Skip to content

Commit 46c8b91

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1269
No.1269.Number of Ways to Stay in the Same Place After Some Steps
1 parent e8b5228 commit 46c8b91

File tree

6 files changed

+328
-2
lines changed

6 files changed

+328
-2
lines changed

‎solution/1200-1299/1269.Number of Ways to Stay in the Same Place After Some Steps/README.md

Lines changed: 123 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -58,22 +58,144 @@
5858

5959
<!-- 这里可写通用的实现逻辑 -->
6060

61+
**方法一：记忆化搜索**
62+
63+
我们观察题目的数据范围，可以发现，`steps` 最大不超过 $500$，这意味着我们最远只能往右走 $500$ 步。
64+
65+
我们可以设计一个函数 $dfs(i, j)$，表示当前在位置 $i$，并且剩余步数为 $j$ 的方案数。那么答案就是 $dfs(0, steps)$。
66+
67+
函数 $dfs(i, j)$ 的执行过程如下：
68+
69+
1. 如果 $i \gt j$ 或者 $i \geq arrLen$ 或者 $i \lt 0$ 或者 $j \lt 0$，那么返回 $0$。
70+
1. 如果 $i = 0$ 且 $j = 0$，那么此时指针已经停在原地，并且没有剩余步数，所以返回 $1$。
71+
1. 否则，我们可以选择向左走一步，向右走一步，或者不动，所以返回 $dfs(i - 1, j - 1) + dfs(i + 1, j - 1) + dfs(i, j - 1)$。注意答案的取模操作。
72+
73+
过程中，我们可以使用记忆化搜索避免重复计算。
74+
75+
时间复杂度 $O(steps \times steps)，空间复杂度 O(steps \times steps)$。其中 $steps$ 是题目给定的步数。
76+
6177
<!-- tabs:start -->
6278

6379
### **Python3**
6480

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

6783
```python
68-
84+
class Solution:
85+
def numWays(self, steps: int, arrLen: int) -> int:
86+
@cache
87+
def dfs(i, j):
88+
if i > j or i >= arrLen or i < 0 or j < 0:
89+
return 0
90+
if i == 0 and j == 0:
91+
return 1
92+
ans = 0
93+
for k in range(-1, 2):
94+
ans += dfs(i + k, j - 1)
95+
ans %= mod
96+
return ans
97+
98+
mod = 10**9 + 7
99+
return dfs(0, steps)
69100
```
70101

71102
### **Java**
72103

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

75106
```java
107+
class Solution {
108+
private Integer[][] f;
109+
private int n;
110+
111+
public int numWays(int steps, int arrLen) {
112+
f = new Integer[steps][steps + 1];
113+
n = arrLen;
114+
return dfs(0, steps);
115+
}
116+
117+
private int dfs(int i, int j) {
118+
if (i > j || i >= n || i < 0 || j < 0) {
119+
return 0;
120+
}
121+
if (i == 0 && j == 0) {
122+
return 1;
123+
}
124+
if (f[i][j] != null) {
125+
return f[i][j];
126+
}
127+
int ans = 0;
128+
final int mod = (int) 1e9 + 7;
129+
for (int k = -1; k <= 1; ++k) {
130+
ans = (ans + dfs(i + k, j - 1)) % mod;
131+
}
132+
return f[i][j] = ans;
133+
}
134+
}
135+
```
136+
137+
### **C++**
138+
139+
```cpp
140+
class Solution {
141+
public:
142+
int numWays(int steps, int arrLen) {
143+
int f[steps][steps + 1];
144+
memset(f, -1, sizeof f);
145+
const int mod = 1e9 + 7;
146+
function<int(int, int)> dfs = [&](int i, int j) -> int {
147+
if (i > j || i >= arrLen || i < 0 || j < 0) {
148+
return 0;
149+
}
150+
if (i == 0 && j == 0) {
151+
return 1;
152+
}
153+
if (f[i][j] != -1) {
154+
return f[i][j];
155+
}
156+
int ans = 0;
157+
for (int k = -1; k <= 1; ++k) {
158+
ans = (ans + dfs(i + k, j - 1)) % mod;
159+
}
160+
return f[i][j] = ans;
161+
};
162+
return dfs(0, steps);
163+
}
164+
};
165+
```
76166
167+
### **Go**
168+
169+
```go
170+
func numWays(steps int, arrLen int) int {
171+
const mod int = 1e9 + 7
172+
f := make([][]int, steps)
173+
for i := range f {
174+
f[i] = make([]int, steps+1)
175+
for j := range f[i] {
176+
f[i][j] = -1
177+
}
178+
}
179+
var dfs func(i, j int) int
180+
dfs = func(i, j int) (ans int) {
181+
if i > j || i >= arrLen || i < 0 || j < 0 {
182+
return 0
183+
}
184+
if i == 0 && j == 0 {
185+
return 1
186+
}
187+
if f[i][j] != -1 {
188+
return f[i][j]
189+
}
190+
for k := -1; k <= 1; k++ {
191+
ans += dfs(i+k, j-1)
192+
ans %= mod
193+
}
194+
f[i][j] = ans
195+
return
196+
}
197+
return dfs(0, steps)
198+
}
77199
```
78200

79201
### **...**

‎solution/1200-1299/1269.Number of Ways to Stay in the Same Place After Some Steps/README_EN.md

Lines changed: 107 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -53,13 +53,119 @@ Stay, Stay
5353
### **Python3**
5454

5555
```python
56-
56+
class Solution:
57+
def numWays(self, steps: int, arrLen: int) -> int:
58+
@cache
59+
def dfs(i, j):
60+
if i > j or i >= arrLen or i < 0 or j < 0:
61+
return 0
62+
if i == 0 and j == 0:
63+
return 1
64+
ans = 0
65+
for k in range(-1, 2):
66+
ans += dfs(i + k, j - 1)
67+
ans %= mod
68+
return ans
69+
70+
mod = 10**9 + 7
71+
return dfs(0, steps)
5772
```
5873

5974
### **Java**
6075

6176
```java
77+
class Solution {
78+
private Integer[][] f;
79+
private int n;
80+
81+
public int numWays(int steps, int arrLen) {
82+
f = new Integer[steps][steps + 1];
83+
n = arrLen;
84+
return dfs(0, steps);
85+
}
86+
87+
private int dfs(int i, int j) {
88+
if (i > j || i >= n || i < 0 || j < 0) {
89+
return 0;
90+
}
91+
if (i == 0 && j == 0) {
92+
return 1;
93+
}
94+
if (f[i][j] != null) {
95+
return f[i][j];
96+
}
97+
int ans = 0;
98+
final int mod = (int) 1e9 + 7;
99+
for (int k = -1; k <= 1; ++k) {
100+
ans = (ans + dfs(i + k, j - 1)) % mod;
101+
}
102+
return f[i][j] = ans;
103+
}
104+
}
105+
```
106+
107+
### **C++**
108+
109+
```cpp
110+
class Solution {
111+
public:
112+
int numWays(int steps, int arrLen) {
113+
int f[steps][steps + 1];
114+
memset(f, -1, sizeof f);
115+
const int mod = 1e9 + 7;
116+
function<int(int, int)> dfs = [&](int i, int j) -> int {
117+
if (i > j || i >= arrLen || i < 0 || j < 0) {
118+
return 0;
119+
}
120+
if (i == 0 && j == 0) {
121+
return 1;
122+
}
123+
if (f[i][j] != -1) {
124+
return f[i][j];
125+
}
126+
int ans = 0;
127+
for (int k = -1; k <= 1; ++k) {
128+
ans = (ans + dfs(i + k, j - 1)) % mod;
129+
}
130+
return f[i][j] = ans;
131+
};
132+
return dfs(0, steps);
133+
}
134+
};
135+
```
62136
137+
### **Go**
138+
139+
```go
140+
func numWays(steps int, arrLen int) int {
141+
const mod int = 1e9 + 7
142+
f := make([][]int, steps)
143+
for i := range f {
144+
f[i] = make([]int, steps+1)
145+
for j := range f[i] {
146+
f[i][j] = -1
147+
}
148+
}
149+
var dfs func(i, j int) int
150+
dfs = func(i, j int) (ans int) {
151+
if i > j || i >= arrLen || i < 0 || j < 0 {
152+
return 0
153+
}
154+
if i == 0 && j == 0 {
155+
return 1
156+
}
157+
if f[i][j] != -1 {
158+
return f[i][j]
159+
}
160+
for k := -1; k <= 1; k++ {
161+
ans += dfs(i+k, j-1)
162+
ans %= mod
163+
}
164+
f[i][j] = ans
165+
return
166+
}
167+
return dfs(0, steps)
168+
}
63169
```
64170

65171
### **...**

‎solution/1200-1299/1269.Number of Ways to Stay in the Same Place After Some Steps/Solution.cpp

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
class Solution {
2+
public:
3+
int numWays(int steps, int arrLen) {
4+
int f[steps][steps + 1];
5+
memset(f, -1, sizeof f);
6+
const int mod = 1e9 + 7;
7+
function<int(int, int)> dfs = [&](int i, int j) -> int {
8+
if (i > j || i >= arrLen || i < 0 || j < 0) {
9+
return 0;
10+
}
11+
if (i == 0 && j == 0) {
12+
return 1;
13+
}
14+
if (f[i][j] != -1) {
15+
return f[i][j];
16+
}
17+
int ans = 0;
18+
for (int k = -1; k <= 1; ++k) {
19+
ans = (ans + dfs(i + k, j - 1)) % mod;
20+
}
21+
return f[i][j] = ans;
22+
};
23+
return dfs(0, steps);
24+
}
25+
};

‎solution/1200-1299/1269.Number of Ways to Stay in the Same Place After Some Steps/Solution.go

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
func numWays(steps int, arrLen int) int {
2+
const mod int = 1e9 + 7
3+
f := make([][]int, steps)
4+
for i := range f {
5+
f[i] = make([]int, steps+1)
6+
for j := range f[i] {
7+
f[i][j] = -1
8+
}
9+
}
10+
var dfs func(i, j int) int
11+
dfs = func(i, j int) (ans int) {
12+
if i > j || i >= arrLen || i < 0 || j < 0 {
13+
return 0
14+
}
15+
if i == 0 && j == 0 {
16+
return 1
17+
}
18+
if f[i][j] != -1 {
19+
return f[i][j]
20+
}
21+
for k := -1; k <= 1; k++ {
22+
ans += dfs(i+k, j-1)
23+
ans %= mod
24+
}
25+
f[i][j] = ans
26+
return
27+
}
28+
return dfs(0, steps)
29+
}

‎solution/1200-1299/1269.Number of Ways to Stay in the Same Place After Some Steps/Solution.java

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
class Solution {
2+
private Integer[][] f;
3+
private int n;
4+
5+
public int numWays(int steps, int arrLen) {
6+
f = new Integer[steps][steps + 1];
7+
n = arrLen;
8+
return dfs(0, steps);
9+
}
10+
11+
private int dfs(int i, int j) {
12+
if (i > j || i >= n || i < 0 || j < 0) {
13+
return 0;
14+
}
15+
if (i == 0 && j == 0) {
16+
return 1;
17+
}
18+
if (f[i][j] != null) {
19+
return f[i][j];
20+
}
21+
int ans = 0;
22+
final int mod = (int) 1e9 + 7;
23+
for (int k = -1; k <= 1; ++k) {
24+
ans = (ans + dfs(i + k, j - 1)) % mod;
25+
}
26+
return f[i][j] = ans;
27+
}
28+
}

‎solution/1200-1299/1269.Number of Ways to Stay in the Same Place After Some Steps/Solution.py

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
class Solution:
2+
def numWays(self, steps: int, arrLen: int) -> int:
3+
@cache
4+
def dfs(i, j):
5+
if i > j or i >= arrLen or i < 0 or j < 0:
6+
return 0
7+
if i == 0 and j == 0:
8+
return 1
9+
ans = 0
10+
for k in range(-1, 2):
11+
ans += dfs(i + k, j - 1)
12+
ans %= mod
13+
return ans
14+
15+
mod = 10**9 + 7
16+
return dfs(0, steps)

0 commit comments

Comments
 (0)