Skip to content

Commit 786f248

Browse files
YangFongYangFong
committed
feat: add solutions to lc problems
- No.0062.Unique Paths - No.0063.Unique Paths II - No.0213.House Robber II - No.1855.Maximum Distance Between a Pair of Values
1 parent c504cd4 commit 786f248

File tree

14 files changed

+422
-2
lines changed

14 files changed

+422
-2
lines changed

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

Lines changed: 19 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -58,9 +58,9 @@
5858

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

61-
动态规划。
61+
**方法一：动态规划**
6262

63-
假设 `dp[i][j]` 表示到达网格 `(i,j)` 的路径数，则 `dp[i][j] = dp[i - 1][j] + dp[i][j - 1]`。
63+
假设 `dp[i][j]` 表示到达网格 `(i, j)` 的路径数，则 `dp[i][j] = dp[i - 1][j] + dp[i][j - 1]`。
6464

6565
<!-- tabs:start -->
6666

@@ -153,6 +153,23 @@ func uniquePaths(m int, n int) int {
153153
}
154154
```
155155

156+
### **Rust**
157+
158+
```rust
159+
impl Solution {
160+
pub fn unique_paths(m: i32, n: i32) -> i32 {
161+
let (m, n) = (m as usize, n as usize);
162+
let mut dp = vec![1; n];
163+
for i in 1..m {
164+
for j in 1..n {
165+
dp[j] += dp[j - 1];
166+
}
167+
}
168+
dp[n - 1]
169+
}
170+
}
171+
```
172+
156173
### **...**
157174

158175
```

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

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -127,6 +127,23 @@ func uniquePaths(m int, n int) int {
127127
}
128128
```
129129

130+
### **Rust**
131+
132+
```rust
133+
impl Solution {
134+
pub fn unique_paths(m: i32, n: i32) -> i32 {
135+
let (m, n) = (m as usize, n as usize);
136+
let mut dp = vec![1; n];
137+
for i in 1..m {
138+
for j in 1..n {
139+
dp[j] += dp[j - 1];
140+
}
141+
}
142+
dp[n - 1]
143+
}
144+
}
145+
```
146+
130147
### **...**
131148

132149
```

‎solution/0000-0099/0062.Unique Paths/Solution.rs

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
impl Solution {
2+
pub fn unique_paths(m: i32, n: i32) -> i32 {
3+
let (m, n) = (m as usize, n as usize);
4+
let mut dp = vec![1; n];
5+
for i in 1..m {
6+
for j in 1..n {
7+
dp[j] += dp[j - 1];
8+
}
9+
}
10+
dp[n - 1]
11+
}
12+
}

‎solution/0000-0099/0063.Unique Paths II/README.md

Lines changed: 67 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -163,6 +163,73 @@ func uniquePathsWithObstacles(obstacleGrid [][]int) int {
163163
}
164164
```
165165

166+
### **TypeScript**
167+
168+
```ts
169+
function uniquePathsWithObstacles(obstacleGrid: number[][]): number {
170+
const m = obstacleGrid.length;
171+
const n = obstacleGrid[0].length;
172+
const dp = Array.from({ length: m }, () => new Array(n).fill(0));
173+
for (let i = 0; i < m; i++) {
174+
if (obstacleGrid[i][0] === 1) {
175+
break;
176+
}
177+
dp[i][0] = 1;
178+
}
179+
for (let i = 0; i < n; i++) {
180+
if (obstacleGrid[0][i] === 1) {
181+
break;
182+
}
183+
dp[0][i] = 1;
184+
}
185+
for (let i = 1; i < m; i++) {
186+
for (let j = 1; j < n; j++) {
187+
if (obstacleGrid[i][j] === 1) {
188+
continue;
189+
}
190+
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
191+
}
192+
}
193+
return dp[m - 1][n - 1];
194+
}
195+
```
196+
197+
### **Rust**
198+
199+
```rust
200+
impl Solution {
201+
pub fn unique_paths_with_obstacles(obstacle_grid: Vec<Vec<i32>>) -> i32 {
202+
let m = obstacle_grid.len();
203+
let n = obstacle_grid[0].len();
204+
if obstacle_grid[0][0] == 1 || obstacle_grid[m - 1][n - 1] == 1 {
205+
return 0;
206+
}
207+
let mut dp = vec![vec![0; n]; m];
208+
for i in 0..n {
209+
if obstacle_grid[0][i] == 1 {
210+
break;
211+
}
212+
dp[0][i] = 1;
213+
}
214+
for i in 0..m {
215+
if obstacle_grid[i][0] == 1 {
216+
break;
217+
}
218+
dp[i][0] = 1;
219+
}
220+
for i in 1..m {
221+
for j in 1..n {
222+
if obstacle_grid[i][j] == 1 {
223+
continue;
224+
}
225+
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
226+
}
227+
}
228+
dp[m - 1][n - 1]
229+
}
230+
}
231+
```
232+
166233
### **...**
167234

168235
```

‎solution/0000-0099/0063.Unique Paths II/README_EN.md

Lines changed: 67 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -146,6 +146,73 @@ func uniquePathsWithObstacles(obstacleGrid [][]int) int {
146146
}
147147
```
148148

149+
### **TypeScript**
150+
151+
```ts
152+
function uniquePathsWithObstacles(obstacleGrid: number[][]): number {
153+
const m = obstacleGrid.length;
154+
const n = obstacleGrid[0].length;
155+
const dp = Array.from({ length: m }, () => new Array(n).fill(0));
156+
for (let i = 0; i < m; i++) {
157+
if (obstacleGrid[i][0] === 1) {
158+
break;
159+
}
160+
dp[i][0] = 1;
161+
}
162+
for (let i = 0; i < n; i++) {
163+
if (obstacleGrid[0][i] === 1) {
164+
break;
165+
}
166+
dp[0][i] = 1;
167+
}
168+
for (let i = 1; i < m; i++) {
169+
for (let j = 1; j < n; j++) {
170+
if (obstacleGrid[i][j] === 1) {
171+
continue;
172+
}
173+
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
174+
}
175+
}
176+
return dp[m - 1][n - 1];
177+
}
178+
```
179+
180+
### **Rust**
181+
182+
```rust
183+
impl Solution {
184+
pub fn unique_paths_with_obstacles(obstacle_grid: Vec<Vec<i32>>) -> i32 {
185+
let m = obstacle_grid.len();
186+
let n = obstacle_grid[0].len();
187+
if obstacle_grid[0][0] == 1 || obstacle_grid[m - 1][n - 1] == 1 {
188+
return 0;
189+
}
190+
let mut dp = vec![vec![0; n]; m];
191+
for i in 0..n {
192+
if obstacle_grid[0][i] == 1 {
193+
break;
194+
}
195+
dp[0][i] = 1;
196+
}
197+
for i in 0..m {
198+
if obstacle_grid[i][0] == 1 {
199+
break;
200+
}
201+
dp[i][0] = 1;
202+
}
203+
for i in 1..m {
204+
for j in 1..n {
205+
if obstacle_grid[i][j] == 1 {
206+
continue;
207+
}
208+
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
209+
}
210+
}
211+
dp[m - 1][n - 1]
212+
}
213+
}
214+
```
215+
149216
### **...**
150217

151218
```

‎solution/0000-0099/0063.Unique Paths II/Solution.rs

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
impl Solution {
2+
pub fn unique_paths_with_obstacles(obstacle_grid: Vec<Vec<i32>>) -> i32 {
3+
let m = obstacle_grid.len();
4+
let n = obstacle_grid[0].len();
5+
if obstacle_grid[0][0] == 1 || obstacle_grid[m - 1][n - 1] == 1 {
6+
return 0;
7+
}
8+
let mut dp = vec![vec![0; n]; m];
9+
for i in 0..n {
10+
if obstacle_grid[0][i] == 1 {
11+
break;
12+
}
13+
dp[0][i] = 1;
14+
}
15+
for i in 0..m {
16+
if obstacle_grid[i][0] == 1 {
17+
break;
18+
}
19+
dp[i][0] = 1;
20+
}
21+
for i in 1..m {
22+
for j in 1..n {
23+
if obstacle_grid[i][j] == 1 {
24+
continue;
25+
}
26+
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
27+
}
28+
}
29+
dp[m - 1][n - 1]
30+
}
31+
}

‎solution/0000-0099/0063.Unique Paths II/Solution.ts

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
function uniquePathsWithObstacles(obstacleGrid: number[][]): number {
2+
const m = obstacleGrid.length;
3+
const n = obstacleGrid[0].length;
4+
const dp = Array.from({ length: m }, () => new Array(n).fill(0));
5+
for (let i = 0; i < m; i++) {
6+
if (obstacleGrid[i][0] === 1) {
7+
break;
8+
}
9+
dp[i][0] = 1;
10+
}
11+
for (let i = 0; i < n; i++) {
12+
if (obstacleGrid[0][i] === 1) {
13+
break;
14+
}
15+
dp[0][i] = 1;
16+
}
17+
for (let i = 1; i < m; i++) {
18+
for (let j = 1; j < n; j++) {
19+
if (obstacleGrid[i][j] === 1) {
20+
continue;
21+
}
22+
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
23+
}
24+
}
25+
return dp[m - 1][n - 1];
26+
}

‎solution/0200-0299/0213.House Robber II/README.md

Lines changed: 40 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -153,6 +153,46 @@ func max(a, b int) int {
153153
}
154154
```
155155

156+
### **TypeScript**
157+
158+
```ts
159+
function rob(nums: number[]): number {
160+
const n = nums.length;
161+
if (n === 1) {
162+
return nums[0];
163+
}
164+
const robRange = (left: number, right: number) => {
165+
const dp = [0, 0];
166+
for (let i = left; i < right; i++) {
167+
[dp[0], dp[1]] = [dp[1], Math.max(dp[1], dp[0] + nums[i])];
168+
}
169+
return dp[1];
170+
};
171+
return Math.max(robRange(0, n - 1), robRange(1, n));
172+
}
173+
```
174+
175+
### **Rust**
176+
177+
```rust
178+
impl Solution {
179+
pub fn rob(nums: Vec<i32>) -> i32 {
180+
let n = nums.len();
181+
if n == 1 {
182+
return nums[0];
183+
}
184+
let rob_range = |left, right| {
185+
let mut dp = [0, 0];
186+
for i in left..right {
187+
dp = [dp[1], dp[1].max(dp[0] + nums[i])];
188+
}
189+
dp[1]
190+
};
191+
rob_range(0, n - 1).max(rob_range(1, n))
192+
}
193+
}
194+
```
195+
156196
### **...**
157197

158198
```

‎solution/0200-0299/0213.House Robber II/README_EN.md

Lines changed: 40 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -142,6 +142,46 @@ func max(a, b int) int {
142142
}
143143
```
144144

145+
### **TypeScript**
146+
147+
```ts
148+
function rob(nums: number[]): number {
149+
const n = nums.length;
150+
if (n === 1) {
151+
return nums[0];
152+
}
153+
const robRange = (left: number, right: number) => {
154+
const dp = [0, 0];
155+
for (let i = left; i < right; i++) {
156+
[dp[0], dp[1]] = [dp[1], Math.max(dp[1], dp[0] + nums[i])];
157+
}
158+
return dp[1];
159+
};
160+
return Math.max(robRange(0, n - 1), robRange(1, n));
161+
}
162+
```
163+
164+
### **Rust**
165+
166+
```rust
167+
impl Solution {
168+
pub fn rob(nums: Vec<i32>) -> i32 {
169+
let n = nums.len();
170+
if n == 1 {
171+
return nums[0];
172+
}
173+
let rob_range = |left, right| {
174+
let mut dp = [0, 0];
175+
for i in left..right {
176+
dp = [dp[1], dp[1].max(dp[0] + nums[i])];
177+
}
178+
dp[1]
179+
};
180+
rob_range(0, n - 1).max(rob_range(1, n))
181+
}
182+
}
183+
```
184+
145185
### **...**
146186

147187
```

‎solution/0200-0299/0213.House Robber II/Solution.rs

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
impl Solution {
2+
pub fn rob(nums: Vec<i32>) -> i32 {
3+
let n = nums.len();
4+
if n == 1 {
5+
return nums[0];
6+
}
7+
let rob_range = |left, right| {
8+
let mut dp = [0, 0];
9+
for i in left..right {
10+
dp = [dp[1], dp[1].max(dp[0] + nums[i])];
11+
}
12+
dp[1]
13+
};
14+
rob_range(0, n - 1).max(rob_range(1, n))
15+
}
16+
}

0 commit comments

Comments
 (0)