regular commit

Author: zhang-wen-guang

283.c

@@ -1,13 +1,58 @@
 #include <stdio.h>
+#include <stdlib.h>
 
 /**
  * Return an array of arrays of size *returnSize.
  * Note: The returned array must be malloced, assume caller calls free().
  */
+
+int count = 0;
+
+void swap(int *a, int *b) {
+    int tmp = *a;
+    *a = *b;
+    *b = tmp;
+}
+
+void permuteRecursive(int *nums, int begin, int **res, int numsSize, int *top) {
+    int i;
+
+    if (begin == numsSize) {
+        for (i = 0; i < numsSize; ++i) res[*top][i] = nums[i];
+        (*top)++;
+        return;
+    }
+    for (i = begin; i < numsSize; ++i) {
+        swap(&nums[i], &nums[begin]);
+        permuteRecursive(nums, begin + 1, res, numsSize, top);
+        swap(&nums[i], &nums[begin]);
+    }
+}
 int** permute(int* nums, int numsSize, int* returnSize) {
+    int **res, i = numsSize;
+    int top = 0;
+
+    *returnSize = numsSize;
+    while (--i) (*returnSize) *= i;
+    res = (int **)malloc(sizeof(int *) * (*returnSize));
+    for (i = 0; i < (*returnSize); ++i) res[i] = (int *)malloc(sizeof(int) * numsSize);
+    permuteRecursive(nums, 0, res, numsSize, &top);
+    return res;
 }
 
 int main()
 {
+    int i, j, nums[] = {1, 2, 3};
+    int **res, returnSize;
+
+    res = permute(nums, 3, &returnSize);
+
+    for (i = 0; i < returnSize; ++i) {
+        for (j = 0; j < 3; ++j) {
+            printf("%d\t", res[i][j]);
+        }
+        printf("\n");
+    }
+
     return 0;
 }

290.c

@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+/**
+ * Return an array of arrays of size *returnSize.
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+
+void swap(int * nums, int x,int y)
+{
+    int temp;
+    temp=nums[x];
+    nums[x]=nums[y];
+    nums[y]=temp;
+}
+void perm(int* nums,int index, int l, int **result,int * p)
+{
+    if(index==l)
+    {
+        for(int i=0;i<=l;i++)
+        result[(*p)][i]=nums[i];
+        (*p)++;
+        return;
+    }
+    else
+    {
+        for(int i=index;i<=l;i++)
+        {
+            swap(nums,index,i);
+            perm(nums,index+1,l,result,p);
+            swap(nums,i,index);
+        }
+    }
+}
+int** permute(int* nums, int numsSize, int* returnSize)
+{
+    *returnSize=1;
+    int i,t,j,k=0;
+    int *p =&k;
+    for(i=1;i<=numsSize;i++)
+    *returnSize=*returnSize*i;
+    t=*returnSize;
+    int ** result=(int **)malloc(t * sizeof(int *));
+    for (i=0; i<t; i++)
+    {
+         result[i] = (int *)malloc(numsSize * sizeof(int));
+         for(j=0;j<numsSize;j++)
+         result[i][j]=0;
+    }
+    perm(nums,0,numsSize-1,result,p);
+    return result;
+}
+
+int main()
+{
+    int i, j, nums[] = {1, 2, 3};
+    int **res, returnSize;
+
+    res = permute(nums, 3, &returnSize);
+
+    for (i = 0; i < returnSize; ++i) {
+        for (j = 0; j < 3; ++j) {
+            printf("%d\t", res[i][j]);
+        }
+        printf("\n");
+    }
+
+    return 0;
+}

292.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+
+int minPathSum(int** grid, int gridRowSize, int gridColSize) {
+    int i, res = 0;
+    int tmp1, tmp2;
+
+    if (1 == gridRowSize) {
+        for (i = 0; i < gridColSize; ++i) res += grid[0][i];
+        return res;
+    } else if (1 == gridColSize) {
+        for (i = 0; i < gridRowSize; ++i) res += grid[i][0];
+        return res;
+    } else {
+        tmp1 = minPathSum(grid, gridRowSize, gridColSize - 1);
+        tmp2 = minPathSum(grid, gridRowSize - 1, gridColSize);
+        res = tmp1 < tmp2 ? tmp1 : tmp2;
+        return res + grid[gridRowSize - 1][gridColSize - 1];
+    }
+}
+
+int main()
+{
+    return 0;
+}