coolwriter的博客

分享才能快乐

动态规划(六)最短路径

题目
给定一个矩阵m,从左上角开始每次只能向右或者向下走,最后到达右下角的位置,路径上所有的数字累加起来就是路径和,返回所有路径中最小的路径和。
例子:
给定m如下:
1 3 5 9
8 1 3 4
5 0 6 1
8 8 4 0
路径1,3,1,0,6,1,0是所有路径中路径和最小的,所以返回12。
解法1

思路:

使用动态规划,定义 dp[M][N] , M ,N 分别代表矩阵的行和列数 dp[i][j] 表示从左上角到矩阵(i,j)位置是的最短路径和。则可知 到(i,j)位置有两种情况:1)由(i-1,j)向下走,2)由(i,j-1)向右走,所以dp[i][j]=Math.min(dp[i-1][j],dp[i][j-1])+m[i][j];对于dp[0][j] 只能由 dp[0][j-1] 向右走,dp[i][0] 只能由 dp[i-1][0] 向下走。所以 dp[0][j]=dp[0][j-1]+m[0][j], dp[i][0]=dp[i-1][0]+m[i][0].

public static int shortestRoad(int arr[][])
    {
        int dp[][]=new int [arr.length][arr[0].length];
        dp[0][0]=arr[0][0];
        for(int i=1;i<arr.length;i++)
        {
            dp[i][0]=dp[i-1][0]+arr[i][0];
            //第一列只能由上向下
        }
        for(int j=1;j<arr[0].length;j++)
        {
            dp[0][j]=dp[0][j-1]+arr[0][j];
            //第一行只能由左向右
        }
        for(int i=1;i<arr.length;i++)
            for(int j=1;j<arr[0].length;j++)
            {
                dp[i][j]=Math.min(dp[i-1][j], dp[i][j-1])+arr[i][j];
            }

        return dp[arr.length-1][arr[0].length-1];
    }

思路:
解法1中使用dp数组的空间大小为M*N,其实可以对dp数组的空间压缩至N,定义大小为N的dp数组,对于第一行,dp[i]=dp[i-1]+m[0][i],在求第二行中的 dp[i] 时可以覆盖第一行 dp[i] ,第二行dp[i]=min(dp[i],dp[i-1])+m[i][j]。

public static int shortestRoad1(int arr[][])
    {
        int dp[]=new int[arr[0].length];
        dp[0]=arr[0][0];
        for(int j=1;j<arr[0].length;j++)
        {
            dp[j]=dp[j-1]+arr[0][j];
            //求出第一行的dp
        }
        for(int i=1;i<arr.length;i++)
        {
            dp[0]=arr[i][0]+dp[0];
            //dp[0]代表每一行最左边的dp,
            //后一行的dp覆盖前一行的dp
            for(int j=1;j<arr[0].length;j++)
            {
                dp[j]=Math.min(dp[j-1]+arr[i][j], dp[j]+arr[i][j]);
            }
        }               
        return dp[arr[0].length-1];
    }

类似题目

题目描述
有一个XxY的网格,一个机器人只能走格点且只能向右或向下走,要从左上角走到右下角。请设计一个算法,计算机器人有多少种走法。
给定两个正整数int x,int y,请返回机器人的走法数目。保证x+y小于等于12。
测试样例:
2,2
返回:2

/ 题目要求走的是大格子而不是网格线的交点,所以有两种走法。
// 二维数组用于计算走到当前格子的走法总数,为其上方格子走法总数与其左侧格子走法总数之和

class Robot {
public:
    int countWays(int x, int y) {
        // write code ,here
        int dp[13][13]={0};
        dp[0][0]=0;
        for(int i=1;i<y;i++)//第一行初始化,因为只有横着走一种方法。
             dp[0][i]=1;
         for(int i=1;i<x;i++)//第一列初始化,因为只有竖着一种方法。
            dp[i][0]=1;
         for(int i=1;i<x;i++)//dp[i][j]的方法,等于走到上面一格和走到左边一个方法之和。
              for(int j=1;j<y;j++){
                  dp[i][j]=dp[i-1][j]+dp[i][j-1];
              }
         return dp[x-1][y-1];      
    }
};
阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/coolwriter/article/details/79959743
个人分类: 动态规划
上一篇动态规划(五)背包问题
下一篇[leetcode]evaluate-reverse-polish-notation
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭