update

Author: tangweikun

CATEGORY.md

@@ -6,44 +6,8 @@ https://github.com/garciparedes
 
 https://garciparedes.me/#headers
 
-- Breadth First Search +5
-
-  - [ ] 107
-  - [ ] 542
-  - [ ] 801
-  - [ ] 877
-
-- Depth First Search +8
-
-  - [ ] 111
-  - [ ] 199
-  - [ ] 337
-  - [ ] 491
-  - [ ] 494
-  - [ ] 513
-  - [ ] 515
-  - [ ] 542
-
-- Dynamic Programming +7
-
-  - [ ] 1143
-  - [ ] 5
-  - [ ] 91
-  - [ ] 152
-    - [ ] 264
-    - [ ] 279
-    - [ ] 300
-    - [ ] 309
-      - [ ] 322
-        - [ ] 343
-        - [ ] 357
-        - [ ] 376
-
 - Greedy
 
-  - [ ] 134
-  - [ ] 376
-  - [ ] 392
   - [ ] 402
   - [ ] 406
   - [ ] 435
@@ -116,3 +80,27 @@ https://garciparedes.me/#headers
       - [ ] 78
         - [ ] 306
           - [ ] 872
+
+- Breadth First Search +5
+
+  - [ ] 107
+    - [ ] 877
+
+- Depth First Search +8
+
+  - [ ] 337
+
+- Dynamic Programming +7
+
+  - [ ] 5
+  - [ ] 91
+  - [ ] 152
+    - [ ] 264
+    - [ ] 279
+    - [ ] 300
+    - [ ] 309
+      - [ ] 322
+        - [ ] 343
+        - [ ] 357
+        - [ ] 376
+          - [ ] 1143

src/111-minimum-depth-of-binary-tree/20210730.js

@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var minDepth = function (root) {
+  if (!root) return 0;
+  let res = Infinity;
+  dfs(root, 0);
+  return res;
+
+  function dfs(node, preLevel) {
+    if (!node) return;
+
+    if (!node.left && !node.right) {
+      res = Math.min(res, preLevel + 1);
+      return;
+    }
+
+    dfs(node.left, preLevel + 1);
+    dfs(node.right, preLevel + 1);
+  }
+};

src/134-gas-station/0730.js

@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} gas
+ * @param {number[]} cost
+ * @return {number}
+ */
+var canCompleteCircuit = function (gas, cost) {
+  let res = -1;
+  const len = gas.length;
+
+  for (let i = 0; i < len; i++) {
+    let count = 0;
+    let sum = 0;
+
+    while (count < len) {
+      sum += gas[(i + count) % len] - cost[(i + count) % len];
+      count++;
+      if (sum < 0) {
+        break;
+      }
+    }
+    if (sum >= 0) {
+      return i;
+    }
+  }
+
+  return res;
+};
+
+console.log(canCompleteCircuit([1, 2, 3, 4, 5], [3, 4, 5, 1, 2]));

src/199-binary-tree-right-side-view/20210730.js

@@ -0,0 +1,24 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var rightSideView = function (root) {
+  const res = [];
+  dfs(root, 0);
+  return res;
+
+  function dfs(node, level) {
+    if (!node) return;
+
+    res[level] = node.val;
+    dfs(node.left, level + 1);
+    dfs(node.right, level + 1);
+  }
+};

src/337-house-robber-iii/index.js

@@ -1,13 +1,13 @@
 // HELP:
 
-export const rob = root => {
+var rob = (root) => {
   const money = dfs(root);
   return Math.max(money[0], money[1]);
-};
 
-function dfs(root) {
-  if (!root) return [0, 0];
-  const L = dfs(root.left);
-  const R = dfs(root.right);
-  return [Math.max(L[0], L[1]) + Math.max(R[0], R[1]), root.val + L[0] + R[0]];
-}
+  function dfs(root) {
+    if (!root) return [0, 0];
+    const L = dfs(root.left);
+    const R = dfs(root.right);
+    return [Math.max(L[0], L[1]) + Math.max(R[0], R[1]), root.val + L[0] + R[0]];
+  }
+};

src/392-is-subsequence/0730.js

@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isSubsequence = function (s, t) {
+  let start = 0;
+  for (let char of s) {
+    let flag = false;
+    for (let i = start; i < t.length; i++) {
+      if (char === t[i]) {
+        start = i + 1;
+        flag = true;
+        break;
+      }
+    }
+
+    if (!flag) return false;
+  }
+
+  return true;
+};

src/491-increasing-subsequences/20210730.js

@@ -0,0 +1,29 @@
+// HELP:
+[1, 4, 6, 7];
+
+const findSubsequences = function (nums) {
+  let res = [];
+  dfs(nums, []);
+  return res;
+
+  function dfs(arr, pre) {
+    if (arr.length === 0) {
+      if (pre.length >= 2) {
+        res.push(pre);
+      }
+
+      return;
+    }
+    let i = 1;
+    while (i < arr.length && arr[i] === arr[i - 1]) {
+      i++;
+    }
+    dfs(arr.slice(i), pre);
+
+    if (arr[0] >= pre[pre.length - 1] || pre.length === 0) {
+      dfs(arr.slice(1), [...pre, arr[0]]);
+    }
+  }
+};
+
+console.log(findSubsequences([4, 6, 7, 7]));

src/494-target-sum/index.js

@@ -1,44 +1,22 @@
-// export const findTargetSumWays = (nums: number[], target: number): any => {
-//   if (nums.length === 1) {
-//     if (nums[0] === 0 && target === 0) return 2
-//     if (nums[0] === Math.abs(target)) return 1
-//     return 0
-//   }
-
-//   return (
-//     findTargetSumWays(
-//       nums.slice(0, nums.length - 1),
-//       target + nums[nums.length - 1],
-//     ) +
-//     findTargetSumWays(
-//       nums.slice(0, nums.length - 1),
-//       target - nums[nums.length - 1],
-//     )
-//   )
-// }
-
-// HELP:
-
-export const findTargetSumWays = (nums, S) => {
-  let sum = 0;
-  for (let i = 0; i < nums.length; i++) {
-    sum += nums[i];
-  }
-
-  if (sum < S || (sum + S) % 2 !== 0) {
-    return 0;
-  }
-
-  const target = (S + sum) / 2;
-  const dp = [];
-  for (let i = 0; i <= target; i++) {
-    dp[i] = 0;
-  }
-  dp[0] = 1;
-  for (let i = 0; i < nums.length; i++) {
-    for (let j = target; j >= nums[i]; j--) {
-      dp[j] += dp[j - nums[i]];
-    }
-  }
-  return dp[target];
-};
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var findTargetSumWays = function (nums, target) {
+  let res = 0;
+  dfs(0, 0);
+  return res;
+
+  function dfs(preSum, index) {
+    if (index === nums.length) {
+      if (preSum === target) {
+        res++;
+      }
+      return;
+    }
+
+    dfs(preSum - nums[index], index + 1);
+    dfs(preSum + nums[index], index + 1);
+  }
+};

src/513-find-bottom-left-tree-value/20210730.js

@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var findBottomLeftValue = function (root) {
+  const res = [];
+  dfs(root, 0);
+  return res[res.length - 1];
+
+  function dfs(node, level) {
+    if (!node) return;
+
+    if (res[level] === undefined) {
+      res[level] = node.val;
+    }
+
+    dfs(node.left, level + 1);
+    dfs(node.right, level + 1);
+  }
+};

src/515-find-largest-value-in-each-tree-row/0730.js

@@ -0,0 +1,12 @@
+const largestValues = (root) => {
+  const res = [];
+  dfs(root, 0);
+  return res;
+
+  function dfs(node, level) {
+    if (!node) return;
+    res[level] = res[level] === undefined ? node.val : Math.max(res[level], node.val);
+    dfs(node.left, level + 1);
+    dfs(node.right, level + 1);
+  }
+};