动态规划之矩阵的最小路径和

题目： 给定一个m*n的矩阵，从左上角开始，每次只能向下或向右走，最后到达右下角的位置，路径上所有数字加起来就是路径的和，返回所有路径中最小的路径和

举例：

给定以下矩阵

1   3    5    9

8   1    3    4

5   0    6    1

8   8    4    0

路径 1--3---1--0--6---1---0是最小路径，最小路径和是12，那么怎么用动态规划来实现呢？

分析：

我们用二维数组a[m][n]来存储矩阵，到达a[i][j]的最短路径和用dp[i][j]来存储

a[0][i] 和a[j][0]的值我们可以很容易就算出来，因为到达这些节点只有一条路线

dp[0][0]=a[0][0],

dp[0][1]=dp[0][0]+a[0][1],

dp[0][2]=dp[0][1]+a[0][2]

以此类推，dp[0][i]=dp[0][i-1],i>1

同理得出dp[j][1]=dp[j-1][0],j>1

由此，现在的dp数组的值为

1      4        9       18

9

14

22

以此为基础，继续计算dp[1][1]=min（dp[1][0],dp[0],[1]）+a[1][1],到达a[i][j]（i>=1，j>=1）路径都有两条,取其中路径和最小的一条,得出dp[i][j]=min(dp[i-1],[j],dp[i],[j-1])+a[i][j]

解决该问题需要三个for循环

代码如下：

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;
    }