feat: 新增回溯和dp两题

Author: sl1673495

动态规划/下降路径最小和-931.js

@@ -0,0 +1,34 @@
+/**
+ * @param {number[][]} A
+ * @return {number}
+ */
+let minFallingPathSum = function (A) {
+  let n = A.length
+
+  let dp = []
+  for (let i = 0; i < n; i++) {
+    dp[i] = []
+  }
+
+  for (let j = 0; j < n; j++) {
+    dp[n - 1][j] = A[n - 1][j]
+  }
+
+  for (let i = n - 2; i >= 0; i--) {
+    for (let j = 0; j < n; j++) {
+      dp[i][j] = Infinity
+      let left = j - 1
+      let right = j + 1
+      let mid = j
+      let nextRowIndexes = [left, mid, right]
+      for (let nextRowIndex of nextRowIndexes) {
+        if (nextRowIndex >= 0 && nextRowIndex < n) {
+          dp[i][j] = Math.min(dp[i][j], A[i][j] + dp[i + 1][nextRowIndex])
+        }
+      }
+    }
+  }
+
+  // 第一行的最小值 可以确定整体的最小路径
+  return Math.min(...dp[0])
+}

递归与回溯/不同路径 III-980.js

@@ -0,0 +1,72 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+let uniquePathsIII = function (grid) {
+  let maxY = grid.length
+  if (!maxY) return 0
+  let maxX = grid[0].length
+
+  let validCellsCount = 0
+  let entry
+  let visited = []
+  for (let y = 0; y < maxY; y++) {
+    visited[y] = []
+    for (let x = 0; x < maxX; x++) {
+      let val = grid[y][x]
+      if (val === 0) {
+        validCellsCount++
+      }
+      if (val === 1) {
+        entry = [y, x]
+      }
+    }
+  }
+
+  let isValid = (y, x) => {
+    return (
+      y >= 0 &&
+      y < maxY &&
+      x >= 0 &&
+      x < maxX &&
+      !visited[y][x] &&
+      grid[y][x] !== -1
+    )
+  }
+
+  let dirs = [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1],
+  ]
+  let res = 0
+
+  let dfs = (y, x, passCount) => {
+    let val = grid[y][x]
+    if (val === 2) {
+      if (passCount === validCellsCount) {
+        res++
+      }
+      return
+    } else if (val === 0) {
+      passCount += 1
+    }
+
+    for (let [diffY, diffX] of dirs) {
+      let nextY = y + diffY
+      let nextX = x + diffX
+      if (isValid(nextY, nextX)) {
+        visited[nextY][nextX] = true
+        dfs(nextY, nextX, passCount)
+        visited[nextY][nextX] = false
+      }
+    }
+  }
+
+  let [entryY, entryX] = entry
+  visited[entryY][entryX] = true
+  dfs(entryY, entryX, 0)
+
+  return res
+}