力扣OJ 63. 不同路徑 II （二維DP）

一個機器人位於一個 m x n 網格的左上角 （起始點在下圖中標記爲“Start” ）。

機器人每次只能向下或者向右移動一步。機器人試圖達到網格的右下角（在下圖中標記爲“Finish”）。

現在考慮網格中有障礙物。那麼從左上角到右下角將會有多少條不同的路徑？

網格中的障礙物和空位置分別用 1 和 0 來表示。

說明：m 和 n 的值均不超過 100。

示例 1:

輸入:
[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]
輸出: 2
解釋:
3x3 網格的正中間有一個障礙物。
從左上角到右下角一共有 2 條不同的路徑：
1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

 

我的遞歸寫法：

class Solution {
public:
    vector<vector<int>>ans;
    int dp(vector<vector<int>>& obs,int x,int y)
    {
        if(x<0||x>=obs.size()||y<0||y>=obs[0].size()||obs[x][y])return 0;
        if(ans[x][y])return ans[x][y];
        return ans[x][y]=dp(obs,x,y-1)+dp(obs,x-1,y);
    }
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        ans=obstacleGrid;
        for(int i=0;i<ans.size();i++)for(int j=0;j<ans[0].size();j++)ans[i][j]=0;
        ans[0][0]=1;
        return dp(obstacleGrid,obstacleGrid.size()-1,obstacleGrid[0].size()-1);
    }
};

 

我收集來的非遞歸寫法：

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int row = obstacleGrid.size();
        int col = obstacleGrid[0].size();

        if (row == 0 || col == 0)
            return 0;

        vector<vector<int>> dp(row, vector<int>(col, 0));
        if (obstacleGrid[0][0] == 1)
        {
            dp[0][0] = 0;
        }
        else 
        {
            dp[0][0] =1;
        }

        //計算第一行,當前爲障礙物，或者前面一個就到達不了，直接爲0
        for (int i = 1; i < col;i++)
        {
            if (obstacleGrid[0][i] == 1 || dp[0][i-1] == 0)
            {
                dp[0][i] = 0;
            }
            else 
            {
                dp[0][i] =1;
            }
            
        }

        //計算第一列，當前爲障礙物，或者前面一個就到達不了，直接爲0
        for (int i =1; i<row;i++)
        {
            if (obstacleGrid[i][0] == 1 || dp[i-1][0] == 0)
            {
                dp[i][0] = 0;
            }
            else 
            {
                dp[i][0] = 1;
            }
            
        }

        for (int i =1;i<row;i++)
        {
            for (int j = 1;j<col;j++)
            {
                if (obstacleGrid[i][j] == 1)
                {
                    dp[i][j] = 0;
                }
                else 
                {
                    dp[i][j]=dp[i][j-1] + dp[i-1][j];
                }
                
            }
        }
        return dp[row-1][col-1];

    }
};

 

我的非遞歸寫法：

class Solution {
public:
    vector<vector<int>>ans;
    int uniquePathsWithObstacles(vector<vector<int>>& obs) {
        vector<vector<int>> ans=obs;
        ans[0][0]=(obs[0][0]?0:1);        
        for(int j=1;j<obs[0].size();j++)ans[0][j]=(obs[0][j]?0:ans[0][j-1]);
        for(int i=1;i<obs.size();i++){
            ans[i][0]=(obs[i][0]?0:ans[i-1][0]);
            for(int j=1;j<obs[0].size();j++)ans[i][j]=(obs[i][j]?0:ans[i][j-1]+ans[i-1][j]);
        }
        return ans[ans.size()-1][ans[0].size()-1];
    }
};

 

我的空間壓縮寫法：

class Solution {
public:
    vector<vector<int>>ans;
    int uniquePathsWithObstacles(vector<vector<int>>& obs) {
        vector<int> ans=obs[0];
        ans[0]=(obs[0][0]?0:1);        
        for(int j=1;j<obs[0].size();j++)ans[j]=(obs[0][j]?0:ans[j-1]);
        for(int i=1;i<obs.size();i++){
            ans[0]=(obs[i][0]?0:ans[0]);
            for(int j=1;j<obs[0].size();j++)ans[j]=(obs[i][j]?0:ans[j-1]+ans[j]);
        }
        return ans[ans.size()-1];
    }
};