LeetCode 1.Minimum Path Sum 2.Unique Paths I and II

大家好，我是刘天昊，快到端午节了，今天说两道动态规划的题目（话说动规真的挺难的）

当然这三题是一样的解体思路先看Unique Paths 

A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).

How many possible unique paths are there?

Above is a 3 x 7 grid. How many possible unique paths are there?

Note: m and n will be at most 100.

（没想到图也可以出来）题目说从左上角到右下角每次走一步（只能往右或者往左）有多少种不同的走法

动态规划我觉得核心就是 子问题+记忆 从小到大的思考问题

我们先思考1*1，没什么好想的就一种走法（0，0）

然后1*2，也是一种走法横着走到「（0，1）；

接着考虑2*1，也是一种竖着走到头（1，0），好讲到这里注意重点来了

当我们考虑2*2的时候当然答案是2

但是我们这样考虑我们先走到（0，1），有一种走法（跟1*2一样）接着从（0，1）到（1，1）只能往下走

再考虑先走到（1，0）有一种走法（跟2*1）一样，从（1，0）到（1，1）只能往右走好我们走2*2有两种方法那么2*2=1*2+2*1；

再来思考2*3=2*2+1*3为什么我们分析下我们可以先走到（0，2）往下，也可以走到（1，1）往右到（1，2）点

我们到（0，2）只能横着走一种，但是我们到（2，2）有两种所以2*3的走法=2*2的走法+1*3的走法，到这里我们总结出来规律

（I，j）的走法=（i-1，j）的走法+（i，j-1）的走法接着写代码就容易了po上代码

int uniquePaths(int m, int n) 
{
    if(m==1||n==1)
    {
        return 1;
    }
    int save[m][n];
    memset(save,0,sizeof(save));
    for(int i=0;i<m;i++)
    {
        save[i][0]=1;
    }
    for(int i=0;i<n;i++)
    {
        save[0][i]=1;
    }
    for(int i=1;i<m;i++)
    {
        for(int j=1;j<n;j++)
        {
            save[i][j]=save[i-1][j]+save[i][j-1];
        }
    }
    return save[m-1][n-1];
}

接着看2

Follow up for "Unique Paths":

Now consider if some obstacles are added to the grids. How many unique paths would there be?

An obstacle and empty space is marked as 1 and 0 respectively in the grid.

For example,

There is one obstacle in the middle of a 3x3 grid as illustrated below.

[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]

The total number of unique paths is 2.

Note: m and n will be at most 100.

说咋门跟上次一样但是多了障碍物，做了上题，这题就简单了，障碍物就走不通呗，考虑有障碍物的地方填0再用上面的代码改进

int uniquePathsWithObstacles(int** obstacleGrid, int obstacleGridRowSize, int obstacleGridColSize) 
{
    int m=obstacleGridRowSize;
    int n=obstacleGridColSize;
    int save[m][n];
    memset(save,0,sizeof(save));
    save[0][0]=1;
    if(obstacleGrid[0][0]==1)
    {
        return 0;
    }
    if(m==1)
    {
        for(int i=1;i<n;i++)
        {
            if(obstacleGrid[0][i]==1)
            {
                return 0;
            }
            else
            {
                save[0][i]=save[0][i-1];
            }
        }
    }
    if(n==1)
    {
        for(int i=1;i<m;i++)
        {
            if(obstacleGrid[i][0]==1)
            {
                return 0;
            }
            else
            {
                save[i][0]=save[i-1][0];
            }
        }
    }
    else
    {
       
        for(int i=1;i<n;i++)
        {
            if(obstacleGrid[0][i]==1)
            {
                save[0][i]=0;
            }
            else
            {
                save[0][i]=save[0][i-1];
            }
        }
        for(int i=1;i<m;i++)
        {
            if(obstacleGrid[i][0]==1)
            {
                save[i][0]=0;
            }
            else
            {
                save[i][0]=save[i-1][0];
            }
        }
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                if(obstacleGrid[i][j]!=1)
                {
                    save[i][j]=save[i-1][j]+save[i][j-1];
                }
                else
                {
                    save[i][j]=0;
                }
            }
        }
    }
    return save[m-1][n-1];
}

注意第一行有一个障碍物第一行全为0，第一列也是

这题解决了再来个差不多的这一讲就带到这里，这些动规是比较简单的笔者自己想的（想了好久，说简单是和别的比较，这个我想出来了，所以简单后面的动规，呵呵）

#define Min(a,b) a<b?a:b
int minPathSum(int** grid, int gridRowSize, int gridColSize)
{
    int val[gridRowSize][gridColSize];
    memset(val,0,sizeof(val));
    val[0][0]=grid[0][0];
    for(int i=1;i<gridColSize;i++)
    {
        val[0][i]=(val[0][i-1]+grid[0][i]);
    }
    for(int i=1;i<gridRowSize;i++)
    {
        val[i][0]=(val[i-1][0]+grid[i][0]);
    }
    for(int i=1;i<gridRowSize;i++)
    {
        for(int j=1;j<gridColSize;j++)
        {
            val[i][j]=(Min(val[i-1][j],val[i][j-1]))+grid[i][j];
        }
    }
    return val[gridRowSize-1][gridColSize-1];
}

这个不解释了，跟前面也类似，开个二维数组就是记忆的过程，前面的分析就是子问题，当然刷leetcode的题目，一般公司也不会考贪心和动规，遇到了就看运气吧，

毕竟动规和贪心都没有固定的形态。

这次就到这里