动态规划之矩阵的最小路径和plus版---压缩空间法

在讲之前，我们先分析下上篇文章 动态规划之矩阵的最小路径和（非空间压缩法）的不足，上篇文章需要额外申请一个和 原矩阵相同空间的二维数组存放到达每个节点的路径和，而压缩空间法只需要申请一个长度为矩阵长宽较小值的一维数组，以滚动的方式求出最小路径和

非空间压缩法代码如下，具体分析可参考我的上一篇博客：

public class MinPathSum {
    public static void main(String[] args) {
        int a[][]={{1,3,5,9},
                    {8,1,3,4},
                    {5,0,6,1},
                    {8,8,4,0}};
        System.out.println(getMinPathSum(a));
    }
    private static int getMinPathSum(int [][]a){
        int[][] dp=new int[a.length][a[0].length];
        dp[0][0]=a[0][0];
        // 得出第一行的路径和
        for(int i=1;i<a[0].length;i++){
            dp[0][i]=dp[0][i-1]+a[0][i];
        }
        //得出第一列的路径和
        for(int j=1;j<a.length;j++){
            dp[j][0]=dp[j-1][0]+a[j][0];
        }
        //得出dp[i][j],i>=1,j>=1
        for(int i=1;i<dp.length;i++) {
            for (int j = 1; j < dp[0].length; j++) {
                dp[i][j]=getMin(dp[i-1][j],dp[i][j-1])+a[i][j];
            }
 
        }
        // 输出转换后的dp数组
        for(int i=0;i<dp.length;i++) {
            for (int j = 0; j < dp[0].length; j++) {
                System.out.print(dp[i][j]+" ");
            }
            System.out.println();
        }
        return dp[dp.length-1][dp[0].length-1];
    }
    private static int getMin(int a,int b){
        return a<b?a:b;

空间压缩法代码如下，大家可以做一下对比：

public class MinPathSum {
    public static void main(String[] args) {
        int a[][]={{1,3,5,9},
                {8,1,3,4},
                {5,0,6,1},
                {8,8,4,0}
                };

        System.out.println(getMinPathSum(a)) ;
    }
    private static int getMinPathSum(int[][] a){
        int min=a.length;
        int max=a[0].length;
        boolean rowLess=true;
        if(a.length>=a[0].length){
            min=a[0].length;
            max=a.length;
            rowLess=false;
        }
        int arr[]=new int[min];
        arr[0]=a[0][0];
        for(int i=1;i<min;i++){
            arr[i]=arr[i-1]+(rowLess?a[i][0]:a[0][i]);

        }
        for(int i=1;i<max;i++){
            arr[0]=(rowLess?a[0][i]:a[i][0])+arr[0];
            for (int j = 1; j <min ; j++) {
                arr[j]=Math.min(arr[j-1],arr[j])+(rowLess?a[j][i]:a[i][j]);
            }
        }

        return arr[min-1];
    }
}