【动态规划】 LeetCode # 64 最小路径和 （空间复杂度为O(n)）

题目链接：

LeetCode # 64 最小路径和

题目描述：

64. 最小路径和
    给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

示例:

输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

第一次提交：

本题属于路径问题，是经典的动态规划题型之一。

设 dp[i][j] 为走到 grid[i][j] 的最小路径和（包含第 i 行第 j 列元素），状态转移方程式：
dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]
其中，dp[i-1][j] 表示是从上方来的，dp[i][j-1]表示是从左方来的。

特殊情况：

对于第一行的其他元素（除（0,0）外），只能从左边来：
dp[i][j] = dp[i][j-1] + grid[i][j]

对于第一列的其他元素（除（0,0）外），只能从上边来：
dp[i][j] = dp[i-1][j] + grid[i][j]

返回的结果应该为dp[m-1][n-1]。

代码：

/*
*路径问题，经典的动态规划题型之一
*设 dp[i][j] 为走到 grid[i][j] 的最小路径和（包含第 i 行第 j 列元素）
*从上方或者左方而来，状态转移方程式：
*dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]
*初始化：dp[0][0] = grid[0][0]
*特殊情况：
*对于第一行的其他元素，只能从左边来：dp[i][j] = dp[i][j-1] + grid[i][j]
*对于第一列的其他元素，只能从上边来：dp[i][j] = dp[i-1][j] + grid[i][j]
*返回的结果应该为dp[m-1][n-1]
*/
class Solution {
    public int minPathSum(int[][] grid) {
        int[][] dp = new int[grid.length][grid[0].length];
        dp[0][0] = grid[0][0];
        for(int j = 1; j < grid[0].length; j++){//第一行除第一个元素外，只能从左边来
            dp[0][j] = dp[0][j-1] + grid[0][j];
        }
        for(int i = 1; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                if(j == 0){ dp[i][j] = dp[i-1][j] + grid[i][j];}
                else{
                    dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
                }
            }
        }
        return dp[grid.length-1][grid[0].length-1];
    }
}

优化：

第一次提交的代码中，创建了二维数组 dp[i][j]，算法空间复杂度为 O(n^2)，能不能把空间复杂度降低到 O(n) 呢？

答案当然是可以的。这个题每次计算 dp[i][j] 只用到了其左方、上方的数据，最后返回的是 dp 的最后一行最后一列，因此不需要创建二维数组 dp[][]，可以创建一维数组 dp[] 用来存储上一行的内容，左方的数据可以通过 dp[j-1] 获得。因为对每一行进行正序循环时，赋值前 dp[j] 是正上方的数据，dp[j-1]已经更新为了这一行的数据，即左方的数据。

优化后的代码：空间复杂度为O(n)

/*
*路径问题，经典的动态规划题型之一
*设 dp[i][j] 为走到 grid[i][j] 的最小路径和（包含第 i 行第 j 列元素）
*从上方或者左方而来，状态转移方程式：
*dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]
*初始化：dp[0][0] = grid[0][0]
*特殊情况：
*对于第一行的其他元素，只能从左边来：dp[i][j] = dp[i][j-1] + grid[i][j]
*对于第一列的其他元素，只能从上边来：dp[i][j] = dp[i-1][j] + grid[i][j]
*返回的结果应该为dp[m-1][n-1]
*优化：这个题每次计算dp[i][j]只用到了其左方、上方的数据，最后返回的是dp的最后一行最后一列，因此不需要创建二维数组dp[][]，可以创建一维数组dp[]用来存储上一行的内容，左方的数据可以通过dp[j-1]获得，每行正序循环，赋值前dp[j]是正上方的数据，dp[j-1]已经更新为了这一行的数据，即左方的数据
*/
class Solution {
    public int minPathSum(int[][] grid) {
        int[] dp = new int[grid[0].length];
        dp[0] = grid[0][0];
        for(int j = 1; j < grid[0].length; j++){//第一行除第一个元素外，只能从左边来
            dp[j] = dp[j-1] + grid[0][j];
            //System.out.print(dp[j] + " ");
        }
        //System.out.println();
        for(int i = 1; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                if(j == 0){ dp[j] = dp[j] + grid[i][j];}
                else{
                    dp[j] = Math.min(dp[j], dp[j-1]) + grid[i][j];//dp[j]是上方数据，dp[j-1]是左方数据
                }
                // System.out.print(dp[j] + " ");
            }
            //System.out.println();
        }
        return dp[grid[0].length-1];
    }
}