LeetCode--62. Unique Paths & 63. Unique Paths II

题目链接：https://leetcode.com/problems/unique-paths/和https://leetcode.com/problems/unique-paths-ii/

从（0,0）到达（m-1,n-1）的路径总数，第二问路上有障碍物。

问题一思路一：DFS暴力搜索

class Solution {
    public static int number;
    public static int mi;
    public static int ni;
    
    public int uniquePaths(int m,int n) {
        
        number=0;
        mi=m;
        ni=n;
        recursive(0,0);
        return number;
    }
    
    public static void recursive(int i,int j)
    {
        if(i>=mi || j>=ni)
            return;
        if(i == mi-1 && j == ni-1)
        {
            number++;
            return;
        }

        recursive(i+1,j);
        recursive(i,j+1);
    }
}

问题二思路一：DFS暴力搜索

class Solution {
    
    public static int number;
    public static int m;
    public static int n;
    
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        
        number=0;
        m=obstacleGrid.length;
        n=obstacleGrid[0].length;
        if(obstacleGrid[0][0]!=1)
            recursive(0,0,obstacleGrid);
        return number;
    }
    
    public static void recursive(int i,int j,int[][] grid)
    {
        if(i>=m || j>=n)
            return;
        if(i == m-1 && j == n-1)
        {
            number++;
            return;
        }
        
        if(i+1

很遗憾，这两题的DFS暴力搜索解法都TLE了，超时的原因就是存在大量的重复计算，时间复杂度为O(2^n)，应该可以用DP来优化，思路类似于Fibonacci数列的DP优化。关键是找到递推式。

先看第一题：不难发现，对于位置（i,j）到位置（m-1,n-1）都是要经过（i+1，j）或者（i，j+1）的，所以位置（i,j）到达位置（m-1,n-1）的路径数=从位置（i+1，j）到达位置（m-1,n-1）的路径数+从位置（i，j+1）到达位置（m-1,n-1）的路径数

对于第m-1行或者n-1列的位置到达（m-1,n-1）都只有1种路线，代码如下：

class Solution {
    public static  int uniquePaths(int m, int n) {
		int[][] ans=new int[m][n];
		for(int i=0;i

在看第二题：要把障碍物考虑到递推式中，障碍物所在的位置到达终点的路径数为0。代码如下：

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        
        int m=obstacleGrid.length,n=obstacleGrid[0].length;
        
        int[][] memo=new int[m][n];
         memo[m-1][n-1]=1;
        if(obstacleGrid[m-1][n-1]==1)
            memo[m-1][n-1]=0;
           
        for(int i=m-2;i>=0;i--)
        {
            if(obstacleGrid[i][n-1]==1)
            {
                memo[i][n-1]=0;
                continue;
            }
            memo[i][n-1]=memo[i+1][n-1];
        }
        
        for(int i=n-2;i>=0;i--)
        {
            if(obstacleGrid[m-1][i]==1)
            {
                memo[m-1][i]=0;
                continue;
            }
            memo[m-1][i]=memo[m-1][i+1];
        }
        
        for(int i=m-2;i>=0;i--)
        {
            for(int j=n-2;j>=0;j--)
            {
                if(obstacleGrid[i][j]==1)
                {
                    memo[i][j]=0;
                    continue;
                }
                memo[i][j]=memo[i+1][j]+memo[i][j+1];
            }
        }
        
        return memo[0][0];
    }
}

一般来说，动态规划优化方法都是在暴力搜索的基础上考虑去重操作写出来的，大可不必直接去想动态规划的解法。