Minimum Path Sum

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.

Notice

You can only move either down or right at any point in time.

Solution 1: Search.

public int minPathSum(int[][] grid) {
    if(grid == null || grid.length == 0) {
        return 0;
    }
    int[] min = new int[1];
    min[0] = Integer.MAX_VALUE;
    return search(grid, 0, 0, 0, min);
}

public int search(int[][] grid, int i, int j, int sum, int[] min) {
    if(i < 0 || j < 0 || i >= grid.length || j >= grid[0].length) {
        return 0;
    }
    if(i == grid.length - 1 && j == grid[0].length - 1) {
        min[0] = grid[i][j];
        return min[0];
    } 
    if(i < grid.length - 1 && j < grid[0].length - 1) {
        min[0] = grid[i][j] + Math.min(search(grid, i + 1, j, sum + grid[i][j], min), 
                                       search(grid, i, j + 1, sum + grid[i][j], min));
        return min[0];
    }
    if(i < grid.length - 1) {
        min[0] = grid[i][j] + search(grid, i + 1, j, sum + grid[i][j], min);
        return min[0];
    }
    if(j < grid[0].length - 1) {
        min[0] = grid[i][j] + search(grid, i, j + 1, sum + grid[i][j], min);
        return min[0];
    }
    return 0;   
}

Solution 2: Memory Search.

public int minPathSum(int[][] grid) {
    if (grid == null || grid.length == 0 || grid[0].length == 0) {
        return 0;
    }
    int m = grid.length, n = grid[0].length;
    int[][] dp = new int[m][n];
    for(int i = 0; i < m; i++) {
        for(int j = 0; j < n; j++) {
            dp[i][j] = Integer.MAX_VALUE;
        }
    }
    search(grid, 0, 0, dp);
    return dp[0][0];
}

public int search(int[][] grid, int i, int j, int[][] dp) {
    if(i < 0 || j < 0 || i >= grid.length || j >= grid[0].length) {
        return 0;
    }
    if(dp[i][j] != Integer.MAX_VALUE) {
        return dp[i][j];
    }
    if(i == grid.length - 1 && j == grid[0].length - 1) {
        dp[i][j] = grid[i][j];
        return dp[i][j];
    }
    if(i < grid.length - 1 && j < grid[0].length - 1) {
        dp[i][j] = grid[i][j] + Math.min(search(grid, i, j + 1, dp), search(grid, i + 1, j, dp));
        return dp[i][j];
    }
    if(i < grid.length - 1) {
        dp[i][j] = grid[i][j] + search(grid, i + 1, j, dp);
        return dp[i][j];
    }
    if(j < grid[0].length - 1) {
        dp[i][j] = grid[i][j] + search(grid, i, j + 1, dp);
        return dp[i][j];
    }
    return 0;
}

Solution 3: DP

public int minPathSum(int[][] grid) {
    if (grid == null || grid.length == 0 || grid[0].length == 0) {
        return 0;
    }
    int m = grid.length, n = grid[0].length;
    int[][] dp = new int[m][n];
    dp[0][0] = grid[0][0];
    for(int i = 1; i < m; i++) {
        dp[i][0] = grid[i][0] + dp[i - 1][0];
    }
    for(int i = 1; i < n; i++) {
        dp[0][i] = grid[0][i] + dp[0][i - 1];
    }
    for(int i = 1; i < grid.length; i++) {
        for(int j = 1; j < grid[0].length; j++) {
            dp[i][j] = grid[i][j] + Math.min(dp[i - 1][j], dp[i][j - 1]);
        }
    }
    return dp[m - 1][n - 1];
}