✨ dynamic problem

Author: tangweikun

CATEGORY.md

@@ -60,3 +60,15 @@ https://labuladong.gitbook.io/algo/di-ling-zhang-bi-du-xi-lie/gitbook
 https://github.com/garciparedes
 
 https://garciparedes.me/#headers
+
+- 动态规划
+
+  - [ ] 5
+  - [x] 53
+  - [x] 62
+  - [x] 64
+  - [x] 70
+  - [ ] 91
+  - [x] 120
+  - [ ] 121
+  - [ ] 152

src/120-triangle/20210602.js

@@ -0,0 +1,31 @@
+/**
+ * @param {number[][]} triangle
+ * @return {number}
+ */
+var minimumTotal = function (triangle) {
+  const dp = Array(triangle.length);
+
+  for (let i = 0; i < triangle.length; i++) {
+    dp[i] = [];
+    for (let j = 0; j < i + 1; j++) {
+      if (i === 0) {
+        dp[i][j] = Number(triangle[i][j]);
+        continue;
+      }
+      if (j === 0) {
+        dp[i][j] = ~~dp[i - 1][j] + Number(triangle[i][j]);
+        continue;
+      }
+      if (j === i) {
+        dp[i][j] = ~~dp[i - 1][j - 1] + Number(triangle[i][j]);
+        continue;
+      }
+      dp[i][j] =
+        Math.min(~~dp[i - 1][j - 1], ~~dp[i - 1][j]) + Number(triangle[i][j]);
+    }
+  }
+
+  return Math.min(...dp[triangle.length - 1]);
+};
+
+minimumTotal([[2], [3, 4], [6, 5, 7], [4, 1, 8, 3]]);

src/121-best-time-to-buy-and-sell-stock/20210602.ts

@@ -0,0 +1,14 @@
+// Time Complexity O(n) [Only a single pass is needed.]
+// Space Complexity O(1)  [Only two variables are used.]
+
+function maxProfit(prices) {
+  let res = -Infinity;
+  let buy = Infinity;
+
+  for (let i = 0; i < prices.length; i++) {
+    res = Math.max(res, prices[i] - buy);
+    buy = Math.min(buy, prices[i]);
+  }
+
+  return Math.max(res, 0);
+}

src/53-maximum-subarray/20210602.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxSubArray = function (nums) {
+  let max = -Infinity;
+  let pre = 0;
+
+  for (let i = 0; i < nums.length; i++) {
+    pre = Math.max(nums[i], pre + nums[i]);
+    max = Math.max(max, pre);
+  }
+
+  return max;
+};

src/62-unique-paths/20210602.js

@@ -0,0 +1,11 @@
+function uniquePaths(m, n) {
+  let dp = Array(m).fill(Array(n).fill(1));
+
+  for (let i = 1; i < m; i++) {
+    for (let j = 1; j < n; j++) {
+      dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+    }
+  }
+
+  return dp[m - 1][n - 1];
+}

src/64-minimum-path-sum/20210602.ts

@@ -0,0 +1,21 @@
+function minPathSum(grid) {
+  const m = grid.length;
+  const n = grid[0].length;
+  const dp = Array(m).fill(Array(n));
+
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      if (i === 0) {
+        dp[i][j] = ~~dp[i][j - 1] + grid[i][j];
+        continue;
+      }
+      if (j === 0) {
+        dp[i][j] = ~~dp[i - 1][j] + grid[i][j];
+        continue;
+      }
+      dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
+    }
+  }
+
+  return dp[m - 1][n - 1];
+}

src/70-climbing-stairs/20210602.js

@@ -0,0 +1,20 @@
+// Approach: Fibonacci Number
+// Time Complexity O(N)
+// Space Complexity O(1)
+
+// Approach: Fibonacci Number
+// Time Complexity O(N)
+// Space Complexity O(1)
+
+function getClimbingWays(numOfStairs) {
+  const dp = Array(numOfStairs).fill(0);
+  for (let i = 0; i < numOfStairs; i++) {
+    if (i < 2) {
+      dp[i] = i + 1;
+      continue;
+    }
+    dp[i] = dp[i - 1] + dp[i - 2];
+  }
+
+  return dp[numOfStairs - 1];
+}