# Unique Paths II Leetcode Solution

In this post, we are going to solve the Unique Paths II Leetcode SolutionÂ problem of Leetcode. This Leetcode problem is done in many programming languages like C++, Java, and Python.

## Problem

You are given anÂ m x nÂ integer arrayÂ grid. There is a robot initially located at theÂ top-left cornerÂ (i.e.,Â grid[0][0]). The robot tries to move to theÂ bottom-right cornerÂ (i.e.,Â grid[m-1][n-1]). The robot can only move either down or right at any point in time.

An obstacle and space are marked asÂ 1Â orÂ 0Â respectively inÂ grid. A path that the robot takes cannot includeÂ anyÂ square that is an obstacle.

ReturnÂ the number of possible unique paths that the robot can take to reach the bottomâ€“right corner.

The testcases are generated so that the answer will be less than or equal toÂ 2 * 109.

Example 1:

Input: obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
Output: 2
Explanation: There is one obstacle in the middle of the 3x3 grid above.
There are two ways to reach the bottom-right corner:
1. Right -> Right -> Down -> Down
2. Down -> Down -> Right -> Right

Example 2:

Input: obstacleGrid = [[0,1],[0,0]]
Output: 1

Constraints:

• m == obstacleGrid.length
• n == obstacleGrid[i].length
• 1 <= m, n <= 100
• obstacleGrid[i][j]Â isÂ 0Â orÂ 1.

Now, letâ€™s see the leetcode solution ofÂ Unique Paths II Leetcode Solution.

### Unique Paths II Leetcode Solution in Python

class Solution:
def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
m = len(obstacleGrid)
n = len(obstacleGrid[0])
# dp[i][j] := unique paths from (0, 0) to (i - 1, j - 1)
dp = [[0] * (n + 1) for _ in range(m + 1)]
dp[0][1] = 1  # Can also set dp[1][0] = 1

for i in range(1, m + 1):
for j in range(1, n + 1):
if obstacleGrid[i - 1][j - 1] == 0:
dp[i][j] = dp[i - 1][j] + dp[i][j - 1]

return dp[m][n]

### Unique Paths II Leetcode Solutionin CPP

class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
const int m = obstacleGrid.size();
const int n = obstacleGrid[0].size();
// dp[i][j] := unique paths from (0, 0) to (i - 1, j - 1)
vector<vector<long>> dp(m + 1, vector<long>(n + 1, 0));
dp[0][1] = 1;  // Can also set dp[1][0] = 1

for (int i = 1; i <= m; ++i)
for (int j = 1; j <= n; ++j)
if (!obstacleGrid[i - 1][j - 1])
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];

return dp[m][n];
}
};

### Unique Paths II Leetcode Solution in Java

class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
final int m = obstacleGrid.length;
final int n = obstacleGrid[0].length;
// dp[i][j] := unique paths from (0, 0) to (i - 1, j - 1)
long[][] dp = new long[m + 1][n + 1];
dp[0][1] = 1; // Can also set dp[1][0] = 1

for (int i = 1; i <= m; ++i)
for (int j = 1; j <= n; ++j)
if (obstacleGrid[i - 1][j - 1] == 0)
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];

return (int) dp[m][n];
}
}

Note:Â This problemÂ Unique Paths II is generated byÂ LeetcodeÂ but the solution is provided byÂ Chase2learn This tutorial is only forÂ EducationalÂ andÂ LearningÂ purposes.

Sharing Is Caring