Refine

Signed-off-by: begeekmyfriend <[email protected]>

Author: begeekmyfriend

039_combination_sum/combination_sum.c

@@ -2,6 +2,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+
 static void dfs(int *nums, int size, int start, int target, int *stack,
                 int len, int **results, int *count, int *column_sizes)
 {
@@ -17,7 +18,7 @@ static void dfs(int *nums, int size, int start, int target, int *stack,
         for (i = start; i < size; i++) {
             stack[len] = nums[i];
             /* The elements in solution can be duplicate for the purpose of the problem */
-            dfs(nums, size, i, target - nums[i], stack, len + 1, results, column_sizes, count);
+            dfs(nums, size, i, target - nums[i], stack, len + 1, results, count, column_sizes);
         }
     }
 }

040_combination_sum_ii/combination_sum.c

@@ -1,8 +1,10 @@
+#include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <string.h>
 
+
 static int compare(const void *a, const void *b)
 {
     return *(int *) a - *(int *) b;
@@ -20,7 +22,7 @@ static void dfs(int *nums, int size, int start, int target, int *solution,
         column_sizes[*count] = len;
         (*count)++;
     } else {
-        int last = -1;
+        int last = INT_MIN;
         for (i = start; i < size; i++) {
             if (last != nums[i]) {
                 /* No duplicate combinations in different order */

046_permutations/permutations.c

@@ -42,9 +42,10 @@ static void dfs(int *nums, int size, bool *used, int *stack,
         col_size[*count] = size;
         (*count)++;
     } else {
+        /* Reverse order is allowed in different levels, always starts from [0] */
         for (i = 0; i < size; i++) {
             if (!used[i]) {
-                /* */
+                /* Used marks only allows remaining elements in DFS levels */
                 used[i] = true;
                 stack[len] = nums[i];
                 dfs(nums, size, used, stack, len + 1, results, count, col_size);

047_permutations_ii/permutations.c

@@ -18,11 +18,12 @@ static void dfs(int *nums, int size, bool *used, int *stack,
         col_size[*count] = size;
         (*count)++;
     } else {
+        /* Reverse order is allowed in different levels, always starts from [0] */
         for (i = 0; i < size; i++) {
+            /* Used marks only allows remaining elements in DFS levels */
             if (!used[i]) {
-                if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
-                    /* In case that duplicate permutation with same elemements */
-                    /* Used marks allow same elements in different DFS levels */
+                if (i > 0 && !used[i - 1] && nums[i - 1] == nums[i]) {
+                    /* In case that duplicate permutation with same elemements but in different postions */
                     continue;
                 }
                 used[i] = true;
@@ -46,8 +47,8 @@ static int **permute(int* nums, int numsSize, int* returnSize, int **returnColum
     int count = 0, cap = 10000;
     int *stack = malloc(numsSize * sizeof(int));
     int **results = malloc(cap * sizeof(int *));
-    bool *used = malloc(numsSize);
-    memset(used, false, numsSize);
+    bool *used = malloc(numsSize * sizeof(bool));
+    memset(used, false, numsSize * sizeof(bool));
     *returnSize = 0;
     *returnColumnSize = malloc(cap * sizeof(int));
     dfs(nums, numsSize, used, stack, 0, results, returnSize, *returnColumnSize);

055_jump_game/jump_game.c

@@ -12,6 +12,7 @@ static bool canJump(int* nums, int numsSize)
     int i, pos = 0;
     for (i = 0; i < numsSize - 1; i++) {
         if (pos < i || pos >= numsSize - 1) {
+            /* pos < i means nums[pos] == 0 */
             break;
         }
         /* if all positive number it always can arrive. */

056_merge_intervals/merge_intervals.c

@@ -36,6 +36,7 @@ int** merge(int** intervals, int intervalsSize, int* intervalsColSize, int* retu
             intervals[len][0] = tmp[i * 2];
             intervals[len][1] = tmp[i * 2 + 1];
         } else if (tmp[i * 2 + 1] > intervals[len][1]) {
+            /* merge this interval */
             intervals[len][1] = tmp[i * 2 + 1];
         }
     }

057_insert_interval/insert_interval.c

@@ -35,6 +35,7 @@ int** insert(int** intervals, int intervalsSize, int* intervalsColSize, int* new
             results[len][0] = tmp[i * 2];
             results[len][1] = tmp[i * 2 + 1];
         } else if (tmp[i * 2 + 1] > results[len][1]) {
+            /* merge this interval */
             results[len][1] = tmp[i * 2 + 1];
         }
     }

059_spiral_matrix_ii/spiral_matrix.c

@@ -1,16 +1,22 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+
 /**
- ** Return an array of arrays.
- ** Note: The returned array must be malloced, assume caller calls free().
- **/
-static int** generateMatrix(int n) {
+ * Return an array of arrays of size *returnSize.
+ * The sizes of the arrays are returned as *returnColumnSizes array.
+ * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ */
+static int** generateMatrix(int n, int* returnSize, int** returnColumnSizes)
+{
     int i;
     int **matrix = malloc(n * sizeof(int *));
     int *nums = malloc(n * n * sizeof(int));
+    *returnSize = n;
+    *returnColumnSizes = malloc(n * sizeof(int));
     for (i = 0; i < n; i++) {
         matrix[i] = &nums[i * n];
+        (*returnColumnSizes)[i] = n;
     }
 
     int direction = 0;
@@ -60,9 +66,10 @@ int main(int argc, char **argv)
         exit(-1);
     }
 
-    int i, j;
+    int i, j, count;
     int n = atoi(argv[1]);
-    int **matrix = generateMatrix(n);
+    int *col_sizes;
+    int **matrix = generateMatrix(n, &count, &col_sizes);
     for (i = 0; i < n; i++) {
         for (j = 0; j < n; j++) {
             printf("%d ", matrix[i][j]);