Update comments

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

Author: begeekmyfriend

0042_trapping_rain_water/trap_water.c

@@ -1,6 +1,31 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#if 0
+static int trap(int* height, int heightSize)
+{
+    int i, res = 0;
+    int *lmax = malloc(heightSize * sizeof(int));
+    int *rmax = malloc(heightSize * sizeof(int));
+
+    lmax[0] = height[0];
+    rmax[heightSize - 1] = height[heightSize - 1];
+
+    for (i = 1; i < heightSize; i++) {
+        lmax[i] = height[i] > lmax[i - 1]  ? height[i] : lmax[i - 1] ;
+    }
+
+    for (i = heightSize - 2; i >= 0; i--) {
+        rmax[i] = height[i] > rmax[i + 1]  ? height[i] : rmax[i + 1] ;
+    }
+
+    for (i = 1; i < heightSize - 1; i++) {
+        res += (lmax[i]  < rmax[i]  ? lmax[i]  : rmax[i] ) - height[i];
+    }
+
+    return res;
+}
+#endif
 
 static int trap(int* height, int heightSize)
 {
@@ -12,13 +37,15 @@ static int trap(int* height, int heightSize)
     int r = heightSize - 1, rmax = 0;
     while (l < r) {
         if (height[l] < height[r]) {
+            /* Only lmax is needed for lmax < rmax here */
             if (height[l] > lmax) {
                 lmax = height[l];
             } else {
                 res += lmax - height[l];
             }
             l++;
         } else {
+            /* Only rmax is needed for rmax < lmax here */
             if (height[r] > rmax) {
                 rmax = height[r];
             } else {

0042_trapping_rain_water/trap_water.cc

@@ -13,13 +13,15 @@ class Solution {
         int right = height.size() - 1, right_max = 0;
         while (left < right) {
             if (height[left] < height[right]) {
+                /* Only lmax is needed for lmax < rmax here */
                 if (height[left] > left_max) {
                     left_max = height[left];
                 } else {
                     res += left_max - height[left];
                 }
                 left++;
             } else {
+                /* Only rmax is needed for rmax < lmax here */
                 if (height[right] > right_max) {
                     right_max = height[right];
                 } else {

0084_largest_rectangle_in_histogram/rect_in_histogram.c

@@ -3,33 +3,33 @@
 
 static int largestRectangleArea(int* heights, int heightsSize)
 {
-    int *indexes = malloc(heightsSize * sizeof(int));
-    int *left = malloc(heightsSize * sizeof(int));
-    int *right = malloc(heightsSize * sizeof(int));
+    int *idx_stk = malloc(heightsSize * sizeof(int));
+    int *lmax = malloc(heightsSize * sizeof(int));
+    int *rmax = malloc(heightsSize * sizeof(int));
 
     int i, pos = 0;
     for (i = 0; i < heightsSize; i++) {
-        /* monotonous increasing stack */
-        while (pos > 0 && heights[indexes[pos - 1]] >= heights[i]) {
+        /* keep monotonous increasing stack */
+        while (pos > 0 && heights[i] < heights[idx_stk[pos - 1]]) {
             pos--;
         }
-        left[i] = pos == 0 ? -1 : indexes[pos - 1];
-        indexes[pos++] = i;
+        lmax[i] = pos == 0 ? -1 : idx_stk[pos - 1];
+        idx_stk[pos++] = i;
     }
 
     pos = 0;
     for (i = heightsSize - 1; i >= 0; i--) {
-        /* monotonous increasing stack */
-        while (pos > 0 && heights[indexes[pos - 1]] >= heights[i]) {
+        /* keep monotonous increasing stack */
+        while (pos > 0 && heights[i] < heights[idx_stk[pos - 1]]) {
             pos--;
         }
-        right[i] = pos == 0 ? heightsSize : indexes[pos - 1];
-        indexes[pos++] = i;
+        rmax[i] = pos == 0 ? heightsSize : idx_stk[pos - 1];
+        idx_stk[pos++] = i;
     }
 
     int max_area = 0;
     for (i = 0; i < heightsSize; i++) {
-        int area = heights[i] * (right[i] - left[i] - 1);
+        int area = heights[i] * (rmax[i] - lmax[i] - 1);
         max_area = area > max_area ? area : max_area;
     }
 

0085_maximal_rectangle/maximal_rectangle.c

@@ -10,49 +10,49 @@ static inline int max(int a, int b)
 
 static int area_calc(int *heights, int size)
 {
-    int *indexes = malloc(size * sizeof(int));
-    int *lhist = malloc(size * sizeof(int));
-    int *rhist = malloc(size * sizeof(int));
+    int *idx_stk = malloc(size * sizeof(int));
+    int *lmax = malloc(size * sizeof(int));
+    int *rmax = malloc(size * sizeof(int));
 
     int i, pos = 0;
     for (i = 0; i < size; i++) {
-        /* squeeze to keep monotonous increasing histograms */
-        while (pos > 0 && heights[indexes[pos - 1]] >= heights[i]) {
+        /* keep monotonous increasing maxograms */
+        while (pos > 0 && heights[i] < heights[idx_stk[pos - 1]]) {
             pos--;
         }
-        lhist[i] = pos == 0 ? -1 : indexes[pos - 1];
-        indexes[pos++] = i;
+        lmax[i] = pos == 0 ? -1 : idx_stk[pos - 1];
+        idx_stk[pos++] = i;
     }
 
     pos = 0;
     for (i = size - 1; i >= 0; i--) {
-        /* squeeze to keep monotonous increasing histograms */
-        while (pos > 0 && heights[indexes[pos - 1]] >= heights[i]) {
+        /* keep monotonous increasing maxograms */
+        while (pos > 0 && heights[i] < heights[idx_stk[pos - 1]]) {
             pos--;
         }
-        rhist[i] = pos == 0 ? size : indexes[pos - 1];
-        indexes[pos++] = i;
+        rmax[i] = pos == 0 ? size : idx_stk[pos - 1];
+        idx_stk[pos++] = i;
     }
 
     int max_area = 0;
     for (i = 0; i < size; i++) {
-        int area = heights[i] * (rhist[i] - lhist[i] - 1);
+        int area = heights[i] * (rmax[i] - lmax[i] - 1);
         max_area = max(area, max_area);
     }
 
     return max_area;
 }
 
-static int maximalRectangle(char** matrix, int matrixRowSize, int matrixColSize)
+static int maximalRectangle(char** matrix, int matrixSize, int* matrixColSize)
 {
     int i, j, max_area = 0;
-    int *heights = malloc(matrixColSize * sizeof(int));
-    memset(heights, 0, matrixColSize * sizeof(int));
-    for (i = 0; i < matrixRowSize; i++) {
-        for (j = 0; j < matrixColSize; j++) {
+    int *heights = malloc(matrixColSize[0] * sizeof(int));
+    memset(heights, 0, matrixColSize[0] * sizeof(int));
+    for (i = 0; i < matrixSize; i++) {
+        for (j = 0; j < matrixColSize[i]; j++) {
             heights[j] = matrix[i][j] == '1' ? heights[j] + 1 : 0;
         }
-        max_area = max(max_area, area_calc(heights, matrixColSize));
+        max_area = max(max_area, area_calc(heights, matrixColSize[i]));
     }
     return max_area;
 }
@@ -68,9 +68,11 @@ int main(int argc, char **argv)
     int i, j;
     int row_size = argc - 1;
     int col_size = strlen(argv[1]);
+    int *cols = malloc(row_size * sizeof(int));
     for (i = 0; i < row_size; i++) {
+        cols[i] = strlen(argv[1]);
         printf("%s\n", argv[i + 1]);
     }
-    printf("%d\n", maximalRectangle(argv + 1, argc - 1, strlen(argv[1])));
+    printf("%d\n", maximalRectangle(argv + 1, argc - 1, cols));
     return 0;
 }