Refine

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

Author: begeekmyfriend

091_decode_ways/decode_ways.c

@@ -2,29 +2,29 @@
 #include <stdlib.h>
 #include <string.h>
 
-static int numDecodings(char* s) {
+
+static int numDecodings(char* s)
+{
     int len = strlen(s);
     if (len == 0) {
         return 0;
     }
 
-    int dp[len + 1];
-    memset(dp, 0, (len + 1) * sizeof(int));
-
-    dp[0] = 1; 
-    dp[1] = s[0] == '0' ? 0 : 1;
+    int a = 1;
+    int b = s[0] == '0' ? 0 : a;
+    int c = b;
+    /* DP: How many counts in sequence c = f(a, b) and c counts s[i - 1] */
     for (int i = 2; i <= len; i++) {
-        if (s[i - 1] != '0') {
-            dp[i] = dp[i - 1];
-        }
-
+        c = s[i - 1] == '0' ? 0 : b;
         int num = (s[i - 2] - '0') * 10 + (s[i - 1] - '0');
         if (num >= 10 && num <= 26) {
-            dp[i] += dp[i - 2];
+            c += a;
         }
+        a = b;
+        b = c;
     }
 
-    return dp[len];
+    return c;
 }
 
 int main(int argc, char **argv)

120_triangle/triangle.c

@@ -3,6 +3,7 @@
 #include <stdbool.h>
 #include <string.h>
 
+
 static int dfs(int** triangle, int row_size, int *col_sizes,
                int row, int col, int **sums, bool **passes)
 {
@@ -14,24 +15,23 @@ static int dfs(int** triangle, int row_size, int *col_sizes,
         int s1 = dfs(triangle, row_size, col_sizes, row + 1, col, sums, passes);
         int s2 = dfs(triangle, row_size, col_sizes, row + 1, col + 1, sums, passes);
         sums[row][col] = triangle[row][col] + (s1 < s2 ? s1 : s2);
+        /* Set pass marks in backtracing as the paths are overlapped */
         passes[row][col] = true;
         return sums[row][col];
     }
 }
 
-static int minimumTotal(int** triangle, int triangleRowSize, int *triangleColSizes)
+static int minimumTotal(int** triangle, int triangleSize, int *triangleColSizes)
 {
     int i;
-    bool **passes = malloc(triangleRowSize * sizeof(bool *));
-    for (i = 0; i < triangleRowSize; i++) {
+    int **sums = malloc(triangleSize * sizeof(int *));
+    bool **passes = malloc(triangleSize * sizeof(bool *));
+    for (i = 0; i < triangleSize; i++) {
         passes[i] = malloc(triangleColSizes[i]);
         memset(passes[i], false, triangleColSizes[i]);
-    }
-    int **sums = malloc(triangleRowSize * sizeof(int *));
-    for (i = 0; i < triangleRowSize; i++) {
         sums[i] = malloc(triangleColSizes[i] * sizeof(int));
     }
-    return dfs(triangle, triangleRowSize, triangleColSizes, 0, 0, sums, passes);
+    return dfs(triangle, triangleSize, triangleColSizes, 0, 0, sums, passes);
 }
 
 int main(void)

207_course_schedule/course_schedule.c

@@ -3,51 +3,49 @@
 #include <stdbool.h>
 #include <string.h>
 
+
 struct graph_node {
     int req_num;
     int reqs[15];
+    bool touched;
+    bool taken;
 };
 
-static bool dfs(struct graph_node *courses, int id, bool *takens, bool *touched)
+static bool dfs(struct graph_node *courses, int id)
 {
     int i;
-    if (touched[id]) {
+    if (courses[id].touched) {
         return true;
-    } else if (takens[id]) {
+    } else if (courses[id].taken) {
         return false;
     } else {
-        takens[id] = true;
+        courses[id].taken = true;
         for (i = 0; i < courses[id].req_num; i++) {
-            if (!dfs(courses, courses[id].reqs[i], takens, touched)) {
+            if (!dfs(courses, courses[id].reqs[i])) {
                 return false;
             }
         }
-        /* marked as available and no need to traverse next time */
-        touched[id] = true;
-        takens[id] = false;
+        /* If paths overlapped, mark in backtracing for no need to traverse next time */
+        courses[id].touched = true;
+        courses[id].taken = false;
         return true;
     }
 }
 
-static bool canFinish(int numCourses, int** prerequisites, int prerequisitesRowSize, int prerequisitesColSize)
+static bool canFinish(int numCourses, int** prerequisites, int prerequisitesSize, int *prerequisitesColSize)
 {
     int i;
-    bool *takens = malloc(numCourses);
-    bool *touched = malloc(numCourses);
     struct graph_node *courses = malloc(numCourses * sizeof(*courses));
 
     memset(courses, 0, numCourses * sizeof(*courses));
-    memset(takens, false, numCourses * sizeof(bool));
-    memset(touched, false, numCourses * sizeof(bool));
-
-    for (i = 0; i < prerequisitesRowSize; i++) {
+    for (i = 0; i < prerequisitesSize; i++) {
         int id = prerequisites[i][0];
         int req = prerequisites[i][1];
         courses[id].reqs[courses[id].req_num++] = req;
     }
 
     for (i = 0; i < numCourses; i++) {
-        if (!dfs(courses, i, takens, touched)) {
+        if (!dfs(courses, i)) {
             return false;
         }
     }
@@ -59,24 +57,31 @@ int main(void)
 {
     int i, course_num = 6, pair_num = 6;
     int **pairs = malloc(pair_num * sizeof(int *));
+    int *col_sizes = malloc(pair_num * sizeof(int));
     pairs[0] = malloc(2 * sizeof(int));
     pairs[0][0] = 1;
     pairs[0][1] = 0;
+    col_sizes[0] = 2;
     pairs[1] = malloc(2 * sizeof(int));
     pairs[1][0] = 2;
     pairs[1][1] = 1;
+    col_sizes[1] = 2;
     pairs[2] = malloc(2 * sizeof(int));
     pairs[2][0] = 3;
     pairs[2][1] = 2;
+    col_sizes[2] = 2;
     pairs[3] = malloc(2 * sizeof(int));
     pairs[3][0] = 1;
     pairs[3][1] = 3;
+    col_sizes[3] = 2;
     pairs[4] = malloc(2 * sizeof(int));
     pairs[4][0] = 4;
     pairs[4][1] = 0;
+    col_sizes[4] = 2;
     pairs[5] = malloc(2 * sizeof(int));
     pairs[5][0] = 0;
     pairs[5][1] = 5;
-    printf("%s\n", canFinish(course_num, pairs, pair_num, 2) ? "true" : "false");
+    col_sizes[5] = 2;
+    printf("%s\n", canFinish(course_num, pairs, pair_num, col_sizes) ? "true" : "false");
     return 0;
 }

210_course_schedule_ii/course_schedule.c

@@ -3,29 +3,33 @@
 #include <stdbool.h>
 #include <string.h>
 
+
 struct graph_node {
     int req_num;
     int reqs[15];
+    bool touched;
+    bool taken;
 };
 
-static bool dfs(struct graph_node *courses, int id, bool *takens, bool *touched, int *order, int *count)
+static bool dfs(struct graph_node *courses, int id, int *order, int *count)
 {
     int i;
-    if (touched[id]) {
+    if (courses[id].touched) {
         return true;
-    } else if (takens[id]) {
+    } else if (courses[id].taken) {
         return false;
     } else {
-        takens[id] = true;
+        courses[id].taken = true;
         for (i = 0; i < courses[id].req_num; i++) {
-            if (!dfs(courses, courses[id].reqs[i], takens, touched, order, count)) {
+            if (!dfs(courses, courses[id].reqs[i], order, count)) {
                 return false;
             }
         }
-        /* marked as available and no need to traverse next time */
+        /* Record path in backtrace before DFS return */
         order[(*count)++] = id;
-        touched[id] = true;
-        takens[id] = false;
+        /* If paths overlapped, mark in backtracing for no need to traverse next time */
+        courses[id].touched = true;
+        courses[id].taken = false;
         return true;
     }
 }
@@ -34,27 +38,22 @@ static bool dfs(struct graph_node *courses, int id, bool *takens, bool *touched,
  * Return an array of size *returnSize.
  * Note: The returned array must be malloced, assume caller calls free().
  */
-static int *findOrder(int numCourses, int** prerequisites, int prerequisitesRowSize, int prerequisitesColSize, int *returnSize)
+static int *findOrder(int numCourses, int** prerequisites, int prerequisitesSize, int *prerequisitesColSize, int *returnSize)
 {
     int i;
     int *order = malloc(numCourses * sizeof(int));
-    bool *takens = malloc(numCourses);
-    bool *touched = malloc(numCourses);
     struct graph_node *courses = malloc(numCourses * sizeof(*courses));
 
     memset(courses, 0, numCourses * sizeof(*courses));
-    memset(takens, false, numCourses * sizeof(bool));
-    memset(touched, false, numCourses * sizeof(bool));
-
-    for (i = 0; i < prerequisitesRowSize; i++) {
+    for (i = 0; i < prerequisitesSize; i++) {
         int id = prerequisites[i][0];
         int req = prerequisites[i][1];
         courses[id].reqs[courses[id].req_num++] = req;
     }
 
     *returnSize = 0;
     for (i = 0; i < numCourses; i++) {
-        if (!dfs(courses, i, takens, touched, order, returnSize)) {
+        if (!dfs(courses, i, order, returnSize)) {
             *returnSize = 0;
             return order;
         }
@@ -67,6 +66,7 @@ int main(void)
 {
     int i, course_num = 3, pair_num = 1;
     int **pairs = malloc(pair_num * sizeof(int *));
+    int *col_sizes = malloc(pair_num * sizeof(int));
     pairs[0] = malloc(2 * sizeof(int));
     pairs[0][0] = 1;
     pairs[0][1] = 0;
@@ -84,7 +84,7 @@ int main(void)
     //pairs[4][1] = 5;
 
     int count = 0;
-    int *ids = findOrder(course_num, pairs, pair_num, 2, &count);
+    int *ids = findOrder(course_num, pairs, pair_num, col_sizes, &count);
     for (i = 0; i < count; i++) {
         printf("%d ", ids[i]);
     }

236_lowest_common_ancestor_of_a_binary_tree/bst_lca.c

@@ -2,6 +2,7 @@
 #include <stdlib.h>
 #include <stdbool.h>
 
+
 struct TreeNode {
     int val;
     struct TreeNode *left;
@@ -11,24 +12,18 @@ struct TreeNode {
 static struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q)
 {
     if (root == NULL || root == p || root == q) {
+        /* edge cases: if return NULL then no p or q node in this path */
         return root;
     }
 
+    /* l is the LCA in the left branch but not root->left */
     struct TreeNode *l = lowestCommonAncestor(root->left, p, q);
-    if (l != NULL && l != p && l != q) {
-        /* both p and q in left subtree: l->left != NULL && l->right != NULL */
-        return l;
-    }
-
+    /* r is the LCA in the right branch but not root->right */
     struct TreeNode *r = lowestCommonAncestor(root->right, p, q);
-    if (r != NULL && r != p && r != q) {
-        /* both p and q in right subtree: r->left != NULL && r->right != NULL */
-        return r;
-    }
-
     if (l != NULL && r != NULL) {
         return root;
     } else {
+        /* if not return root node, the return value is fixed */
         return l != NULL ? l : r;
     }
 }