Leetcode 62&63&64 不同路径 Java

最新推荐文章于 2021-10-29 19:19:50 发布

qxdPx

最新推荐文章于 2021-10-29 19:19:50 发布

阅读量421

点赞数

分类专栏： Leetcode

本文链接：https://blog.csdn.net/qxdPx/article/details/88597512

版权

Leetcode 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

Leetcode 62 不同路径

这道题一看就是动态规划题，但是因为我动态规划掌握的不是很好，所以总想投机取巧，研究是否有不用DP的方法。这道题因为设置的非常简单，没有添加障碍物什么的，所以给了我用排列组合的方法><

排列组合 ：先贴通过的代码段

class Solution {
    public int uniquePaths(int m, int n) {
        int max=Math.max(m-1,n-1);
        int min=Math.min(m-1,n-1);
        Double result=1D;
        for(int i=1;i<=min;i++)
        {
            result=result*(max+i)/i;
        }
        return result.intValue();                
    }
}

这里面有一个点我现在还不太理解。

//正确写法
result = result * ( max + i ) / i;

//我的写法
result * = ( max + i ) / i;

我觉得是一样的，但是运行出来下面那行无法得到正确答案。

但是上面的做法只是因为题目的限制条件太少，适用场景并不多。于是，但是要老老实实看一下动态规划是如何做的。

动态规划：以下是代码段：

class Solution {
    public int uniquePaths(int m, int n) {
        int [][]dp=new int[m][n];
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(i==0||j==0) dp[i][j]=1;
                else dp[i][j]=dp[i-1][j]+dp[i][j-1];
          
            }
        }
        return dp[m-1][n-1];            
    }
}

解释一点，其实是非常简单的道理，但是刚开始我还是有点不理解的…（主要是基础太弱T T

if(i==0||j==0) dp[i][j]=1;

这句把最上面和最左边的格子都填1的原因是因为走到这些格子有且仅有一种方法。

Leetcode 63 不同路径II

这道题在上面的题的基础上设置了障碍物，但是DP思想是一样的。

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        if(obstacleGrid.length==0) return 0;
        int row=obstacleGrid.length;
        int col=obstacleGrid[0].length;
        int [][]dp=new int[row][col];
        
        for(int i=0;i<row;i++) //对第一列初始化
        {
            if(obstacleGrid[i][0]!=1) dp[i][0]=1;
            else break;
        }        
        for(int i=0;i<col;i++) //对第一行初始化
        {
            if(obstacleGrid[0][i]!=1) dp[0][i]=1;
            else break;
        }
        
        for(int i=1;i<row;i++) //一样的动归思路
        {
            for(int j=1;j<col;j++)
            {              
                    if(obstacleGrid[i][j]!=1)
                    {
                        dp[i][j]=dp[i-1][j]+dp[i][j-1];
                    }
            }
        }
        return dp[row-1][col-1];
    }
}

Leetcode 64 最小路径和

class Solution {
    public int minPathSum(int[][] grid) {
        if(grid.length==0) return 0;
        int row=grid.length;
        int col=grid[0].length;
        
        int [][]dp=new int[row+1][col+1];
        for(int i=1;i<row+1;i++)
        {
            for(int j=1;j<col+1;j++)
            {
                if(i==1||j==1)
                {	//初始化第一行和第一列
                    dp[i][j]=dp[i-1][j]+dp[i][j-1]+grid[i-1][j-1]; 
                }
                else
                {
                    dp[i][j]=Math.min(dp[i-1][j],dp[i][j-1])+grid[i-1][j-1];
                }
            }
        }
        return dp[row][col];        
    }
}