Unique Paths

题目描述：如下图所示，机器人位于m×n方格的左上角(起点)，它只能向下或向右行走，问到达右下角(终点)共有多少条路径？

这是一道基本的动态规划的题目，因为机器人只能向下或向右移动，当到达一点是，它只能来自该点的左边和上边。设当前位置为(i,j),Path[i][j]表示从起点到当前点的路径数，所以有： Path[i][j]=Path[i][j-1]+Path[i-1][j]. 根据上述条件，还可以得到第一行和第一列的路径数都为1。算法代码如下：

     int uniquePaths(int m, int n) 
   {
        vector<vector<int> > path(m,vector<int>(n,0));
        for(int i=0;i<m;i++) path[i][0]=1;
        for(int j=0;j<n;j++) path[0][j]=1;
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                path[i][j]=path[i-1][j]+path[i][j-1];
            }
        }
        return path[m-1][n-1];
   }

这里可以利用上一轮的结果(向下的箭头)，加上左边点的路径数表示当前点的路径数，因此可以将二维数组降为一维，即：Path[j]=Path[j]+Path[j-1],同时只需将第一行初始化为1，用于第一轮的计算。算法代码如下：

int uniquePaths(int m, int n) 
{
    vector<int> path(n,0);
    for(int j=0;j<n;j++) path[j]=1;
    for(int i=1;i<m;i++)
    {
        for(int j=1;j<n;j++)
        {
            path[j]=path[j]+path[j-1];
        }
    }
    return path[n-1];
}

扩展问题：如果方格中有障碍物时，情况如何？我们用一个二维数组表示带障碍的方格，有障碍用1表示，无障碍用0表示。

该问题首先要判断是否有障碍，如果有障碍要进行清0，如果没障碍则按上述方法计算。

int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid)
{
        int m=obstacleGrid.size();
        int n=obstacleGrid[0].size();
        vector<vector<int> > path(m,vector<int>(n,0));
        path[0][0]=obstacleGrid[0][0]==1? 0:1;
        for(int i=1;i<m;i++) path[i][0]=obstacleGrid[i][0]==1? 0:path[i-1][0];
        for(int j=1;j<n;j++) path[0][j]=obstacleGrid[0][j]==1? 0:path[0][j-1];
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                path[i][j]=obstacleGrid[i][j]==1? 0:(path[i-1][j]+path[i][j-1]);
            }
        }
        return path[m-1][n-1];
 }

 同上一题，我们可以使用一维数组来记录路径数，同时当某一列都有障碍时则明显没有通路应立即返回，这里我们使用一个标记位进行记录。

int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) 
    {
       int m = obstacleGrid.size();
       int n = obstacleGrid[0].size();
       vector<int> cur(m, 0);
       for (int i = 0; i < m; i++) 
       {
        if (obstacleGrid[i][0] != 1)
            cur[i] = 1;
        else break;
       }
       for (int j = 1; j < n; j++) 
       {
         bool flag = false;
         if (obstacleGrid[0][j] == 1)
            cur[0] = 0;
         else flag = true;
         for (int i = 1; i < m; i++) 
         {
            if (obstacleGrid[i][j] != 1) 
            {
                cur[i] += cur[i - 1];
                if (cur[i]) flag = true;
            }
            else cur[i] = 0;
         }
         if (!flag) return 0;
       }
    return cur[m - 1];
  }

我们还可以使用题目给定用来记录障碍的数组来记录路径数：

int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) 
    {
       int m=obstacleGrid.size();
        int n=obstacleGrid[0].size();
        for(int i= 0;i<m;i++)
        for(int j=0;j<n;j++)
        {
            if(obstacleGrid[i][j] == 1)
                obstacleGrid[i][j] = 0;
            else
            {
                if(i == 0 && j == 0)
                    obstacleGrid[i][j] = 1;
                else if(i == 0)
                    obstacleGrid[i][j] = obstacleGrid[i][j-1];
                else if(j == 0)
                    obstacleGrid[i][j] = obstacleGrid[i-1][j];
                else
                    obstacleGrid[i][j] = obstacleGrid[i][j-1] + obstacleGrid[i-1][j];
            }
        }

    return obstacleGrid[m-1][n-1];
    }