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.

Example

Example 1:
	Input:  [[1,3,1],[1,5,1],[4,2,1]]
	Output: 7
	
	Explanation:
	Path is: 1 -> 3 -> 1 -> 1 -> 1


Example 2:
	Input:  [[1,3,2]]
	Output: 6
	
	Explanation:  
	Path is: 1 -> 3 -> 2

Notice

You can only go right or down in the path..

思路：dp(i,j) = grid(i,j)+ Math.min(dp(i-1,j), dp(i,j-1)); 注意row, col，这两行列的初始化。

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];
        
        // calculate matrix;
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(i == 0 && j == 0) {
                   dp[0][0] = grid[0][0];
                } else if(j == 0 && i >= 1) {
                    dp[i][0] = dp[i - 1][0] + grid[i][0];
                } else if(i == 0 && j >= 1) {
                    dp[0][j] = dp[0][j - 1] + grid[0][j];
                } else {
                    dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
                }
            }
        }
        return dp[m - 1][n - 1];
    }
}

利用滚动数组，做到space O(N);

注意滚动数组的精髓是: 申请的数组f[]取模，而不是A数组取模，也不是循环减少，注意背后的思想；

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[2][n];
        
        // calculate matrix;
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(i == 0 && j == 0) {
                   dp[0][0] = grid[0][0];
                } else if(j == 0 && i >= 1) {
                    dp[i % 2][0] = dp[(i - 1) % 2][0] + grid[i][0];
                } else if(i == 0 && j >= 1) {
                    dp[0][j] = dp[0][j - 1] + grid[0][j];
                } else {
                    dp[i % 2][j] = Math.min(dp[(i - 1) % 2][j], dp[i % 2][j - 1]) + grid[i][j];
                }
            }
        }
        return dp[(m - 1) % 2][n - 1];
    }
}