Refine

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

Author: begeekmyfriend

039_combination_sum/combination_sum.c

@@ -3,7 +3,7 @@
 #include <string.h>
 
 static void dfs(int *nums, int size, int start, int target, int *stack,
-                int len, int **results, int *column_sizes, int *count)
+                int len, int **results, int *count, int *column_sizes)
 {
     int i;
     if (target == 0) {
@@ -24,17 +24,17 @@ static void dfs(int *nums, int size, int start, int target, int *stack,
 
 /**
  ** Return an array of arrays of size *returnSize.
- ** The sizes of the arrays are returned as *columnSizes array.
- ** Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ ** The sizes of the arrays are returned as *returnColumnSizes array.
+ ** Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  **/
-static int** combinationSum(int* candidates, int candidatesSize, int target, int** columnSizes, int* returnSize)
+static int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int **returnColumnSizes)
 {
-    int cap = 100;
-    int *stack = malloc(target * sizeof(int));
+    int cap = 200;
+    int *stack = malloc(candidatesSize * sizeof(int));
     int **results = malloc(cap * sizeof(int *));
-    *columnSizes = malloc(cap * sizeof(int));
+    *returnColumnSizes = malloc(cap * sizeof(int));
     *returnSize = 0;
-    dfs(candidates, candidatesSize, 0, target, stack, 0, results, *columnSizes, returnSize);
+    dfs(candidates, candidatesSize, 0, target, stack, 0, results, returnSize, *returnColumnSizes);
     return results;
 }
 
@@ -53,7 +53,7 @@ int main(int argc, char **argv)
     }
 
     int *sizes;
-    int **lists = combinationSum(nums, argc - 2, target, &sizes, &count);
+    int **lists = combinationSum(nums, argc - 2, target, &count, &sizes);
     for (i = 0; i < count; i++) {
         for (j = 0; j < sizes[i]; j++) {
             printf("%d ", lists[i][j]);

040_combination_sum_ii/combination_sum.c

@@ -9,7 +9,7 @@ static int compare(const void *a, const void *b)
 }
 
 static void dfs(int *nums, int size, int start, int target, int *solution, int len,
-                bool *used, int **results, int *column_sizes, int *count)
+                bool *used, int **results, int *count, int *column_sizes)
 {
     int i;
     if (target == 0) {
@@ -23,7 +23,7 @@ static void dfs(int *nums, int size, int start, int target, int *solution, int l
                 if (i > 0 && !used[i - 1] && nums[i - 1] == nums[i]) continue;
                 used[i] = true;
                 solution[len] = nums[i];
-                dfs(nums, size, i + 1, target - nums[i], solution, len + 1, used, results, column_sizes, count);
+                dfs(nums, size, i + 1, target - nums[i], solution, len + 1, used, results, count, column_sizes);
                 used[i] = false;
             }
         }
@@ -32,20 +32,20 @@ static void dfs(int *nums, int size, int start, int target, int *solution, int l
 
 /**
  ** Return an array of arrays of size *returnSize.
- ** The sizes of the arrays are returned as *columnSizes array.
- ** Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
+ ** The sizes of the arrays are returned as *returnColumnSizes array.
+ ** Note: Both returned array and *returnColumnSizes array must be malloced, assume caller calls free().
  **/
-static int** combinationSum(int* candidates, int candidatesSize, int target, int** columnSizes, int* returnSize)
+static int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes)
 {
     qsort(candidates, candidatesSize, sizeof(int), compare);
 
     int *solution = malloc(target * sizeof(int));
     int **results = malloc(100 * sizeof(int *));
     bool *used = malloc(candidatesSize);
     memset(used, false, candidatesSize);
-    *columnSizes = malloc(100 * sizeof(int));
+    *returnColumnSizes = malloc(100 * sizeof(int));
     *returnSize = 0;
-    dfs(candidates, candidatesSize, 0, target, solution, 0, used, results, *columnSizes, returnSize);
+    dfs(candidates, candidatesSize, 0, target, solution, 0, used, results, returnSize, *returnColumnSizes);
     return results;
 }
 
@@ -64,7 +64,7 @@ int main(int argc, char **argv)
     }
 
     int *sizes; 
-    int **lists = combinationSum(nums, argc - 2, target, &sizes, &count);
+    int **lists = combinationSum(nums, argc - 2, target, &count, &sizes);
     for (i = 0; i < count; i++) {
         for (j = 0; j < sizes[i]; j++) {
             printf("%d ", lists[i][j]);

042_trapping_rain_water/trap_water.c

@@ -1,49 +1,45 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+
+static inline int max(int a, int b)
+{
+    return a > b ? a : b;
+}
+
+static inline int min(int a, int b)
+{
+    return a < b ? a : b;
+}
+
 static int trap(int* height, int heightSize)
 {
-    if (heightSize < 2) {
+    if (heightSize < 1) {
         return 0;
     }
 
-    int i, j, top0 = -1, top1 = -1, sum = 0, level = 0;
-    for (i = 0; i < heightSize; i++) {
-        if (height[i] > 0) {
-            top0 = i;
-            break;
-        }
+    int i;
+    int *lh = malloc(heightSize * sizeof(int));
+    int *rh = malloc(heightSize * sizeof(int));
+
+    /* restore the max height in the left side of [i] (included) */
+    lh[0] = height[0];
+    for (i = 1; i < heightSize; i++) {
+        lh[i] = max(height[i], lh[i - 1]);
     }
 
-    while (i < heightSize) {
-        top1 = -1;
-        for (j = i + 1; j < heightSize; j++) {
-            if (height[j] >= height[j - 1]) {
-                if (top1 < 0 || height[j] >= height[top1]) {
-                    top1 = j;
-                }
-                if (height[j] >= height[top0]) {
-                    break;
-                }
-            }
-        }
-
-        if (top1 >= 0) {
-            int level = height[top0] < height[top1] ? height[top0] : height[top1];
-            while (i < top1) {
-                if (level > height[i]) {
-                    sum += level - height[i];
-                }
-                i++;
-            }
-            top0 = top1;
-            i = top1;
-        } else {
-            i = j;
-        }
+    /* restore the max height in the right side of [i] (included) */
+    rh[heightSize - 1] = height[heightSize - 1];
+    for (i = heightSize - 2; i >= 0; i--) {
+        rh[i] = max(height[i], rh[i + 1]);
+    }
+
+    int capacity = 0;
+    for (i = 0; i < heightSize; i++) {
+        capacity += min(lh[i], rh[i]) - height[i];
     }
 
-    return sum;
+    return capacity;
 }
 
 int main(int argc, char **argv)