feat: add solutions to lc problem: No.1575

No.1575.Count All Possible Routes

Author: yanglbme

solution/1000-1099/1032.Stream of Characters/Solution.py

@@ -25,7 +25,6 @@ def search(self, w: List[str]) -> bool:
 
 
 class StreamChecker:
-
     def __init__(self, words: List[str]):
         self.trie = Trie()
         self.cs = []
@@ -35,7 +34,8 @@ def __init__(self, words: List[str]):
 
     def query(self, letter: str) -> bool:
         self.cs.append(letter)
-        return self.trie.search(self.cs[-self.limit:])
+        return self.trie.search(self.cs[-self.limit :])
+
 
 # Your StreamChecker object will be instantiated and called as such:
 # obj = StreamChecker(words)

solution/1500-1599/1575.Count All Possible Routes/README.md

@@ -68,6 +68,19 @@
 
 **方法一：记忆化搜索**
 
+我们设计一个函数 $dfs(i, k)$，表示从城市 $i$ 出发，剩余汽油量为 $k$ 时，到达目的地 $finish$ 的路径数。那么答案就是 $dfs(start, fuel)$。
+
+函数 $dfs(i, k)$ 的计算过程如下：
+
+-   如果 $k \lt 0$ 或者 $|locations[i] - locations[finish]| \gt k$，那么返回 $0$。
+-   如果 $i = finish$，那么答案路径数初始时为 $1$，否则为 $0$。
+-   然后，我们遍历所有城市 $j$，如果 $j \ne i$，那么我们可以从城市 $i$ 移动到城市 $j$，此时剩余汽油量为 $k - |locations[i] - locations[j]|$，那么我们可以将答案路径数加上 $dfs(j, k - |locations[i] - locations[j]|)$。
+-   最后，我们返回答案路径数。
+
+为了避免重复计算，我们可以使用记忆化搜索。
+
+时间复杂度 $O(n^2 \times fuel)$，空间复杂度 $O(n \times fuel)$。其中 $n$ 为城市数量。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -80,15 +93,16 @@ class Solution:
         self, locations: List[int], start: int, finish: int, fuel: int
     ) -> int:
         @cache
-        def dfs(i, t):
-            if abs(locations[i] - locations[finish]) > t:
+        def dfs(i: int, k: int) -> int:
+            if k < 0 or abs(locations[i] - locations[finish] > k):
                 return 0
-            res = int(i == finish)
-            for j, v in enumerate(locations):
-                if j != i:
-                    if (cost := abs(locations[i] - v)) <= t:
-                        res += dfs(j, t - cost)
-            return res % mod
+            ans = int(i == finish)
+            ans += sum(
+                dfs(j, k - abs(locations[i] - x))
+                for j, x in enumerate(locations)
+                if j != i
+            )
+            return ans % mod
 
         mod = 10**9 + 7
         return dfs(start, fuel)
@@ -100,41 +114,34 @@ class Solution:
 
 ```java
 class Solution {
-    private int[][] f;
     private int[] locations;
-    private int target;
-    private static final int MOD = (int) 1e9 + 7;
+    private int finish;
+    private int n;
+    private Integer[][] f;
+    private final int mod = (int) 1e9 + 7;
 
     public int countRoutes(int[] locations, int start, int finish, int fuel) {
-        int n = locations.length;
-        f = new int[n + 1][fuel + 1];
+        n = locations.length;
         this.locations = locations;
-        target = finish;
-        for (int i = 0; i < f.length; ++i) {
-            Arrays.fill(f[i], -1);
-        }
+        this.finish = finish;
+        f = new Integer[n][fuel + 1];
         return dfs(start, fuel);
     }
 
-    private int dfs(int i, int t) {
-        if (f[i][t] != -1) {
-            return f[i][t];
-        }
-        if (Math.abs(locations[i] - locations[target]) > t) {
+    private int dfs(int i, int k) {
+        if (k < 0 || Math.abs(locations[i] - locations[finish]) > k) {
             return 0;
         }
-        int res = i == target ? 1 : 0;
-        for (int j = 0; j < locations.length; ++j) {
+        if (f[i][k] != null) {
+            return f[i][k];
+        }
+        int ans = i == finish ? 1 : 0;
+        for (int j = 0; j < n; ++j) {
             if (j != i) {
-                int cost = Math.abs(locations[i] - locations[j]);
-                if (cost <= t) {
-                    res += dfs(j, t - cost);
-                    res %= MOD;
-                }
+                ans = (ans + dfs(j, k - Math.abs(locations[i] - locations[j]))) % mod;
             }
         }
-        f[i][t] = res;
-        return res;
+        return f[i][k] = ans;
     }
 }
 ```
@@ -144,25 +151,27 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    const int mod = 1e9 + 7;
-
     int countRoutes(vector<int>& locations, int start, int finish, int fuel) {
         int n = locations.size();
-        vector<vector<int>> f(n + 1, vector<int>(fuel + 1, -1));
-        return dfs(start, fuel, locations, finish, f);
-    }
-
-    int dfs(int i, int t, vector<int>& locations, int target, vector<vector<int>>& f) {
-        if (f[i][t] != -1) return f[i][t];
-        if (abs(locations[i] - locations[target]) > t) return 0;
-        int res = i == target;
-        for (int j = 0; j < locations.size(); ++j) {
-            if (j == i) continue;
-            int cost = abs(locations[i] - locations[j]);
-            if (cost <= t) res = (res + dfs(j, t - cost, locations, target, f)) % mod;
-        }
-        f[i][t] = res;
-        return res;
+        int f[n][fuel + 1];
+        memset(f, -1, sizeof(f));
+        const int mod = 1e9 + 7;
+        function<int(int, int)> dfs = [&](int i, int k) -> int {
+            if (k < 0 || abs(locations[i] - locations[finish]) > k) {
+                return 0;
+            }
+            if (f[i][k] != -1) {
+                return f[i][k];
+            }
+            int ans = i == finish;
+            for (int j = 0; j < n; ++j) {
+                if (j != i) {
+                    ans = (ans + dfs(j, k - abs(locations[i] - locations[j]))) % mod;
+                }
+            }
+            return f[i][k] = ans;
+        };
+        return dfs(start, fuel);
     }
 };
 ```
@@ -172,36 +181,32 @@ public:
 ```go
 func countRoutes(locations []int, start int, finish int, fuel int) int {
 	n := len(locations)
-	f := make([][]int, n+1)
+	f := make([][]int, n)
 	for i := range f {
 		f[i] = make([]int, fuel+1)
 		for j := range f[i] {
 			f[i][j] = -1
 		}
 	}
-	mod := int(1e9) + 7
+	const mod = 1e9 + 7
 	var dfs func(int, int) int
-	dfs = func(i, t int) int {
-		if f[i][t] != -1 {
-			return f[i][t]
-		}
-		if abs(locations[i]-locations[finish]) > t {
+	dfs = func(i, k int) (ans int) {
+		if k < 0 || abs(locations[i]-locations[finish]) > k {
 			return 0
 		}
-		res := 0
+		if f[i][k] != -1 {
+			return f[i][k]
+		}
 		if i == finish {
-			res++
+			ans = 1
 		}
-		for j, v := range locations {
+		for j, x := range locations {
 			if j != i {
-				cost := abs(locations[i] - v)
-				if cost <= t {
-					res = (res + dfs(j, t-cost)) % mod
-				}
+				ans = (ans + dfs(j, k-abs(locations[i]-x))) % mod
 			}
 		}
-		f[i][t] = res
-		return res
+		f[i][k] = ans
+		return
 	}
 	return dfs(start, fuel)
 }
@@ -214,6 +219,38 @@ func abs(x int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function countRoutes(
+    locations: number[],
+    start: number,
+    finish: number,
+    fuel: number,
+): number {
+    const n = locations.length;
+    const f = Array.from({ length: n }, () => Array(fuel + 1).fill(-1));
+    const mod = 1e9 + 7;
+    const dfs = (i: number, k: number): number => {
+        if (k < 0 || Math.abs(locations[i] - locations[finish]) > k) {
+            return 0;
+        }
+        if (f[i][k] !== -1) {
+            return f[i][k];
+        }
+        let ans = i === finish ? 1 : 0;
+        for (let j = 0; j < n; ++j) {
+            if (j != i) {
+                const x = Math.abs(locations[i] - locations[j]);
+                ans = (ans + dfs(j, k - x)) % mod;
+            }
+        }
+        return (f[i][k] = ans);
+    };
+    return dfs(start, fuel);
+}
+```
+
 ### **...**
 
 ```