Skip to content

Commit e5c8396

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc/lcof2 problems
lc No.0329 & lcof2 No.112.Longest Increasing Path in a Matrix
1 parent d20cd54 commit e5c8396

File tree

11 files changed

+686
-75
lines changed

11 files changed

+686
-75
lines changed

‎lcof2/剑指 Offer II 112. 最长递增路径/README.md

+148-1
Original file line numberDiff line numberDiff line change
@@ -55,22 +55,169 @@
5555

5656
<!-- 这里可写通用的实现逻辑 -->
5757

58+
记忆化搜索。
59+
5860
<!-- tabs:start -->
5961

6062
### **Python3**
6163

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

6466
```python
65-
67+
class Solution:
68+
def longestIncreasingPath(self, matrix: List[List[int]]) -> int:
69+
@lru_cache(None)
70+
def dfs(i, j):
71+
ans = 1
72+
for a, b in [[-1, 0], [1, 0], [0, 1], [0, -1]]:
73+
x, y = i + a, j + b
74+
if 0 <= x < m and 0 <= y < n and matrix[x][y] > matrix[i][j]:
75+
ans = max(ans, dfs(x, y) + 1)
76+
return ans
77+
78+
ans = 0
79+
m, n = len(matrix), len(matrix[0])
80+
for i in range(m):
81+
for j in range(n):
82+
ans = max(ans, dfs(i, j))
83+
return ans
6684
```
6785

6886
### **Java**
6987

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

7290
```java
91+
class Solution {
92+
93+
private int[][] memo;
94+
private int[][] matrix;
95+
private int m;
96+
private int n;
97+
98+
public int longestIncreasingPath(int[][] matrix) {
99+
this.matrix = matrix;
100+
m = matrix.length;
101+
n = matrix[0].length;
102+
memo = new int[m][n];
103+
for (int i = 0; i < m; ++i) {
104+
Arrays.fill(memo[i], -1);
105+
}
106+
int ans = 0;
107+
for (int i = 0; i < m; ++i) {
108+
for (int j = 0; j < n; ++j) {
109+
ans = Math.max(ans, dfs(i, j));
110+
}
111+
}
112+
return ans;
113+
}
114+
115+
private int dfs(int i, int j) {
116+
if (memo[i][j] != -1) {
117+
return memo[i][j];
118+
}
119+
int ans = 1;
120+
int[][] dirs = { { 0, -1 }, { 0, 1 }, { 1, 0 }, { -1, 0 } };
121+
for (int[] dir : dirs) {
122+
int x = i + dir[0], y = j + dir[1];
123+
if (
124+
x >= 0 &&
125+
x < m &&
126+
y >= 0 &&
127+
y < n &&
128+
matrix[x][y] > matrix[i][j]
129+
) {
130+
ans = Math.max(ans, dfs(x, y) + 1);
131+
}
132+
}
133+
memo[i][j] = ans;
134+
return ans;
135+
}
136+
}
137+
138+
```
139+
140+
### **C++**
141+
142+
```cpp
143+
class Solution {
144+
public:
145+
vector<vector<int>> memo;
146+
vector<vector<int>> matrix;
147+
int m;
148+
int n;
149+
150+
int longestIncreasingPath(vector<vector<int>>& matrix) {
151+
m = matrix.size();
152+
n = matrix[0].size();
153+
memo.resize(m, vector<int>(n, -1));
154+
this->matrix = matrix;
155+
int ans = 0;
156+
for (int i = 0; i < m; ++i)
157+
for (int j = 0; j < n; ++j)
158+
ans = max(ans, dfs(i, j));
159+
return ans;
160+
}
161+
162+
int dfs(int i, int j) {
163+
if (memo[i][j] != -1) return memo[i][j];
164+
int ans = 1;
165+
vector<vector<int>> dirs = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
166+
for (auto& dir : dirs)
167+
{
168+
int x = i + dir[0], y = j + dir[1];
169+
if (x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[i][j])
170+
ans = max(ans, dfs(x, y) + 1);
171+
}
172+
memo[i][j] = ans;
173+
return ans;
174+
}
175+
};
176+
```
73177
178+
### **Go**
179+
180+
```go
181+
func longestIncreasingPath(matrix [][]int) int {
182+
m, n := len(matrix), len(matrix[0])
183+
memo := make([][]int, m)
184+
for i := range memo {
185+
memo[i] = make([]int, n)
186+
for j := range memo[i] {
187+
memo[i][j] = -1
188+
}
189+
}
190+
ans := -1
191+
var dfs func(i, j int) int
192+
dfs = func(i, j int) int {
193+
if memo[i][j] != -1 {
194+
return memo[i][j]
195+
}
196+
ans := 1
197+
dirs := [4][2]int{{-1, 0}, {1, 0}, {0, 1}, {0, -1}}
198+
for _, dir := range dirs {
199+
x, y := i+dir[0], j+dir[1]
200+
if x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[i][j] {
201+
ans = max(ans, dfs(x, y)+1)
202+
}
203+
}
204+
memo[i][j] = ans
205+
return ans
206+
}
207+
for i := 0; i < m; i++ {
208+
for j := 0; j < n; j++ {
209+
ans = max(ans, dfs(i, j))
210+
}
211+
}
212+
return ans
213+
}
214+
215+
func max(a, b int) int {
216+
if a > b {
217+
return a
218+
}
219+
return b
220+
}
74221
```
75222

76223
### **...**

‎lcof2/剑指 Offer II 112. 最长递增路径/Solution.cpp

+33
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
class Solution {
2+
public:
3+
vector<vector<int>> memo;
4+
vector<vector<int>> matrix;
5+
int m;
6+
int n;
7+
8+
int longestIncreasingPath(vector<vector<int>>& matrix) {
9+
m = matrix.size();
10+
n = matrix[0].size();
11+
memo.resize(m, vector<int>(n, -1));
12+
this->matrix = matrix;
13+
int ans = 0;
14+
for (int i = 0; i < m; ++i)
15+
for (int j = 0; j < n; ++j)
16+
ans = max(ans, dfs(i, j));
17+
return ans;
18+
}
19+
20+
int dfs(int i, int j) {
21+
if (memo[i][j] != -1) return memo[i][j];
22+
int ans = 1;
23+
vector<vector<int>> dirs = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
24+
for (auto& dir : dirs)
25+
{
26+
int x = i + dir[0], y = j + dir[1];
27+
if (x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[i][j])
28+
ans = max(ans, dfs(x, y) + 1);
29+
}
30+
memo[i][j] = ans;
31+
return ans;
32+
}
33+
};

‎lcof2/剑指 Offer II 112. 最长递增路径/Solution.go

+40
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
1+
func longestIncreasingPath(matrix [][]int) int {
2+
m, n := len(matrix), len(matrix[0])
3+
memo := make([][]int, m)
4+
for i := range memo {
5+
memo[i] = make([]int, n)
6+
for j := range memo[i] {
7+
memo[i][j] = -1
8+
}
9+
}
10+
ans := -1
11+
var dfs func(i, j int) int
12+
dfs = func(i, j int) int {
13+
if memo[i][j] != -1 {
14+
return memo[i][j]
15+
}
16+
ans := 1
17+
dirs := [4][2]int{{-1, 0}, {1, 0}, {0, 1}, {0, -1}}
18+
for _, dir := range dirs {
19+
x, y := i+dir[0], j+dir[1]
20+
if x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[i][j] {
21+
ans = max(ans, dfs(x, y)+1)
22+
}
23+
}
24+
memo[i][j] = ans
25+
return ans
26+
}
27+
for i := 0; i < m; i++ {
28+
for j := 0; j < n; j++ {
29+
ans = max(ans, dfs(i, j))
30+
}
31+
}
32+
return ans
33+
}
34+
35+
func max(a, b int) int {
36+
if a > b {
37+
return a
38+
}
39+
return b
40+
}

‎lcof2/剑指 Offer II 112. 最长递增路径/Solution.java

+39
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
class Solution {
2+
private int[][] memo;
3+
private int[][] matrix;
4+
private int m;
5+
private int n;
6+
7+
public int longestIncreasingPath(int[][] matrix) {
8+
this.matrix = matrix;
9+
m = matrix.length;
10+
n = matrix[0].length;
11+
memo = new int[m][n];
12+
for (int i = 0; i < m; ++i) {
13+
Arrays.fill(memo[i], -1);
14+
}
15+
int ans = 0;
16+
for (int i = 0; i < m; ++i) {
17+
for (int j = 0; j < n; ++j) {
18+
ans = Math.max(ans, dfs(i, j));
19+
}
20+
}
21+
return ans;
22+
}
23+
24+
private int dfs(int i, int j) {
25+
if (memo[i][j] != -1) {
26+
return memo[i][j];
27+
}
28+
int ans = 1;
29+
int[][] dirs = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
30+
for (int[] dir : dirs) {
31+
int x = i + dir[0], y = j + dir[1];
32+
if (x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[i][j]) {
33+
ans = Math.max(ans, dfs(x, y) + 1);
34+
}
35+
}
36+
memo[i][j] = ans;
37+
return ans;
38+
}
39+
}

‎lcof2/剑指 Offer II 112. 最长递增路径/Solution.py

+17
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
class Solution:
2+
def longestIncreasingPath(self, matrix: List[List[int]]) -> int:
3+
@lru_cache(None)
4+
def dfs(i, j):
5+
ans = 1
6+
for a, b in [[-1, 0], [1, 0], [0, 1], [0, -1]]:
7+
x, y = i + a, j + b
8+
if 0 <= x < m and 0 <= y < n and matrix[x][y] > matrix[i][j]:
9+
ans = max(ans, dfs(x, y) + 1)
10+
return ans
11+
12+
ans = 0
13+
m, n = len(matrix), len(matrix[0])
14+
for i in range(m):
15+
for j in range(n):
16+
ans = max(ans, dfs(i, j))
17+
return ans

0 commit comments

Comments
 (0)