64. 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.

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

public class Solution {
    public int minPathSum(int[][] grid) {
        int m = grid.length;// row
        int n = grid[0].length; // column
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i == 0 && j != 0) {
                    grid[i][j] = grid[i][j] + grid[i][j - 1];
                } else if (i != 0 && j == 0) {
                    grid[i][j] = grid[i][j] + grid[i - 1][j];
                } else if (i == 0 && j == 0) {
                    grid[i][j] = grid[i][j];
                } else {
                    grid[i][j] = Math.min(grid[i][j - 1], grid[i - 1][j]) + grid[i][j];
                }
            }
        }

        return grid[m - 1][n - 1];
    }
}

class Solution {
    public int minPathSum(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        
        int[][] dp = new int[m][n];

        // Fill dp array with -1 to signify we do not know price to get here
        for (int[] row: dp)
             Arrays.fill(row, -1);
        
        return getPrice(grid, dp, m - 1, n - 1);
    }
    
    /** dp stores cached prices, i and j represent the current index */
    private int getPrice(int[][] grid, int[][] dp, int i, int j) {
        if (i == 0 && j == 0) return grid[i][j];
        // If we are out of bounds, we can not travel here, maximum price
        if (i < 0 || j < 0) return Integer.MAX_VALUE;
        
        // Return min price at this location if we have been here before
        if (dp[i][j] >= 0) return dp[i][j];
        
        int price = grid[i][j];
        // Add the minimum price to the left or above this price, if they exist.
        price += Math.min(getPrice(grid, dp, i - 1, j), getPrice(grid, dp, i, j - 1));
        
        dp[i][j]  =  price;
        return price;
    }
}

/**
 * @param {number[][]} grid
 * @return {number}
 */
var minPathSum = function(grid) {
    let m = grid.length;
    let n = grid[0].length;
    let dp = new Array(m+1).fill([])
    dp.forEach((row,i) => {
        dp[i] = new Array(n+1).fill(0)
    })
    for(let i = 1;i<=m;i++) {
      for(let j = 1;j<=n;j++) {
        if (i==1) {
          dp[i][j] = dp[i][j-1] + grid[i-1][j-1];
        } else if (i!=1 && j==1) {
          dp[i][j] = dp[i-1][j] + grid[i-1][j-1];
        } else {
          let moveDown = dp[i-1][j] + grid[i-1][j-1];
          let moveRight = dp[i][j-1] + grid[i-1][j-1];
          dp[i][j] = Math.min(moveDown,moveRight);
        }
      }
    }
    return dp[m][n]
};

class Solution {
    public int minPathSum(int[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return 0;
        }
        int m = grid.length;
        int n = grid[0].length;
        int[][] dp = new int[m][n];
        return minPathSum(grid, 0, 0, dp);
    }

    public int minPathSum(int[][] grid, int y, int x, int[][] dp) {
        if (y == grid.length-1 && x == grid[y].length-1) {
            return grid[y][x];
        }
        if (dp[y][x] != 0) {
            return dp[y][x];
        }
        int min = Integer.MAX_VALUE;
        if (y < grid.length-1) {
            min = Math.min(min, minPathSum(grid, y+1, x, dp));
        }
        if (x < grid[y].length-1) {
            min = Math.min(min, minPathSum(grid, y, x+1, dp));
        }
        dp[y][x] = grid[y][x] + min;
        return dp[y][x];
    }
}