Minimum-Path-Sum——最小路径和

题目描述：

给定一个只含非负整数的m*n网格，找到一条从左上角到右下角的可以使数字和最小的路径。

 

样例 1:

输入:  [[1,3,1],[1,5,1],[4,2,1]]
输出: 7	
样例解释：
路线为： 1 -> 3 -> 1 -> 1 -> 1。

样例 2:

输入:  [[1,3,2]]
输出:  6
解释:  
路线是： 1 -> 3 -> 2

Notice

你在同一时间只能向下或者向右移动一步

 

AC代码：

public class Solution {

    /**
     * @param grid: a list of lists of integers
     * @return: An integer, minimizes the sum of all numbers along its path
     */
    public int minPathSum(int[][] grid) {
        // write your code here
        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]; // 代表(0, 0)到(i, j)的数字和最小的路径

        // 时间复杂度：O(mn) 空间复杂度：O(mn)
        // 为了降低空间复杂度，这里可以采用滚动数组

        int now = 0, old = 1;
        int top;
        int left;
        // 转移方程
        for (int i = 0; i < m; i++) {
            // 这里是滚动数组的最容易忽视的一点：考虑完一行之后才能滚动，不然会出错
            // 更新
            old = now;
            now = 1 - now;
            for ( int j = 0; j < n; j++) {
                // 左上角的点
                if (i == 0 && j == 0) {
                    // 初始化
                    dp[now][0] = grid[0][0];
                    continue;
                }
                dp[now][j] = grid[i][j];
                // 判断上面是否有点
                if (i > 0) {
                    // 上面有点
                    top = dp[old][j];
                } else {
                    // 这里设置为无穷大，是为了后面比较，因为是选最小的，反之如果选最大，这里
                    // 可以设置为无穷小
                    top = Integer.MAX_VALUE;
                }

                // 同理判断左边点是否存在
                if (j > 0) {
                    left = dp[now][j - 1];
                } else {
                    left = Integer.MAX_VALUE;
                }

                // 比较上面点和左边点的值哪个更小，最后不要忘了加上当前点的值
                if (top < left) {
                    dp[now][j] += top;
                } else {
                    dp[now][j] += left;
                }
            }
        }

        return dp[now][n - 1];
    }
}