Skip to content

Commit 01e5168

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0062
No.0062.Unique Paths
1 parent 10ac13a commit 01e5168

File tree

8 files changed

+427
-106
lines changed

8 files changed

+427
-106
lines changed

‎solution/0000-0099/0062.Unique Paths/README.md

+192-31
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,25 @@
6060

6161
**方法一：动态规划**
6262

63-
假设 `dp[i][j]` 表示到达网格 `(i, j)` 的路径数，则 `dp[i][j] = dp[i - 1][j] + dp[i][j - 1]`。
63+
我们定义 $f[i][j]$ 表示从左上角走到 $(i, j)$ 的路径数量，初始时 $f[0][0] = 1$，答案为 $f[m - 1][n - 1]$。
64+
65+
考虑 $f[i][j]$：
66+
67+
- 如果 $i \gt 0$，那么 $f[i][j]$ 可以从 $f[i - 1][j]$ 走一步到达，因此 $f[i][j] = f[i][j] + f[i - 1][j]$；
68+
- 如果 $j \gt 0$，那么 $f[i][j]$ 可以从 $f[i][j - 1]$ 走一步到达，因此 $f[i][j] = f[i][j] + f[i][j - 1]$。
69+
70+
因此，我们有如下的状态转移方程：
71+
72+
$$
73+
f[i][j] = \begin{cases}
74+
1 & i = 0, j = 0 \\
75+
f[i - 1][j] + f[i][j - 1] & \text{otherwise}
76+
\end{cases}
77+
$$
78+
79+
最终的答案即为 $f[m - 1][n - 1]$。
80+
81+
时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别是网格的行数和列数。
6482

6583
<!-- tabs:start -->
6684

@@ -71,11 +89,25 @@
7189
```python
7290
class Solution:
7391
def uniquePaths(self, m: int, n: int) -> int:
74-
dp = [[1] * n for _ in range(m)]
92+
f = [[0] * n for _ in range(m)]
93+
f[0][0] = 1
94+
for i in range(m):
95+
for j in range(n):
96+
if i:
97+
f[i][j] += f[i - 1][j]
98+
if j:
99+
f[i][j] += f[i][j - 1]
100+
return f[-1][-1]
101+
```
102+
103+
```python
104+
class Solution:
105+
def uniquePaths(self, m: int, n: int) -> int:
106+
f = [[1] * n for _ in range(m)]
75107
for i in range(1, m):
76108
for j in range(1, n):
77-
dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
78-
return dp[-1][-1]
109+
f[i][j] = f[i - 1][j] + f[i][j - 1]
110+
return f[-1][-1]
79111
```
80112

81113
### **Java**
@@ -85,31 +117,37 @@ class Solution:
85117
```java
86118
class Solution {
87119
public int uniquePaths(int m, int n) {
88-
int[][] dp = new int[m][n];
120+
var f = new int[m][n];
121+
f[0][0] = 1;
89122
for (int i = 0; i < m; ++i) {
90-
Arrays.fill(dp[i], 1);
91-
}
92-
for (int i = 1; i < m; ++i) {
93-
for (int j = 1; j < n; ++j) {
94-
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
123+
for (int j = 0; j < n; ++j) {
124+
if (i > 0) {
125+
f[i][j] += f[i - 1][j];
126+
}
127+
if (j > 0) {
128+
f[i][j] += f[i][j - 1];
129+
}
95130
}
96131
}
97-
return dp[m - 1][n - 1];
132+
return f[m - 1][n - 1];
98133
}
99134
}
100135
```
101136

102-
### **TypeScript**
103-
104-
```ts
105-
function uniquePaths(m: number, n: number): number {
106-
let dp = Array.from({ length: m }, v => new Array(n).fill(1));
107-
for (let i = 1; i < m; ++i) {
108-
for (let j = 1; j < n; ++j) {
109-
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
137+
```java
138+
class Solution {
139+
public int uniquePaths(int m, int n) {
140+
var f = new int[m][n];
141+
for (var g : f) {
142+
Arrays.fill(g, 1);
143+
}
144+
for (int i = 1; i < m; ++i) {
145+
for (int j = 1; j < n; j++) {
146+
f[i][j] = f[i - 1][j] + f[i][j - 1];
147+
}
110148
}
149+
return f[m - 1][n - 1];
111150
}
112-
return dp[m - 1][n - 1];
113151
}
114152
```
115153

@@ -119,13 +157,34 @@ function uniquePaths(m: number, n: number): number {
119157
class Solution {
120158
public:
121159
int uniquePaths(int m, int n) {
122-
vector<vector<int>> dp(m, vector<int>(n, 1));
160+
vector<vector<int>> f(m, vector<int>(n));
161+
f[0][0] = 1;
162+
for (int i = 0; i < m; ++i) {
163+
for (int j = 0; j < n; ++j) {
164+
if (i) {
165+
f[i][j] += f[i - 1][j];
166+
}
167+
if (j) {
168+
f[i][j] += f[i][j - 1];
169+
}
170+
}
171+
}
172+
return f[m - 1][n - 1];
173+
}
174+
};
175+
```
176+
177+
```cpp
178+
class Solution {
179+
public:
180+
int uniquePaths(int m, int n) {
181+
vector<vector<int>> f(m, vector<int>(n, 1));
123182
for (int i = 1; i < m; ++i) {
124183
for (int j = 1; j < n; ++j) {
125-
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
184+
f[i][j] = f[i - 1][j] + f[i][j - 1];
126185
}
127186
}
128-
return dp[m - 1][n - 1];
187+
return f[m - 1][n - 1];
129188
}
130189
};
131190
```
@@ -134,23 +193,125 @@ public:
134193

135194
```go
136195
func uniquePaths(m int, n int) int {
137-
dp := make([][]int, m)
138-
for i := 0; i < m; i++ {
139-
dp[i] = make([]int, n)
196+
f := make([][]int, m)
197+
for i := range f {
198+
f[i] = make([]int, n)
140199
}
200+
f[0][0] = 1
141201
for i := 0; i < m; i++ {
142202
for j := 0; j < n; j++ {
143-
if i == 0 || j == 0 {
144-
dp[i][j] = 1
145-
} else {
146-
dp[i][j] = dp[i-1][j] + dp[i][j-1]
203+
if i > 0 {
204+
f[i][j] += f[i-1][j]
205+
}
206+
if j > 0 {
207+
f[i][j] += f[i][j-1]
147208
}
148209
}
149210
}
150-
return dp[m-1][n-1]
211+
return f[m-1][n-1]
212+
}
213+
```
214+
215+
```go
216+
func uniquePaths(m int, n int) int {
217+
f := make([][]int, m)
218+
for i := range f {
219+
f[i] = make([]int, n)
220+
for j := range f[i] {
221+
f[i][j] = 1
222+
}
223+
}
224+
for i := 1; i < m; i++ {
225+
for j := 1; j < n; j++ {
226+
f[i][j] = f[i-1][j] + f[i][j-1]
227+
}
228+
}
229+
return f[m-1][n-1]
151230
}
152231
```
153232

233+
### **TypeScript**
234+
235+
```ts
236+
function uniquePaths(m: number, n: number): number {
237+
const f: number[][] = Array(m)
238+
.fill(0)
239+
.map(() => Array(n).fill(0));
240+
f[0][0] = 1;
241+
for (let i = 0; i < m; ++i) {
242+
for (let j = 0; j < n; ++j) {
243+
if (i > 0) {
244+
f[i][j] += f[i - 1][j];
245+
}
246+
if (j > 0) {
247+
f[i][j] += f[i][j - 1];
248+
}
249+
}
250+
}
251+
return f[m - 1][n - 1];
252+
}
253+
```
254+
255+
```ts
256+
function uniquePaths(m: number, n: number): number {
257+
const f: number[][] = Array(m)
258+
.fill(0)
259+
.map(() => Array(n).fill(1));
260+
for (let i = 1; i < m; ++i) {
261+
for (let j = 1; j < n; ++j) {
262+
f[i][j] = f[i - 1][j] + f[i][j - 1];
263+
}
264+
}
265+
return f[m - 1][n - 1];
266+
}
267+
```
268+
269+
### **JavaScript**
270+
271+
```js
272+
/**
273+
* @param {number} m
274+
* @param {number} n
275+
* @return {number}
276+
*/
277+
var uniquePaths = function (m, n) {
278+
const f = Array(m)
279+
.fill(0)
280+
.map(() => Array(n).fill(0));
281+
f[0][0] = 1;
282+
for (let i = 0; i < m; ++i) {
283+
for (let j = 0; j < n; ++j) {
284+
if (i > 0) {
285+
f[i][j] += f[i - 1][j];
286+
}
287+
if (j > 0) {
288+
f[i][j] += f[i][j - 1];
289+
}
290+
}
291+
}
292+
return f[m - 1][n - 1];
293+
};
294+
```
295+
296+
```js
297+
/**
298+
* @param {number} m
299+
* @param {number} n
300+
* @return {number}
301+
*/
302+
var uniquePaths = function (m, n) {
303+
const f = Array(m)
304+
.fill(0)
305+
.map(() => Array(n).fill(1));
306+
for (let i = 1; i < m; ++i) {
307+
for (let j = 1; j < n; ++j) {
308+
f[i][j] = f[i - 1][j] + f[i][j - 1];
309+
}
310+
}
311+
return f[m - 1][n - 1];
312+
};
313+
```
314+
154315
### **Rust**
155316

156317
```rust

0 commit comments

Comments
 (0)