LeetCode-64. 最小路径和——动态规划

最新推荐文章于 2023-07-13 22:00:00 发布

鹿谷門実

最新推荐文章于 2023-07-13 22:00:00 发布

阅读量228

点赞数

分类专栏： LeetCode 动态规划文章标签：动态规划算法 dfs

本文链接：https://blog.csdn.net/weixin_43517302/article/details/104394931

版权

LeetCode 同时被 2 个专栏收录

21 篇文章 0 订阅

订阅专栏

动态规划

12 篇文章 0 订阅

订阅专栏

该博客探讨了LeetCode第64题的解决方案，最初尝试使用DFS解决，但发现当数据量增大时会导致超时。博主推荐使用动态规划的方法，以O(mn)的时间复杂度和O(mn)的空间复杂度优化问题，并提供了动态规划思路的参考链接。

摘要由CSDN通过智能技术生成

在这里插入图片描述
看到这个题时,我立马觉得肯定要用dfs或者bfs来进行搜索(因为这个跟迷宫问题挺像的),遍历所有的路径,并将路径求和取最小值,于是我便用dfs进行遍历，虽然出得了结果,但要是数据过多的话会超时.

public class Question_64 {
    //只能向下或者向右移动一步
    static int[] xx={1,0};
    static int[] yy={0,1};
    static int min = Integer.MAX_VALUE;
    static int m ;
    static int n ;
    public static int minPathSum(int[][] grid) {
        m = grid.length;
        n = grid[0].length;
        dfs(grid,0,0,grid[0][0]);
        return min;
    }

    private static void dfs(int[][] grid, int x, int y,int value) {
        if (x==m-1&&y==n-1&&min>value){
            min=value;
            return ;
        }
        for(int j=0;j<2;j++){
            int x1 = x;
            int y1 = y;
            //判断该方向会不会下标越界
            if (x1+ xx[j]<m&&y1+ yy[j]<n){
                x1 = x1+ xx[j];
                y1 = y1+ yy[j];
                dfs(grid,x1,y1,value+grid[x1][y1]);
            }
        }

    }

}

其实这题最好用动态规划来解决
时间复杂度：O(mn)O(mn)。遍历整个矩阵恰好一次。
空间复杂度：O(mn)O(mn)。额外的一个同大小矩阵。
在这里插入图片描述

class Solution {
    public int minPathSum(int[][] grid) {
        int m = grid.length;//m行
        int n = grid[0].length;//n列
        int[][] dp = new int[m][n];
        for (int i=m-1;i>=0;i--){
            for (int j=n-1;j>=0;j--){
                if (i==m-1&&j!=n-1){
                    //如果在第m行,且除了第n列外,只需加上本身和右边的
                    dp[i][j]=grid[i][j]+dp[i][j+1];
                }else if (j==n-1&&i!=m-1){
                    //如果在第n列上,且除了第m行外,只需加上本身和下面的
                    dp[i][j]=grid[i][j]+dp[i+1][j];
                }else if (j!=n-1&&i!=m-1){
                    //如果不在第m行和第n列上的,需要从下面和左边中取出最小的再加上本身
                    dp[i][j]=grid[i][j]+Math.min(dp[i+1][j],dp[i][j+1]);
                }else {
                    //如果是在第m行第n列,加上本身即可
                    dp[i][j]=grid[i][j];
                }
            }
        }
        return dp[0][0];
    }
}