LeetCode – Minimum Path Sum (Java)

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Java Solution 1: Depth-First Search

A native solution would be depth-first search. It's time is too expensive and fails the online judgement.

public int minPathSum(int[][] grid) {
    return dfs(0,0,grid);
}
 
public int dfs(int i, int j, int[][] grid){
    if(i==grid.length-1 && j==grid[0].length-1){
        return grid[i][j];
    }
 
    if(i<grid.length-1 && j<grid[0].length-1){
        int r1 = grid[i][j] + dfs(i+1, j, grid);
        int r2 = grid[i][j] + dfs(i, j+1, grid);
        return Math.min(r1,r2);
    }
 
    if(i<grid.length-1){
        return grid[i][j] + dfs(i+1, j, grid);
    }
 
    if(j<grid[0].length-1){
        return grid[i][j] + dfs(i, j+1, grid);
    }
 
    return 0;
}

Java Solution 2: Dynamic Programming

public int minPathSum(int[][] grid) {
    if(grid == null || grid.length==0)
        return 0;
 
    int m = grid.length;
    int n = grid[0].length;
 
    int[][] dp = new int[m][n];
    dp[0][0] = grid[0][0];    
 
    // initialize top row
    for(int i=1; i<n; i++){
        dp[0][i] = dp[0][i-1] + grid[0][i];
    }
 
    // initialize left column
    for(int j=1; j<m; j++){
        dp[j][0] = dp[j-1][0] + grid[j][0];
    }
 
    // fill up the dp table
    for(int i=1; i<m; i++){
        for(int j=1; j<n; j++){
            if(dp[i-1][j] > dp[i][j-1]){
                dp[i][j] = dp[i][j-1] + grid[i][j];
            }else{
                dp[i][j] = dp[i-1][j] + grid[i][j];
            }
        }
    }
 
    return dp[m-1][n-1];
}

If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example:

<pre><code> 
String foo = "bar";
</code></pre>

ABK

Exactly
AJ

static int minPath(int[][] a) {
if (a == null || a.length == 0) {
return 0;
}
int m = a.length;
int n = a[0].length;
for (int i = 1; i < m; i++) {
a[i][0] = a[i – 1][0] + a[i][0];
}

for (int j = 1; j < n; j++) {
a[0][j] = a[0][j – 1] + a[0][j];
}

for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
a[i][j] = Math.min(a[i – 1][j], a[i][j – 1]) + a[i][j];
}
}
return a[m – 1][n – 1];
}
Vasyl Grygoryev

For 2nd solution we can use only one row for temp datas – O(n) extra space:
public int minPathSum(int[][] grid) { if (grid == null || grid.length == 0 || grid[0].length == 0) return 0;
int[] temp = new int[grid[0].length]; for (int i = 0; i < grid.length; i++) for (int j = 0; j 0) if (i > 0) temp[j] = Math.min(temp[j], temp[j - 1]); else temp[j] = temp[j - 1]; temp[j] += grid[i][j]; }
return temp[temp.length - 1]; }
Ryan Shaw

Dijkstra algorithm is the solution.
Sharan Srinivasan

The recursive dfs method can be made more efficient with memoization. Store each i,j value previously computed and call it each it you need it – following the first computation
jason zhang

The DP assumes that we can only walk down, but not up. If we can walk up, this is a a shortest ptah problem

LeetCode – Minimum Path Sum (Java)

Related posts: