Leetcode 62&63&64 不同路径 Java

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