Refine

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

Author: begeekmyfriend

039_combination_sum/combination_sum.c

@@ -6,14 +6,17 @@ static void dfs(int *nums, int size, int start, int target, int *stack,
                 int len, int **results, int *count, int *column_sizes)
 {
     int i;
-    if (target == 0) {
+    if (target < 0) {
+        return;
+    } else if (target == 0) {
         results[*count] = malloc(len * sizeof(int));
         memcpy(results[*count], stack, len * sizeof(int));
         column_sizes[*count] = len;
         (*count)++;
-    } else if (target > 0) {
+    } else {
         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);
         }
     }

040_combination_sum_ii/combination_sum.c

@@ -8,29 +8,27 @@ static int compare(const void *a, const void *b)
     return *(int *) a - *(int *) b;
 }
 
-static void dfs(int *nums, int size, int start, int target, int *solution, int len,
-                bool *used, int **results, int *count, int *column_sizes)
+static void dfs(int *nums, int size, int start, int target, int *solution,
+                int len, int **results, int *count, int *column_sizes)
 {
     int i;
-    if (target == 0) {
+    if (target < 0) {
+        return;
+    } else if (target == 0) {
         results[*count] = malloc(len * sizeof(int));
         memcpy(results[*count], solution, len * sizeof(int));
         column_sizes[*count] = len;
         (*count)++;
-    } else if (target > 0) {
+    } else {
+        int last = -1;
         for (i = start; i < size; i++) {
-            if (!used[i]) {
-                if (i > 0 && !used[i - 1] && nums[i - 1] == nums[i]) {
-                    /* Forbid same elements in same level */
-                    /* Used marks allow same elements in different levels */
-                    continue;
-                }
-                used[i] = true;
+            if (last != nums[i]) {
+                /* No duplicate combinations in different order */
                 solution[len] = nums[i];
-                /* i + 1 limits the selecting range in following levels */
-                dfs(nums, size, i + 1, target - nums[i], solution, len + 1, used, results, count, column_sizes);
-                used[i] = false;
+                /* i + 1 limits the candidate range in next levels */
+                dfs(nums, size, i + 1, target - nums[i], solution, len + 1, results, count, column_sizes);
             }
+            last = nums[i];
         }
     }
 }
@@ -46,11 +44,9 @@ static int** combinationSum(int* candidates, int candidatesSize, int target, int
 
     int *solution = malloc(target * sizeof(int));
     int **results = malloc(100 * sizeof(int *));
-    bool *used = malloc(candidatesSize);
-    memset(used, false, candidatesSize);
     *returnColumnSizes = malloc(100 * sizeof(int));
     *returnSize = 0;
-    dfs(candidates, candidatesSize, 0, target, solution, 0, used, results, returnSize, *returnColumnSizes);
+    dfs(candidates, candidatesSize, 0, target, solution, 0, results, returnSize, *returnColumnSizes);
     return results;
 }
 

046_permutations/permutations.c

@@ -3,13 +3,35 @@
 #include <stdbool.h>
 #include <string.h>
 
+#if 0
 static void swap(int *a, int *b)
 {
     int tmp = *a;
     *a = *b;
     *b = tmp;
 }
 
+static void dfs(int *nums, int size, int start,
+                int **results, int *count, int *col_size)
+{
+    int i;
+    if (start == size) {
+        results[*count] = malloc(size * sizeof(int));
+        memcpy(results[*count], nums, size * sizeof(int));
+        col_size[*count] = size;
+        (*count)++;
+    } else {
+        for (i = start; i < size; i++) {
+            /* A swap can make a new permutation but not be listed in order */
+            swap(nums + start, nums + i);
+            dfs(nums, size, start + 1, results, count, col_size);
+            /* restore the array in backtrace */
+            swap(nums + start, nums + i);
+        }
+    }
+}
+#endif
+
 static void dfs(int *nums, int size, bool *used, int *stack,
                 int len, int **results, int *count, int *col_size)
 {
@@ -22,6 +44,7 @@ static void dfs(int *nums, int size, bool *used, int *stack,
     } else {
         for (i = 0; i < size; i++) {
             if (!used[i]) {
+                /* */
                 used[i] = true;
                 stack[len] = nums[i];
                 dfs(nums, size, used, stack, len + 1, results, count, col_size);

047_permutations_ii/permutations.c

@@ -21,8 +21,8 @@ static void dfs(int *nums, int size, bool *used, int *stack,
         for (i = 0; i < size; i++) {
             if (!used[i]) {
                 if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
-                    /* Forbid same elements on same level */
-                    /* Used marks allow same elements in different levels */
+                    /* In case that duplicate permutation with same elemements */
+                    /* Used marks allow same elements in different DFS levels */
                     continue;
                 }
                 used[i] = true;

051_n_queens/n_queens.c

@@ -65,7 +65,6 @@ static void dfs(int n, int row, int *stack, char ***solutions, int *count, int *
             if (row == 0 || !conflict(stack, row, col)) {
                 stack[row] = col;
                 dfs(n, row + 1, stack, solutions, count, col_sizes);
-                continue;
             }
         }
     }

077_combinations/combinations.c

@@ -14,7 +14,6 @@ static void dfs(int n, int k, int start, int *stack, int len,
         (*count)++;
     } else {
         for (i = start; i <= n; i++) {
-            /* No used marks since the order does not matter */
             stack[len] = i;
             dfs(n, k, i + 1, stack, len + 1, results, count, col_sizes);
         }

090_subsets_ii/subsets.c

@@ -1,3 +1,4 @@
+#include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
@@ -8,46 +9,39 @@ static inline int compare(const void *a, const void *b)
     return *(int *) a - *(int *) b;
 }
 
-static void dfs(int *nums, int size, int start, int *buf, int level,
-                bool *used, int **sets, int *count, int *sizes)
+static void dfs(int *nums, int size, int start, int *buf,
+                int level, int **sets, int *count, int *sizes)
 {
-    int i;
+    int i, last = INT_MIN;
     sets[*count] = malloc(level * sizeof(int));
     memcpy(sets[*count], buf, level * sizeof(int));
     sizes[*count] = level;
     (*count)++;
     for (i = start; i < size; i++) {
-        if (!used[i]) {
-            if (i > 0 && !used[i - 1] && nums[i - 1] == nums[i]) {
-                /* Forbid same elements on same level */
-                /* Used marks allow same elements in different levels */
-                continue;
-            }
-            used[i] = true;
+        if (last != nums[i]) {
+            /* No duplicate candidate elements at same level position */
             buf[level] = nums[i];
-            /* i + 1 limits the selecting range in following levels */
-            dfs(nums, size, i + 1, buf, level + 1, used, sets, count, sizes);
-            used[i] = false;
+            /* i + 1 limits the selecting range in next levels */
+            dfs(nums, size, i + 1, buf, level + 1, sets, count, sizes);
         }
+        last = nums[i];
     }
 }
 
 /**
  ** 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().
+ ** Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  **/
-static int** subsets(int* nums, int numsSize, int* returnSize, int** returnColumnSizes)
+static int** subsetsWithNoDup(int* nums, int numsSize, int* returnSize, int** returnColumnSizes)
 {
     qsort(nums, numsSize, sizeof(int), compare);
     int capacity = 5000;
     int **sets = malloc(capacity * sizeof(int *));
     int *buf = malloc(numsSize * sizeof(int));
-    bool *used = malloc(numsSize);
-    memset(used, false, numsSize);
     *returnColumnSizes = malloc(capacity * sizeof(int));
     *returnSize = 0;
-    dfs(nums, numsSize, 0, buf, 0, used, sets, returnSize, *returnColumnSizes);
+    dfs(nums, numsSize, 0, buf, 0, sets, returnSize, *returnColumnSizes);
     return sets;
 }