Skip to content

Commit 26d7960

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1575
No.1575.Count All Possible Routes
1 parent 8ef3222 commit 26d7960

File tree

8 files changed

+379
-2
lines changed

8 files changed

+379
-2
lines changed

‎README.md

+1
Original file line numberDiff line numberDiff line change
@@ -100,6 +100,7 @@
100100
- [矩阵中的最长递增路径](/solution/0300-0399/0329.Longest%20Increasing%20Path%20in%20a%20Matrix/README.md) - `DFS`、`记忆化搜索`
101101
- [网格图中递增路径的数目](/solution/2300-2399/2328.Number%20of%20Increasing%20Paths%20in%20a%20Grid/README.md) - `DFS`、`记忆化搜索`
102102
- [翻转游戏 II](/solution/0200-0299/0294.Flip%20Game%20II/README.md) - `DFS`、`状态压缩`、`记忆化搜索`
103+
- [统计所有可行路径](/solution/1500-1599/1575.Count%20All%20Possible%20Routes/README.md) - `DFS`、`记忆化搜索`
103104

104105
<!-- DFS 待补充 -->
105106

‎README_EN.md

+1
Original file line numberDiff line numberDiff line change
@@ -98,6 +98,7 @@ Complete solutions to [LeetCode](https://leetcode.com/problemset/all/), [LCOF](h
9898
- [Longest Increasing Path in a Matrix](/solution/0300-0399/0329.Longest%20Increasing%20Path%20in%20a%20Matrix/README_EN.md) - `DFS`、`Memoization`
9999
- [Number of Increasing Paths in a Grid](/solution/2300-2399/2328.Number%20of%20Increasing%20Paths%20in%20a%20Grid/README.md) - `DFS`、`Memoization`
100100
- [Flip Game II](/solution/0200-0299/0294.Flip%20Game%20II/README_EN.md) - `DFS`、`Bitmask`、`Memoization`
101+
- [Count All Possible Routes](/solution/1500-1599/1575.Count%20All%20Possible%20Routes/README_EN.md) - `DFS`、`Memoization`
101102

102103
### 4. Dynamic Programming(DP)
103104

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

+130-1
Original file line numberDiff line numberDiff line change
@@ -66,22 +66,151 @@
6666

6767
<!-- 这里可写通用的实现逻辑 -->
6868

69+
**方法一：记忆化搜索**
70+
6971
<!-- tabs:start -->
7072

7173
### **Python3**
7274

7375
<!-- 这里可写当前语言的特殊实现逻辑 -->
7476

7577
```python
76-
78+
class Solution:
79+
def countRoutes(self, locations: List[int], start: int, finish: int, fuel: int) -> int:
80+
@cache
81+
def dfs(i, t):
82+
if abs(locations[i] - locations[finish]) > t:
83+
return 0
84+
res = int(i == finish)
85+
for j, v in enumerate(locations):
86+
if j != i:
87+
if (cost := abs(locations[i] - v)) <= t:
88+
res += dfs(j, t - cost)
89+
return res % mod
90+
91+
mod = 10**9 + 7
92+
return dfs(start, fuel)
7793
```
7894

7995
### **Java**
8096

8197
<!-- 这里可写当前语言的特殊实现逻辑 -->
8298

8399
```java
100+
class Solution {
101+
private int[][] f;
102+
private int[] locations;
103+
private int target;
104+
private static final int MOD = (int) 1e9 + 7;
105+
106+
public int countRoutes(int[] locations, int start, int finish, int fuel) {
107+
int n = locations.length;
108+
f = new int[n + 1][fuel + 1];
109+
this.locations = locations;
110+
target = finish;
111+
for (int i = 0; i < f.length; ++i) {
112+
Arrays.fill(f[i], -1);
113+
}
114+
return dfs(start, fuel);
115+
}
116+
117+
private int dfs(int i, int t) {
118+
if (f[i][t] != -1) {
119+
return f[i][t];
120+
}
121+
if (Math.abs(locations[i] - locations[target]) > t) {
122+
return 0;
123+
}
124+
int res = i == target ? 1 : 0;
125+
for (int j = 0; j < locations.length; ++j) {
126+
if (j != i) {
127+
int cost = Math.abs(locations[i] - locations[j]);
128+
if (cost <= t) {
129+
res += dfs(j, t - cost);
130+
res %= MOD;
131+
}
132+
}
133+
}
134+
f[i][t] = res;
135+
return res;
136+
}
137+
}
138+
```
139+
140+
### **C++**
141+
142+
```cpp
143+
class Solution {
144+
public:
145+
const int mod = 1e9 + 7;
146+
147+
int countRoutes(vector<int>& locations, int start, int finish, int fuel) {
148+
int n = locations.size();
149+
vector<vector<int>> f(n + 1, vector<int>(fuel + 1, -1));
150+
return dfs(start, fuel, locations, finish, f);
151+
}
152+
153+
int dfs(int i, int t, vector<int>& locations, int target, vector<vector<int>>& f) {
154+
if (f[i][t] != -1) return f[i][t];
155+
if (abs(locations[i] - locations[target]) > t) return 0;
156+
int res = i == target;
157+
for (int j = 0; j < locations.size(); ++j)
158+
{
159+
if (j == i) continue;
160+
int cost = abs(locations[i] - locations[j]);
161+
if (cost <= t) res = (res + dfs(j, t - cost, locations, target, f)) % mod;
162+
}
163+
f[i][t] = res;
164+
return res;
165+
}
166+
};
167+
```
84168
169+
### **Go**
170+
171+
```go
172+
func countRoutes(locations []int, start int, finish int, fuel int) int {
173+
n := len(locations)
174+
f := make([][]int, n+1)
175+
for i := range f {
176+
f[i] = make([]int, fuel+1)
177+
for j := range f[i] {
178+
f[i][j] = -1
179+
}
180+
}
181+
mod := int(1e9) + 7
182+
var dfs func(int, int) int
183+
dfs = func(i, t int) int {
184+
if f[i][t] != -1 {
185+
return f[i][t]
186+
}
187+
if abs(locations[i]-locations[finish]) > t {
188+
return 0
189+
}
190+
res := 0
191+
if i == finish {
192+
res++
193+
}
194+
for j, v := range locations {
195+
if j != i {
196+
cost := abs(locations[i] - v)
197+
if cost <= t {
198+
res = (res + dfs(j, t-cost)) % mod
199+
}
200+
}
201+
}
202+
f[i][t] = res
203+
return res
204+
}
205+
return dfs(start, fuel)
206+
}
207+
208+
func abs(x int) int {
209+
if x < 0 {
210+
return -x
211+
}
212+
return x
213+
}
85214
```
86215

87216
### **...**

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

+128-1
Original file line numberDiff line numberDiff line change
@@ -64,13 +64,140 @@
6464
### **Python3**
6565

6666
```python
67-
67+
class Solution:
68+
def countRoutes(self, locations: List[int], start: int, finish: int, fuel: int) -> int:
69+
@cache
70+
def dfs(i, t):
71+
if abs(locations[i] - locations[finish]) > t:
72+
return 0
73+
res = int(i == finish)
74+
for j, v in enumerate(locations):
75+
if j != i:
76+
if (cost := abs(locations[i] - v)) <= t:
77+
res += dfs(j, t - cost)
78+
return res % mod
79+
80+
mod = 10**9 + 7
81+
return dfs(start, fuel)
6882
```
6983

7084
### **Java**
7185

7286
```java
87+
class Solution {
88+
private int[][] f;
89+
private int[] locations;
90+
private int target;
91+
private static final int MOD = (int) 1e9 + 7;
92+
93+
public int countRoutes(int[] locations, int start, int finish, int fuel) {
94+
int n = locations.length;
95+
f = new int[n + 1][fuel + 1];
96+
this.locations = locations;
97+
target = finish;
98+
for (int i = 0; i < f.length; ++i) {
99+
Arrays.fill(f[i], -1);
100+
}
101+
return dfs(start, fuel);
102+
}
103+
104+
private int dfs(int i, int t) {
105+
if (f[i][t] != -1) {
106+
return f[i][t];
107+
}
108+
if (Math.abs(locations[i] - locations[target]) > t) {
109+
return 0;
110+
}
111+
int res = i == target ? 1 : 0;
112+
for (int j = 0; j < locations.length; ++j) {
113+
if (j != i) {
114+
int cost = Math.abs(locations[i] - locations[j]);
115+
if (cost <= t) {
116+
res += dfs(j, t - cost);
117+
res %= MOD;
118+
}
119+
}
120+
}
121+
f[i][t] = res;
122+
return res;
123+
}
124+
}
125+
```
126+
127+
### **C++**
128+
129+
```cpp
130+
class Solution {
131+
public:
132+
const int mod = 1e9 + 7;
133+
134+
int countRoutes(vector<int>& locations, int start, int finish, int fuel) {
135+
int n = locations.size();
136+
vector<vector<int>> f(n + 1, vector<int>(fuel + 1, -1));
137+
return dfs(start, fuel, locations, finish, f);
138+
}
139+
140+
int dfs(int i, int t, vector<int>& locations, int target, vector<vector<int>>& f) {
141+
if (f[i][t] != -1) return f[i][t];
142+
if (abs(locations[i] - locations[target]) > t) return 0;
143+
int res = i == target;
144+
for (int j = 0; j < locations.size(); ++j)
145+
{
146+
if (j == i) continue;
147+
int cost = abs(locations[i] - locations[j]);
148+
if (cost <= t) res = (res + dfs(j, t - cost, locations, target, f)) % mod;
149+
}
150+
f[i][t] = res;
151+
return res;
152+
}
153+
};
154+
```
73155
156+
### **Go**
157+
158+
```go
159+
func countRoutes(locations []int, start int, finish int, fuel int) int {
160+
n := len(locations)
161+
f := make([][]int, n+1)
162+
for i := range f {
163+
f[i] = make([]int, fuel+1)
164+
for j := range f[i] {
165+
f[i][j] = -1
166+
}
167+
}
168+
mod := int(1e9) + 7
169+
var dfs func(int, int) int
170+
dfs = func(i, t int) int {
171+
if f[i][t] != -1 {
172+
return f[i][t]
173+
}
174+
if abs(locations[i]-locations[finish]) > t {
175+
return 0
176+
}
177+
res := 0
178+
if i == finish {
179+
res++
180+
}
181+
for j, v := range locations {
182+
if j != i {
183+
cost := abs(locations[i] - v)
184+
if cost <= t {
185+
res = (res + dfs(j, t-cost)) % mod
186+
}
187+
}
188+
}
189+
f[i][t] = res
190+
return res
191+
}
192+
return dfs(start, fuel)
193+
}
194+
195+
func abs(x int) int {
196+
if x < 0 {
197+
return -x
198+
}
199+
return x
200+
}
74201
```
75202

76203
### **...**

‎solution/1500-1599/1575.Count All Possible Routes/Solution.cpp

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
public:
3+
const int mod = 1e9 + 7;
4+
5+
int countRoutes(vector<int>& locations, int start, int finish, int fuel) {
6+
int n = locations.size();
7+
vector<vector<int>> f(n + 1, vector<int>(fuel + 1, -1));
8+
return dfs(start, fuel, locations, finish, f);
9+
}
10+
11+
int dfs(int i, int t, vector<int>& locations, int target, vector<vector<int>>& f) {
12+
if (f[i][t] != -1) return f[i][t];
13+
if (abs(locations[i] - locations[target]) > t) return 0;
14+
int res = i == target;
15+
for (int j = 0; j < locations.size(); ++j)
16+
{
17+
if (j == i) continue;
18+
int cost = abs(locations[i] - locations[j]);
19+
if (cost <= t) res = (res + dfs(j, t - cost, locations, target, f)) % mod;
20+
}
21+
f[i][t] = res;
22+
return res;
23+
}
24+
};

‎solution/1500-1599/1575.Count All Possible Routes/Solution.go

+42
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
1+
func countRoutes(locations []int, start int, finish int, fuel int) int {
2+
n := len(locations)
3+
f := make([][]int, n+1)
4+
for i := range f {
5+
f[i] = make([]int, fuel+1)
6+
for j := range f[i] {
7+
f[i][j] = -1
8+
}
9+
}
10+
mod := int(1e9) + 7
11+
var dfs func(int, int) int
12+
dfs = func(i, t int) int {
13+
if f[i][t] != -1 {
14+
return f[i][t]
15+
}
16+
if abs(locations[i]-locations[finish]) > t {
17+
return 0
18+
}
19+
res := 0
20+
if i == finish {
21+
res++
22+
}
23+
for j, v := range locations {
24+
if j != i {
25+
cost := abs(locations[i] - v)
26+
if cost <= t {
27+
res = (res + dfs(j, t-cost)) % mod
28+
}
29+
}
30+
}
31+
f[i][t] = res
32+
return res
33+
}
34+
return dfs(start, fuel)
35+
}
36+
37+
func abs(x int) int {
38+
if x < 0 {
39+
return -x
40+
}
41+
return x
42+
}

0 commit comments

Comments
 (0)