xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-06-28 16:44:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translate all code to English (#1836)

Browse Source 
* Review the EN heading format.

* Fix pythontutor headings.

* Fix pythontutor headings.

* bug fixes

* Fix headings in **/summary.md

* Revisit the CN-to-EN translation for Python code using Claude-4.5

* Revisit the CN-to-EN translation for Java code using Claude-4.5

* Revisit the CN-to-EN translation for Cpp code using Claude-4.5.

* Fix the dictionary.

* Fix cpp code translation for the multipart strings.

* Translate Go code to English.

* Update workflows to test EN code.

* Add EN translation for C.

* Add EN translation for CSharp.

* Add EN translation for Swift.

* Trigger the CI check.

* Revert.

* Update en/hash_map.md

* Add the EN version of Dart code.

* Add the EN version of Kotlin code.

* Add missing code files.

* Add the EN version of JavaScript code.

* Add the EN version of TypeScript code.

* Fix the workflows.

* Add the EN version of Ruby code.

* Add the EN version of Rust code.

* Update the CI check for the English version  code.

* Update Python CI check.

* Fix cmakelists for en/C code.

* Fix Ruby comments
This commit is contained in:
Yudong Jin
2025-12-31 07:44:52 +08:00
committed by GitHub
parent 45e1295241
commit 2778a6f9c7
1284 changed files with 71557 additions and 3275 deletions
Download Patch File Download Diff File Expand all files Collapse all files
en/codes/java/chapter_dynamic_programming/min_path_sum.java
+18 -18
View File
@@ -9,41 +9,41 @@ package chapter_dynamic_programming;
import java.util.Arrays;
public class min_path_sum {
/* Minimum path sum: Brute force search */
/* Minimum path sum: Brute-force search */
static int minPathSumDFS(int[][] grid, int i, int j) {
// If it's the top-left cell, terminate the search
if (i == 0 && j == 0) {
return grid[0][0];
}
// If the row or column index is out of bounds, return a +∞ cost
// If row or column index is out of bounds, return +∞ cost
if (i < 0 || j < 0) {
return Integer.MAX_VALUE;
}
// Calculate the minimum path cost from the top-left to (i-1, j) and (i, j-1)
// Calculate the minimum path cost from top-left to (i-1, j) and (i, j-1)
int up = minPathSumDFS(grid, i - 1, j);
int left = minPathSumDFS(grid, i, j - 1);
// Return the minimum path cost from the top-left to (i, j)
// Return the minimum path cost from top-left to (i, j)
return Math.min(left, up) + grid[i][j];
}
/* Minimum path sum: Memoized search */
/* Minimum path sum: Memoization search */
static int minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {
// If it's the top-left cell, terminate the search
if (i == 0 && j == 0) {
return grid[0][0];
}
// If the row or column index is out of bounds, return a +∞ cost
// If row or column index is out of bounds, return +∞ cost
if (i < 0 || j < 0) {
return Integer.MAX_VALUE;
}
// If there is a record, return it
// If there's a record, return it directly
if (mem[i][j] != -1) {
return mem[i][j];
}
// The minimum path cost from the left and top cells
// Minimum path cost for left and upper cells
int up = minPathSumDFSMem(grid, mem, i - 1, j);
int left = minPathSumDFSMem(grid, mem, i, j - 1);
// Record and return the minimum path cost from the top-left to (i, j)
// Record and return the minimum path cost from top-left to (i, j)
mem[i][j] = Math.min(left, up) + grid[i][j];
return mem[i][j];
}
@@ -62,7 +62,7 @@ public class min_path_sum {
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i - 1][0] + grid[i][0];
}
// State transition: the rest of the rows and columns
// State transition: rest of the rows and columns
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
@@ -81,11 +81,11 @@ public class min_path_sum {
for (int j = 1; j < m; j++) {
dp[j] = dp[j - 1] + grid[0][j];
}
// State transition: the rest of the rows
// State transition: rest of the rows
for (int i = 1; i < n; i++) {
// State transition: first column
dp[0] = dp[0] + grid[i][0];
// State transition: the rest of the columns
// State transition: rest of the columns
for (int j = 1; j < m; j++) {
dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];
}
@@ -102,24 +102,24 @@ public class min_path_sum {
};
int n = grid.length, m = grid[0].length;
// Brute force search
// Brute-force search
int res = minPathSumDFS(grid, n - 1, m - 1);
System.out.println("The minimum path sum from the top left corner to the bottom right corner is " + res);
System.out.println("Minimum path sum from top-left to bottom-right is " + res);
// Memoized search
// Memoization search
int[][] mem = new int[n][m];
for (int[] row : mem) {
Arrays.fill(row, -1);
}
res = minPathSumDFSMem(grid, mem, n - 1, m - 1);
System.out.println("The minimum path sum from the top left corner to the bottom right corner is " + res);
System.out.println("Minimum path sum from top-left to bottom-right is " + res);
// Dynamic programming
res = minPathSumDP(grid);
System.out.println("The minimum path sum from the top left corner to the bottom right corner is " + res);
System.out.println("Minimum path sum from top-left to bottom-right is " + res);
// Space-optimized dynamic programming
res = minPathSumDPComp(grid);
System.out.println("The minimum path sum from the top left corner to the bottom right corner is " + res);
System.out.println("Minimum path sum from top-left to bottom-right is " + res);
}
}