modify code

algorithmzuo · algorithmzuo · commit 992b1d7d2190 · 2023-10-24T16:58:47.000+08:00
diff --git a/src/class067/Code01_MinimumPathSum.java b/src/class067/Code01_MinimumPathSum.java
@@ -7,25 +7,29 @@
 // 测试链接 : https://leetcode.cn/problems/minimum-path-sum/
 public class Code01_MinimumPathSum {
 
+	// 暴力递归
 	public static int minPathSum1(int[][] grid) {
 		return f1(grid, grid.length - 1, grid[0].length - 1);
 	}
 
+	// 从(0,0)到(i,j)最小路径和
+	// 一定每次只能向右或者向下
 	public static int f1(int[][] grid, int i, int j) {
 		if (i == 0 && j == 0) {
 			return grid[0][0];
 		}
 		int up = Integer.MAX_VALUE;
 		int left = Integer.MAX_VALUE;
-		if (i > 0) {
+		if (i - 1 >= 0) {
 			up = f1(grid, i - 1, j);
 		}
-		if (j > 0) {
+		if (j - 1 >= 0) {
 			left = f1(grid, i, j - 1);
 		}
 		return grid[i][j] + Math.min(up, left);
 	}
 
+	// 记忆化搜索
 	public static int minPathSum2(int[][] grid) {
 		int n = grid.length;
 		int m = grid[0].length;
@@ -48,10 +52,10 @@ public static int f2(int[][] grid, int i, int j, int[][] dp) {
 		} else {
 			int up = Integer.MAX_VALUE;
 			int left = Integer.MAX_VALUE;
-			if (i > 0) {
+			if (i - 1 >= 0) {
 				up = f2(grid, i - 1, j, dp);
 			}
-			if (j > 0) {
+			if (j - 1 >= 0) {
 				left = f2(grid, i, j - 1, dp);
 			}
 			ans = grid[i][j] + Math.min(up, left);
@@ -60,6 +64,7 @@ public static int f2(int[][] grid, int i, int j, int[][] dp) {
 		return ans;
 	}
 
+	// 严格位置依赖的动态规划
 	public static int minPathSum3(int[][] grid) {
 		int n = grid.length;
 		int m = grid[0].length;
@@ -79,15 +84,22 @@ public static int minPathSum3(int[][] grid) {
 		return dp[n - 1][m - 1];
 	}
 
+	// 严格位置依赖的动态规划 + 空间压缩技巧
 	public static int minPathSum4(int[][] grid) {
 		int n = grid.length;
 		int m = grid[0].length;
+		// 先让dp表，变成想象中的表的第0行的数据
 		int[] dp = new int[m];
 		dp[0] = grid[0][0];
 		for (int j = 1; j < m; j++) {
 			dp[j] = dp[j - 1] + grid[0][j];
 		}
 		for (int i = 1; i < n; i++) {
+			// i = 1，dp表变成想象中二维表的第1行的数据
+			// i = 2，dp表变成想象中二维表的第2行的数据
+			// i = 3，dp表变成想象中二维表的第3行的数据
+			// ...
+			// i = n-1，dp表变成想象中二维表的第n-1行的数据
 			dp[0] += grid[i][0];
 			for (int j = 1; j < m; j++) {
 				dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];
diff --git a/src/class067/Code03_LongestCommonSubsequence.java b/src/class067/Code03_LongestCommonSubsequence.java
@@ -6,7 +6,7 @@
 // 如果不存在公共子序列，返回0
 // 两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列
 // 测试链接 : https://leetcode.cn/problems/longest-common-subsequence/
-public class Code04_LongestCommonSubsequence {
+public class Code03_LongestCommonSubsequence {
 
 	public static int longestCommonSubsequence1(String str1, String str2) {
 		char[] s1 = str1.toCharArray();
diff --git a/src/class067/Code04_LongestPalindromicSubsequence.java b/src/class067/Code04_LongestPalindromicSubsequence.java
@@ -3,7 +3,7 @@
 // 最长回文子序列
 // 给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度
 // 测试链接 : https://leetcode.cn/problems/longest-palindromic-subsequence/
-public class Code05_LongestPalindromicSubsequence {
+public class Code04_LongestPalindromicSubsequence {
 
 	// 最长回文子序列问题可以转化成最长公共子序列问题
 	// 不过这里讲述区间动态规划的思路
diff --git a/src/class067/Code05_NodenHeightNotLargerThanm.java b/src/class067/Code05_NodenHeightNotLargerThanm.java
@@ -16,7 +16,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code06_NodenHeightNotLargerThanm {
+public class Code05_NodenHeightNotLargerThanm {
 
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
diff --git a/src/class067/Code06_LongestIncreasingPath.java b/src/class067/Code06_LongestIncreasingPath.java
@@ -5,7 +5,7 @@
 // 对于每个单元格，你可以往上，下，左，右四个方向移动
 // 你 不能 在 对角线 方向上移动或移动到 边界外（即不允许环绕）
 // 测试链接 : https://leetcode.cn/problems/longest-increasing-path-in-a-matrix/
-public class Code03_LongestIncreasingPath {
+public class Code06_LongestIncreasingPath {
 
 	public static int longestIncreasingPath1(int[][] grid) {
 		int ans = 0;
