Skip to content

Commit 7b48104

Browse files
algorithmzuoalgorithmzuo
committed
modify code
1 parent 45571ec commit 7b48104

6 files changed

+522
-0
lines changed

‎src/class067/Code01_MinimumPathSum.java‎

Lines changed: 99 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,99 @@
1+
package class067;
2+
3+
// 最小路径和
4+
// 给定一个包含非负整数的 m x n 网格 grid
5+
// 请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
6+
// 说明：每次只能向下或者向右移动一步。
7+
// 测试链接 : https://leetcode.cn/problems/minimum-path-sum/
8+
public class Code01_MinimumPathSum {
9+
10+
public static int minPathSum1(int[][] grid) {
11+
return f1(grid, grid.length - 1, grid[0].length - 1);
12+
}
13+
14+
public static int f1(int[][] grid, int i, int j) {
15+
if (i == 0 && j == 0) {
16+
return grid[0][0];
17+
}
18+
int up = Integer.MAX_VALUE;
19+
int left = Integer.MAX_VALUE;
20+
if (i > 0) {
21+
up = f1(grid, i - 1, j);
22+
}
23+
if (j > 0) {
24+
left = f1(grid, i, j - 1);
25+
}
26+
return grid[i][j] + Math.min(up, left);
27+
}
28+
29+
public static int minPathSum2(int[][] grid) {
30+
int n = grid.length;
31+
int m = grid[0].length;
32+
int[][] dp = new int[n][m];
33+
for (int i = 0; i < n; i++) {
34+
for (int j = 0; j < m; j++) {
35+
dp[i][j] = -1;
36+
}
37+
}
38+
return f2(grid, grid.length - 1, grid[0].length - 1, dp);
39+
}
40+
41+
public static int f2(int[][] grid, int i, int j, int[][] dp) {
42+
if (dp[i][j] != -1) {
43+
return dp[i][j];
44+
}
45+
int ans;
46+
if (i == 0 && j == 0) {
47+
ans = grid[0][0];
48+
} else {
49+
int up = Integer.MAX_VALUE;
50+
int left = Integer.MAX_VALUE;
51+
if (i > 0) {
52+
up = f2(grid, i - 1, j, dp);
53+
}
54+
if (j > 0) {
55+
left = f2(grid, i, j - 1, dp);
56+
}
57+
ans = grid[i][j] + Math.min(up, left);
58+
}
59+
dp[i][j] = ans;
60+
return ans;
61+
}
62+
63+
public static int minPathSum3(int[][] grid) {
64+
int n = grid.length;
65+
int m = grid[0].length;
66+
int[][] dp = new int[n][m];
67+
dp[0][0] = grid[0][0];
68+
for (int i = 1; i < n; i++) {
69+
dp[i][0] = dp[i - 1][0] + grid[i][0];
70+
}
71+
for (int j = 1; j < m; j++) {
72+
dp[0][j] = dp[0][j - 1] + grid[0][j];
73+
}
74+
for (int i = 1; i < n; i++) {
75+
for (int j = 1; j < m; j++) {
76+
dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
77+
}
78+
}
79+
return dp[n - 1][m - 1];
80+
}
81+
82+
public static int minPathSum4(int[][] grid) {
83+
int n = grid.length;
84+
int m = grid[0].length;
85+
int[] dp = new int[m];
86+
dp[0] = grid[0][0];
87+
for (int j = 1; j < m; j++) {
88+
dp[j] = dp[j - 1] + grid[0][j];
89+
}
90+
for (int i = 1; i < n; i++) {
91+
dp[0] += grid[i][0];
92+
for (int j = 1; j < m; j++) {
93+
dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];
94+
}
95+
}
96+
return dp[m - 1];
97+
}
98+
99+
}

‎src/class067/Code02_WordSearch.java‎

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
package class067;
2+
3+
// 单词搜索
4+
// 给定一个 m x n 二维字符网格 board 和一个字符串单词 word
5+
// 如果 word 存在于网格中，返回 true ；否则，返回 false 。
6+
// 单词必须按照字母顺序，通过相邻的单元格内的字母构成
7+
// 其中"相邻"单元格是那些水平相邻或垂直相邻的单元格
8+
// 同一个单元格内的字母不允许被重复使用
9+
// 测试链接 : https://leetcode.cn/problems/word-search/
10+
public class Code02_WordSearch {
11+
12+
public static boolean exist(char[][] board, String word) {
13+
char[] w = word.toCharArray();
14+
for (int i = 0; i < board.length; i++) {
15+
for (int j = 0; j < board[0].length; j++) {
16+
if (f(board, i, j, w, 0)) {
17+
return true;
18+
}
19+
}
20+
}
21+
return false;
22+
}
23+
24+
// 因为board会改其中的字符
25+
// 用来标记哪些字符无法再用
26+
// 带路径的递归无法改成动态规划或者说没必要
27+
public static boolean f(char[][] b, int i, int j, char[] w, int k) {
28+
if (k == w.length) {
29+
return true;
30+
}
31+
if (i < 0 || i == b.length || j < 0 || j == b[0].length || b[i][j] != w[k]) {
32+
return false;
33+
}
34+
char tmp = b[i][j];
35+
b[i][j] = 0;
36+
boolean ans = f(b, i - 1, j, w, k + 1)
37+
|| f(b, i + 1, j, w, k + 1)
38+
|| f(b, i, j - 1, w, k + 1)
39+
|| f(b, i, j + 1, w, k + 1);
40+
b[i][j] = tmp;
41+
return ans;
42+
}
43+
44+
}

‎src/class067/Code03_LongestIncreasingPath.java‎

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
package class067;
2+
3+
// 矩阵中的最长递增路径
4+
// 给定一个 m x n 整数矩阵 matrix ，找出其中 最长递增路径 的长度
5+
// 对于每个单元格，你可以往上，下，左，右四个方向移动
6+
// 你 不能 在 对角线 方向上移动或移动到 边界外（即不允许环绕）
7+
// 测试链接 : https://leetcode.cn/problems/longest-increasing-path-in-a-matrix/
8+
public class Code03_LongestIncreasingPath {
9+
10+
public static int longestIncreasingPath1(int[][] grid) {
11+
int ans = 0;
12+
for (int i = 0; i < grid.length; i++) {
13+
for (int j = 0; j < grid[0].length; j++) {
14+
ans = Math.max(ans, f1(grid, i, j));
15+
}
16+
}
17+
return ans;
18+
}
19+
20+
public static int f1(int[][] grid, int i, int j) {
21+
int next = 0;
22+
if (i > 0 && grid[i][j] < grid[i - 1][j]) {
23+
next = Math.max(next, f1(grid, i - 1, j));
24+
}
25+
if (i + 1 < grid.length && grid[i][j] < grid[i + 1][j]) {
26+
next = Math.max(next, f1(grid, i + 1, j));
27+
}
28+
if (j > 0 && grid[i][j] < grid[i][j - 1]) {
29+
next = Math.max(next, f1(grid, i, j - 1));
30+
}
31+
if (j + 1 < grid[0].length && grid[i][j] < grid[i][j + 1]) {
32+
next = Math.max(next, f1(grid, i, j + 1));
33+
}
34+
return next + 1;
35+
}
36+
37+
public static int longestIncreasingPath2(int[][] grid) {
38+
int n = grid.length;
39+
int m = grid[0].length;
40+
int[][] dp = new int[n][m];
41+
int ans = 0;
42+
for (int i = 0; i < n; i++) {
43+
for (int j = 0; j < m; j++) {
44+
ans = Math.max(ans, f2(grid, i, j, dp));
45+
}
46+
}
47+
return ans;
48+
}
49+
50+
public static int f2(int[][] grid, int i, int j, int[][] dp) {
51+
if (dp[i][j] != 0) {
52+
return dp[i][j];
53+
}
54+
int next = 0;
55+
if (i > 0 && grid[i][j] < grid[i - 1][j]) {
56+
next = Math.max(next, f2(grid, i - 1, j, dp));
57+
}
58+
if (i + 1 < grid.length && grid[i][j] < grid[i + 1][j]) {
59+
next = Math.max(next, f2(grid, i + 1, j, dp));
60+
}
61+
if (j > 0 && grid[i][j] < grid[i][j - 1]) {
62+
next = Math.max(next, f2(grid, i, j - 1, dp));
63+
}
64+
if (j + 1 < grid[0].length && grid[i][j] < grid[i][j + 1]) {
65+
next = Math.max(next, f2(grid, i, j + 1, dp));
66+
}
67+
dp[i][j] = next + 1;
68+
return next + 1;
69+
}
70+
71+
}

‎src/class067/Code04_LongestCommonSubsequence.java‎

Lines changed: 105 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,105 @@
1+
package class067;
2+
3+
// 最长公共子序列
4+
// 给定两个字符串text1和text2
5+
// 返回这两个字符串的最长 公共子序列 的长度
6+
// 如果不存在公共子序列，返回0
7+
// 两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列
8+
// 测试链接 : https://leetcode.cn/problems/longest-common-subsequence/
9+
public class Code04_LongestCommonSubsequence {
10+
11+
public static int longestCommonSubsequence1(String str1, String str2) {
12+
char[] s1 = str1.toCharArray();
13+
char[] s2 = str2.toCharArray();
14+
int n = s1.length;
15+
int m = s2.length;
16+
return f1(s1, s2, n - 1, m - 1);
17+
}
18+
19+
public static int f1(char[] s1, char[] s2, int i1, int i2) {
20+
if (i1 < 0 || i2 < 0) {
21+
return 0;
22+
}
23+
int p1 = f1(s1, s2, i1 - 1, i2 - 1);
24+
int p2 = f1(s1, s2, i1 - 1, i2);
25+
int p3 = f1(s1, s2, i1, i2 - 1);
26+
int p4 = s1[i1] == s2[i2] ? (p1 + 1) : 0;
27+
return Math.max(Math.max(p1, p2), Math.max(p3, p4));
28+
}
29+
30+
public static int longestCommonSubsequence2(String str1, String str2) {
31+
char[] s1 = str1.toCharArray();
32+
char[] s2 = str2.toCharArray();
33+
int n = s1.length;
34+
int m = s2.length;
35+
int[][] dp = new int[n][m];
36+
for (int i = 0; i < n; i++) {
37+
for (int j = 0; j < m; j++) {
38+
dp[i][j] = -1;
39+
}
40+
}
41+
return f2(s1, s2, n - 1, m - 1, dp);
42+
}
43+
44+
public static int f2(char[] s1, char[] s2, int i1, int i2, int[][] dp) {
45+
if (i1 < 0 || i2 < 0) {
46+
return 0;
47+
}
48+
if (dp[i1][i2] != -1) {
49+
return dp[i1][i2];
50+
}
51+
int ans;
52+
if (s1[i1] == s2[i2]) {
53+
ans = f2(s1, s2, i1 - 1, i2 - 1, dp) + 1;
54+
} else {
55+
ans = Math.max(f2(s1, s2, i1 - 1, i2, dp), f2(s1, s2, i1, i2 - 1, dp));
56+
}
57+
dp[i1][i2] = ans;
58+
return ans;
59+
}
60+
61+
public static int longestCommonSubsequence3(String str1, String str2) {
62+
char[] s1 = str1.toCharArray();
63+
char[] s2 = str2.toCharArray();
64+
int n = s1.length;
65+
int m = s2.length;
66+
int[][] dp = new int[n][m];
67+
for (int i1 = 0; i1 < n; i1++) {
68+
for (int i2 = 0; i2 < m; i2++) {
69+
if (s1[i1] == s2[i2]) {
70+
dp[i1][i2] = 1 + (i1 > 0 && i2 > 0 ? dp[i1 - 1][i2 - 1] : 0);
71+
} else {
72+
dp[i1][i2] = Math.max(i1 > 0 ? dp[i1 - 1][i2] : 0, i2 > 0 ? dp[i1][i2 - 1] : 0);
73+
}
74+
}
75+
}
76+
return dp[n - 1][m - 1];
77+
}
78+
79+
public static int longestCommonSubsequence4(String str1, String str2) {
80+
char[] s1, s2;
81+
if (str1.length() >= str2.length()) {
82+
s1 = str1.toCharArray();
83+
s2 = str2.toCharArray();
84+
} else {
85+
s1 = str2.toCharArray();
86+
s2 = str1.toCharArray();
87+
}
88+
int n = s1.length;
89+
int m = s2.length;
90+
int[] dp = new int[m];
91+
for (int i1 = 0, tmp1 = 0, tmp2; i1 < n; i1++) {
92+
for (int i2 = 0; i2 < m; i2++) {
93+
tmp2 = dp[i2];
94+
if (s1[i1] == s2[i2]) {
95+
dp[i2] = 1 + (i1 > 0 && i2 > 0 ? tmp1 : 0);
96+
} else {
97+
dp[i2] = Math.max(i1 > 0 ? dp[i2] : 0, i2 > 0 ? dp[i2 - 1] : 0);
98+
}
99+
tmp1 = tmp2;
100+
}
101+
}
102+
return dp[m - 1];
103+
}
104+
105+
}

0 commit comments

Comments
 (0)