Unique paths in a Grid with Obstacles

Given a grid of size m * n, let us assume you are starting at (1, 1) and your goal is to reach (m, n). At any instance, if you are on (x, y), you can either go to (x, y + 1) or (x + 1, y).
Now consider if some obstacles are added to the grids. How many unique paths would there be?
An obstacle and space are marked as 1 and 0 respectively in the grid.

Examples:

Input: [[0, 0, 0],
[0, 1, 0],
[0, 0, 0]]

Output: 2

There is only one obstacle in the middle.

Unique Paths in a Grid with Obstacles using Recursion:

We have discussed the problem of counting the number of unique paths in a Grid when no obstacle was present in the grid. But here the situation is quite different. While moving through the grid, we can get some obstacles that we can not jump and the way to reach the bottom right corner is blocked.

C++

 `// C++ code to find number of unique paths ``// in a Matrix``#include``using` `namespace` `std;` `int`  `UniquePathHelper(``int` `i, ``int` `j, ``int` `r, ``int` `c, vector>& A){``    ``// boundary condition or constraints``    ``if``(i == r || j == c){``      ``return` `0 ;``    ``}` `    ``if``(A[i][j] == 1){``      ``return` `0 ;``    ``}``    ` `    ``// base case``    ``if``(i == r-1 && j == c-1){``      ``return` `1 ;``    ``}` `    ``return`  `UniquePathHelper(i+1, j, r, c, A) + ``            ``UniquePathHelper(i, j+1, r, c, A) ;``}`  `int` `uniquePathsWithObstacles(vector>& A) ``{``    ` `    ``int` `r = A.size(), c = A[0].size(); ` `    ` `    ``return` `UniquePathHelper(0, 0, r, c, A) ;``}` `// Driver code``int` `main()``{``   ``vector> A = { { 0, 0, 0 },``                             ``{ 0, 1, 0 },``                             ``{ 0, 0, 0 } };``                             ` `   ``cout << uniquePathsWithObstacles(A) << ``" \n"``;                                                ``}`

Java

 `// Java code to find number of unique paths ``// in a Matrix``import` `java.io.*;` `class` `GFG {` `  ``static` `int` `UniquePathHelper(``int` `i, ``int` `j, ``int` `r, ``int` `c,``                              ``int``[][] A)``  ``{``    ``// boundary condition or constraints``    ``if` `(i == r || j == c) {``      ``return` `0``;``    ``}` `    ``if` `(A[i][j] == ``1``) {``      ``return` `0``;``    ``}` `    ``// base case``    ``if` `(i == r - ``1` `&& j == c - ``1``) {``      ``return` `1``;``    ``}` `    ``return` `UniquePathHelper(i + ``1``, j, r, c, A)``      ``+ UniquePathHelper(i, j + ``1``, r, c, A);``  ``}` `  ``static` `int` `uniquePathsWithObstacles(``int``[][] A)``  ``{` `    ``int` `r = A.length, c = A[``0``].length;` `    ``return` `UniquePathHelper(``0``, ``0``, r, c, A);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int``[][] A``      ``= { { ``0``, ``0``, ``0` `}, { ``0``, ``1``, ``0` `}, { ``0``, ``0``, ``0` `} };` `    ``System.out.print(uniquePathsWithObstacles(A));``  ``}``}` `// This code is contributed by nipun_aggarwal`

Python3

 `# Python code to find number of unique paths ``# in a Matrix``def`  `UniquePathHelper(i, j, r, c, A):``  ` `    ``# boundary condition or constraints``    ``if``(i ``=``=` `r ``or` `j ``=``=` `c):``      ``return` `0``    ` `    ``if``(A[i][j] ``=``=` `1``):``      ``return` `0``    ` `    ``# base case``    ``if``(i ``=``=` `r``-``1` `and` `j ``=``=` `c``-``1``):``      ``return` `1` `    ``return`  `UniquePathHelper(i``+``1``, j, r, c, A) ``+` `UniquePathHelper(i, j``+``1``, r, c, A) ` `def` `uniquePathsWithObstacles(A): ``    ``r,c ``=` `len``(A),``len``(A[``0``])``    ` `    ``return` `UniquePathHelper(``0``, ``0``, r, c, A)` `# Driver code``A ``=` `[ [ ``0``, ``0``, ``0` `],``      ``[ ``0``, ``1``, ``0` `],``      ``[ ``0``, ``0``, ``0` `] ]``                             ` `print``(uniquePathsWithObstacles(A))                                           ` `# This code is contributed by shinjanpatra`

C#

 `// C# code to find number of unique paths``// in a Matrix``using` `System;``class` `Program ``{` `  ``// Driver code``  ``static` `void` `Main(``string``[] args)``  ``{``    ``int``[, ] A = ``new` `int``[3, 3] { { 0, 0, 0 },``                               ``{ 0, 1, 0 },``                               ``{ 0, 0, 0 } };``    ``Console.WriteLine(uniquePathsWithObstacles(A));``  ``}` `  ``static` `int` `uniquePathsWithObstacles(``int``[, ] A)``  ``{``    ``int` `r = A.GetLength(0);``    ``int` `c = A.GetLength(1);``    ``return` `UniquePathHelper(0, 0, r, c, A);``  ``}` `  ``static` `int` `UniquePathHelper(``int` `i, ``int` `j, ``int` `r, ``int` `c,``                              ``int``[, ] A)``  ``{``    ``// boundary condition or constraints``    ``if` `(i == r || j == c) {``      ``return` `0;``    ``}` `    ``if` `(A[i, j] == 1) {``      ``return` `0;``    ``}` `    ``// base case``    ``if` `(i == r - 1 && j == c - 1) {``      ``return` `1;``    ``}` `    ``return` `UniquePathHelper(i + 1, j, r, c, A)``      ``+ UniquePathHelper(i, j + 1, r, c, A);``  ``}``}` `// This code is contributed by Tapesh(tapeshdua420)`

Javascript

 ``

Output
```2

```

Time Complexity: O(2m*n)
Auxiliary Space: O(m+n) , because worst path will be when we iterate along corner cells, Recursion will not have all the paths so Space can’t be O(n*m) it should be O(n+m)

Unique paths in a Grid with Obstacles using Dynamic Programming:

1) Top-Down

The most efficient solution to this problem can be achieved using dynamic programming. Like every dynamic problem concept, we will not recompute the subproblems. A temporary 2D matrix will be constructed and value will be stored using the top-down approach.

C++

 `// C++ code to find number of unique paths``// in a Matrix``#include ``using` `namespace` `std;` `int` `UniquePathHelper(``int` `i, ``int` `j, ``int` `r, ``int` `c,``                     ``vector >& A,``                     ``vector >& paths)``{``    ``// boundary condition or constraints``    ``if` `(i == r || j == c) {``        ``return` `0;``    ``}` `    ``if` `(A[i][j] == 1) {``        ``return` `0;``    ``}` `    ``// base case``    ``if` `(i == r - 1 && j == c - 1) {``        ``return` `1;``    ``}` `    ``if` `(paths[i][j] != -1) {``        ``return` `paths[i][j];``    ``}` `    ``return` `paths[i][j]``           ``= UniquePathHelper(i + 1, j, r, c, A, paths)``             ``+ UniquePathHelper(i, j + 1, r, c, A, paths);``}` `int` `uniquePathsWithObstacles(vector >& A)``{` `    ``int` `r = A.size(), c = A[0].size();` `    ``// create a 2D-matrix and initializing``    ``// with value 0` `    ``vector > paths(r, vector<``int``>(c, -1));` `    ``return` `UniquePathHelper(0, 0, r, c, A, paths);``}` `// Driver code``int` `main()``{``    ``vector > A``        ``= { { 0, 0, 0 }, { 0, 1, 0 }, { 0, 0, 0 } };` `    ``cout << uniquePathsWithObstacles(A) << ``" \n"``;``}`

Java

 `// Java code to find number of unique paths``// in a Matrix``import` `java.util.*;` `public` `class` `Main {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[][] A``            ``= { { ``0``, ``0``, ``0` `}, { ``0``, ``1``, ``0` `}, { ``0``, ``0``, ``0` `} };``        ``System.out.println(uniquePathsWithObstacles(A));``    ``}` `    ``public` `static` `int` `uniquePathsWithObstacles(``int``[][] A)``    ``{``        ``int` `r = A.length;``        ``int` `c = A[``0``].length;``        ``// create a 2D-matrix and initializing``        ``// with value 0``        ``int``[][] paths = ``new` `int``[r];` `        ``for` `(``int` `i = ``0``; i < r; i++) {``            ``Arrays.fill(paths[i], -``1``);``        ``}` `        ``return` `UniquePathHelper(``0``, ``0``, r, c, A, paths);``    ``}` `    ``public` `static` `int` `UniquePathHelper(``int` `i, ``int` `j, ``int` `r,``                                       ``int` `c, ``int``[][] A,``                                       ``int``[][] paths)``    ``{``        ``// boundary condition or constraints``        ``if` `(i == r || j == c) {``            ``return` `0``;``        ``}``        ``else` `if` `(A[i][j] == ``1``) {``            ``return` `0``;``        ``}``        ``// base case``        ``else` `if` `(i == r - ``1` `&& j == c - ``1``) {``            ``return` `1``;``        ``}``        ``else` `if` `(paths[i][j] != -``1``) {` `            ``return` `paths[i][j];``        ``}``        ``else` `{``            ``return` `paths[i][j]``                ``= UniquePathHelper(i + ``1``, j, r, c, A, paths)``                  ``+ UniquePathHelper(i, j + ``1``, r, c, A,``                                     ``paths);``        ``}``    ``}``}` `// This code is contributed by Tapesh(tapeshdua420)`

Python3

 `# Python code to find number of unique paths``# in a Matrix`  `def` `UniquePathHelper(i, j, r, c, A, paths):``    ``# boundary condition or constraints``    ``if` `(i ``=``=` `r ``or` `j ``=``=` `c):``        ``return` `0` `    ``if` `(A[i][j] ``=``=` `1``):``        ``return` `0` `    ``# base case``    ``if` `(i ``=``=` `r ``-` `1` `and` `j ``=``=` `c ``-` `1``):``        ``return` `1` `    ``if` `(paths[i][j] !``=` `-``1``):``        ``return` `paths[i][j]` `    ``paths[i][j] ``=` `UniquePathHelper(``        ``i ``+` `1``, j, r, c, A, paths) ``+` `UniquePathHelper(i, j ``+` `1``, r, c, A, paths)``    ``return` `paths[i][j]`  `def` `uniquePathsWithObstacles(A):` `    ``r, c ``=` `len``(A), ``len``(A[``0``])` `    ``# create a 2D-matrix and initializing``    ``# with value 0` `    ``paths ``=` `[[``-``1` `for` `i ``in` `range``(c)]``for` `j ``in` `range``(r)]` `    ``return` `UniquePathHelper(``0``, ``0``, r, c, A, paths)` `# Driver code`  `A ``=` `[[``0``, ``0``, ``0``], [``0``, ``1``, ``0``], [``0``, ``0``, ``0``]]` `print``(uniquePathsWithObstacles(A))` `# code is contributed by shinjanpatra`

C#

 `// C# code to find number of unique paths``// in a Matrix``using` `System;` `class` `Program {` `    ``// Driver code``    ``static` `void` `Main(``string``[] args)``    ``{``        ``int``[, ] A = ``new` `int``[3, 3] { { 0, 0, 0 },``                                    ``{ 0, 1, 0 },``                                    ``{ 0, 0, 0 } };``        ``Console.WriteLine(uniquePathsWithObstacles(A));``    ``}` `    ``static` `int` `uniquePathsWithObstacles(``int``[, ] A)``    ``{``        ``int` `r = A.GetLength(0);``        ``int` `c = A.GetLength(1);` `        ``// create a 2D-matrix and initializing``        ``// with value -1``        ``int``[, ] paths = ``new` `int``[r, c];``        ``for` `(``int` `i = 0; i < r; i++) {``            ``for` `(``int` `j = 0; j < c; j++) {``                ``paths[i, j] = -1;``            ``}``        ``}` `        ``return` `UniquePathHelper(0, 0, r, c, A, paths);``    ``}` `    ``static` `int` `UniquePathHelper(``int` `i, ``int` `j, ``int` `r, ``int` `c,``                                ``int``[, ] A, ``int``[, ] paths)``    ``{``        ``// boundary condition or constraints``        ``if` `(i == r || j == c) {``            ``return` `0;``        ``}` `        ``if` `(A[i, j] == 1) {``            ``return` `0;``        ``}` `        ``// base case``        ``if` `(i == r - 1 && j == c - 1) {``            ``return` `1;``        ``}` `        ``if` `(paths[i, j] != -1) {``            ``return` `paths[i, j];``        ``}` `        ``return` `paths[i, j]``            ``= UniquePathHelper(i + 1, j, r, c, A, paths)``              ``+ UniquePathHelper(i, j + 1, r, c, A, paths);``    ``}``}` `// This code is contributed by Tapesh(tapeshdua420)`

Javascript

 ``

Output
```2

```

Time Complexity: O(m*n)
Auxiliary Space: O(m*n)

2) Bottom-Up

A temporary 2D matrix will be constructed and value will be stored using the bottom-up approach.

Approach:

• Create a 2D matrix of the same size as the given matrix to store the results.
• Traverse through the created array row-wise and start filling the values in it.
• If an obstacle is found, set the value to 0.
• For the first row and column, set the value to 1 if an obstacle is not found.
• Set the sum of the right and the upper values if an obstacle is not present at that corresponding position in the given matrix
• Return the last value of the created 2d matrix

Below is the implementation of the above approach:

C++

 `// C++ code to find number of unique paths ``// in a Matrix``#include``using` `namespace` `std;` `int` `uniquePathsWithObstacles(vector>& A) ``{``    ` `    ``int` `r = A.size(), c = A[0].size(); ``    ` `    ``// create a 2D-matrix and initializing``    ``// with value 0``    ``vector> paths(r, vector<``int``>(c, 0));``    ` `    ``// Initializing the left corner if``    ``// no obstacle there``    ``if` `(A[0][0] == 0)``        ``paths[0][0] = 1;``        ` `    ``// Initializing first column of``    ``// the 2D matrix``    ``for``(``int` `i = 1; i < r; i++)``    ``{``        ``// If not obstacle``        ``if` `(A[i][0] == 0)``            ``paths[i][0] = paths[i-1][0];``    ``} ``    ` `    ``// Initializing first row of the 2D matrix``    ``for``(``int` `j = 1; j < c; j++)``    ``{``        ` `        ``// If not obstacle``        ``if` `(A[0][j] == 0)``            ``paths[0][j] = paths[0][j - 1];``    ``}   ``     ` `    ``for``(``int` `i = 1; i < r; i++)``    ``{``        ``for``(``int` `j = 1; j < c; j++)``        ``{``            ` `            ``// If current cell is not obstacle ``            ``if` `(A[i][j] == 0)``                ``paths[i][j] = paths[i - 1][j] +``                              ``paths[i][j - 1]; ``        ``}  ``    ``}``    ` `    ``// Returning the corner value ``    ``// of the matrix``    ``return` `paths[r - 1];``//it is not visible in the article, instread only paths[r - 1] is visible so please change it``}` `// Driver code``int` `main()``{``   ``vector> A = { { 0, 0, 0 },``                             ``{ 0, 1, 0 },``                             ``{ 0, 0, 0 } };``                             ` `   ``cout << uniquePathsWithObstacles(A) << ``" \n"``;                                                ``}` `// This code is contributed by ajaykr00kj`

Java

 `// Java code to find number of unique paths ``// in a Matrix``public` `class` `Main``{``  ``static` `int` `uniquePathsWithObstacles(``int``[][] A) ``  ``{` `    ``int` `r = ``3``, c = ``3``; ` `    ``// create a 2D-matrix and initializing``    ``// with value 0``    ``int``[][] paths = ``new` `int``[r];``    ``for``(``int` `i = ``0``; i < r; i++)``    ``{``      ``for``(``int` `j = ``0``; j < c; j++)``      ``{``        ``paths[i][j] = ``0``;``      ``}``    ``}` `    ``// Initializing the left corner if``    ``// no obstacle there``    ``if` `(A[``0``][``0``] == ``0``)``      ``paths[``0``][``0``] = ``1``;` `    ``// Initializing first column of``    ``// the 2D matrix``    ``for``(``int` `i = ``1``; i < r; i++)``    ``{``      ``// If not obstacle``      ``if` `(A[i][``0``] == ``0``)``        ``paths[i][``0``] = paths[i - ``1``][``0``];``    ``} ` `    ``// Initializing first row of the 2D matrix``    ``for``(``int` `j = ``1``; j < c; j++)``    ``{` `      ``// If not obstacle``      ``if` `(A[``0``][j] == ``0``)``        ``paths[``0``][j] = paths[``0``][j - ``1``];``    ``}   ` `    ``for``(``int` `i = ``1``; i < r; i++)``    ``{``      ``for``(``int` `j = ``1``; j < c; j++)``      ``{` `        ``// If current cell is not obstacle ``        ``if` `(A[i][j] == ``0``)``          ``paths[i][j] = paths[i - ``1``][j] +``          ``paths[i][j - ``1``]; ``      ``}  ``    ``}` `    ``// Returning the corner value ``    ``// of the matrix``    ``return` `paths[r - ``1``];``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args) {``    ``int``[][] A = { { ``0``, ``0``, ``0` `},``                 ``{ ``0``, ``1``, ``0` `},``                 ``{ ``0``, ``0``, ``0` `} };` `    ``System.out.print(uniquePathsWithObstacles(A));``  ``}``}` `// This code is contributed by divyeshrabadiya07.`

Python

 `# Python code to find number of unique paths in a ``# matrix with obstacles.` `def` `uniquePathsWithObstacles(A):` `    ``# create a 2D-matrix and initializing with value 0``    ``paths ``=` `[[``0``]``*``len``(A[``0``]) ``for` `i ``in` `A]``    ` `    ``# initializing the left corner if no obstacle there``    ``if` `A[``0``][``0``] ``=``=` `0``:``        ``paths[``0``][``0``] ``=` `1``    ` `    ``# initializing first column of the 2D matrix``    ``for` `i ``in` `range``(``1``, ``len``(A)):``        ` `        ``# If not obstacle``        ``if` `A[i][``0``] ``=``=` `0``:``            ``paths[i][``0``] ``=` `paths[i``-``1``][``0``]``            ` `    ``# initializing first row of the 2D matrix``    ``for` `j ``in` `range``(``1``, ``len``(A[``0``])):``        ` `        ``# If not obstacle``        ``if` `A[``0``][j] ``=``=` `0``:``            ``paths[``0``][j] ``=` `paths[``0``][j``-``1``]``            ` `    ``for` `i ``in` `range``(``1``, ``len``(A)):``        ``for` `j ``in` `range``(``1``, ``len``(A[``0``])):` `            ``# If current cell is not obstacle``            ``if` `A[i][j] ``=``=` `0``:``                ``paths[i][j] ``=` `paths[i``-``1``][j] ``+` `paths[i][j``-``1``]` `    ``# returning the corner value of the matrix``    ``return` `paths[``-``1``][``-``1``]`  `# Driver Code``A ``=` `[[``0``, ``0``, ``0``], [``0``, ``1``, ``0``], [``0``, ``0``, ``0``]]``print``(uniquePathsWithObstacles(A))`

C#

 `// C# code to find number of unique paths ``// in a Matrix``using` `System;``class` `GFG {` `  ``static` `int` `uniquePathsWithObstacles(``int``[,] A) ``  ``{` `    ``int` `r = 3, c = 3; ` `    ``// create a 2D-matrix and initializing``    ``// with value 0``    ``int``[,] paths = ``new` `int``[r,c];``    ``for``(``int` `i = 0; i < r; i++)``    ``{``      ``for``(``int` `j = 0; j < c; j++)``      ``{``        ``paths[i, j] = 0;``      ``}``    ``}` `    ``// Initializing the left corner if``    ``// no obstacle there``    ``if` `(A[0, 0] == 0)``      ``paths[0, 0] = 1;` `    ``// Initializing first column of``    ``// the 2D matrix``    ``for``(``int` `i = 1; i < r; i++)``    ``{``      ``// If not obstacle``      ``if` `(A[i, 0] == 0)``        ``paths[i, 0] = paths[i - 1, 0];``    ``} ` `    ``// Initializing first row of the 2D matrix``    ``for``(``int` `j = 1; j < c; j++)``    ``{` `      ``// If not obstacle``      ``if` `(A[0, j] == 0)``        ``paths[0, j] = paths[0, j - 1];``    ``}   ` `    ``for``(``int` `i = 1; i < r; i++)``    ``{``      ``for``(``int` `j = 1; j < c; j++)``      ``{` `        ``// If current cell is not obstacle ``        ``if` `(A[i, j] == 0)``          ``paths[i, j] = paths[i - 1, j] +``          ``paths[i, j - 1]; ``      ``}  ``    ``}` `    ``// Returning the corner value ``    ``// of the matrix``    ``return` `paths[r - 1, c - 1];``  ``}` `  ``// Driver code``  ``static` `void` `Main() {``    ``int``[,] A = { { 0, 0, 0 },``                ``{ 0, 1, 0 },``                ``{ 0, 0, 0 } };` `    ``Console.WriteLine(uniquePathsWithObstacles(A));``  ``}``}` `// This code is contributed by divyesh072019.`

Javascript

 ``

Output
```2

```

Time Complexity: O(m*n)
Auxiliary Space: O(m*n)

Unique paths in a Grid with Obstacles using Space Optimization of Dynamic Programming solution:

In this method, we will use the given ‘A’ 2D matrix to store the previous answer using the bottom-up approach.

Approach

• Start traversing through the given ‘A’ 2D matrix row-wise and fill the values in it.
• For the first row and the first column set the value to 1 if an obstacle is not found.
• For the first row and first column, if an obstacle is found then start filling 0 till the last index in that particular row or column.
• Now start traversing from the second row and column ( eg: A[ 1 ][ 1 ]).
• If an obstacle is found, set 0 at particular Grid ( eg: A[ i ][ j ] ), otherwise set sum of upper and left values at A[ i ][ j ].
• Return the last value of the 2D matrix.

Below is the implementation of the above approach.

C++

 `// CPP program for the above approach` `#include ``using` `namespace` `std;` `int` `uniquePathsWithObstacles(vector >& A)``{` `    ``int` `r = A.size();``    ``int` `c = A[0].size();` `    ``// If obstacle is at starting position``    ``if` `(A[0][0])``        ``return` `0;` `    ``//  Initializing starting position``    ``A[0][0] = 1;` `    ``// first row all are '1' until obstacle``    ``for` `(``int` `j = 1; j < c; j++) {` `        ``if` `(A[0][j] == 0) {``            ``A[0][j] = A[0][j - 1];``        ``}``        ``else` `{``            ``// No ways to reach at this index``            ``A[0][j] = 0;``        ``}``    ``}` `    ``// first column all are '1' until obstacle``    ``for` `(``int` `i = 1; i < r; i++) {` `        ``if` `(A[i][0] == 0) {``            ``A[i][0] = A[i - 1][0];``        ``}``        ``else` `{``            ``// No ways to reach at this index``            ``A[i][0] = 0;``        ``}``    ``}` `    ``for` `(``int` `i = 1; i < r; i++) {` `        ``for` `(``int` `j = 1; j < c; j++) {``            ``// If current cell has no obstacle``            ``if` `(A[i][j] == 0) {` `                ``A[i][j] = A[i - 1][j] + A[i][j - 1];``            ``}``            ``else` `{``                ``// No ways to reach at this index``                ``A[i][j] = 0;``            ``}``        ``}``    ``}` `    ``// returning the bottom right``    ``// corner of Grid``    ``return` `A[r - 1];``}` `// Driver Code` `int` `main()``{` `    ``vector > A``        ``= { { 0, 0, 0 }, { 0, 1, 0 }, { 0, 0, 0 } };` `    ``cout << uniquePathsWithObstacles(A) << ``"\n"``;` `    ``return` `0;``}``// This code is contributed by hemantraj712`

Java

 `// Java program for the above approach``import` `java.io.*;``class` `GFG {` `    ``static` `int` `uniquePathsWithObstacles(``int``[][] A)``    ``{` `        ``int` `r = A.length;``        ``int` `c = A[``0``].length;` `        ``// If obstacle is at starting position``        ``if` `(A[``0``][``0``] != ``0``)``            ``return` `0``;` `        ``//  Initializing starting position``        ``A[``0``][``0``] = ``1``;` `        ``// first row all are '1' until obstacle``        ``for` `(``int` `j = ``1``; j < c; j++) {` `            ``if` `(A[``0``][j] == ``0``) {``                ``A[``0``][j] = A[``0``][j - ``1``];``            ``}``            ``else` `{``                ``// No ways to reach at this index``                ``A[``0``][j] = ``0``;``            ``}``        ``}` `        ``// first column all are '1' until obstacle``        ``for` `(``int` `i = ``1``; i < r; i++) {` `            ``if` `(A[i][``0``] == ``0``) {``                ``A[i][``0``] = A[i - ``1``][``0``];``            ``}``            ``else` `{``                ``// No ways to reach at this index``                ``A[i][``0``] = ``0``;``            ``}``        ``}` `        ``for` `(``int` `i = ``1``; i < r; i++) {` `            ``for` `(``int` `j = ``1``; j < c; j++) {` `                ``// If current cell has no obstacle``                ``if` `(A[i][j] == ``0``) {` `                    ``A[i][j] = A[i - ``1``][j] + A[i][j - ``1``];``                ``}``                ``else` `{``                    ``// No ways to reach at this index``                    ``A[i][j] = ``0``;``                ``}``            ``}``        ``}` `        ``// returning the bottom right``        ``// corner of Grid``        ``return` `A[r - ``1``];``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[][] A``            ``= { { ``0``, ``0``, ``0` `}, { ``0``, ``1``, ``0` `}, { ``0``, ``0``, ``0` `} };` `        ``System.out.print(uniquePathsWithObstacles(A));``    ``}``}` `// This code is contributed by rajsanghavi9.`

Python3

 `# Python program for the above approach`  `def` `uniquePathsWithObstacles(A):` `    ``r ``=` `len``(A)``    ``c ``=` `len``(A[``0``])` `    ``# If obstacle is at starting position``    ``if` `(A[``0``][``0``]):``        ``return` `0` `    ``#  Initializing starting position``    ``A[``0``][``0``] ``=` `1` `    ``# first row all are '1' until obstacle``    ``for` `j ``in` `range``(``1``,c):` `        ``if` `(A[``0``][j] ``=``=` `0``):``            ``A[``0``][j] ``=` `A[``0``][j ``-` `1``]``        ``else``:``            ``# No ways to reach at this index``            ``A[``0``][j] ``=` `0` `    ``# first column all are '1' until obstacle``    ``for` `i ``in` `range``(``1``,r):` `        ``if` `(A[i][``0``] ``=``=` `0``):``            ``A[i][``0``] ``=` `A[i ``-` `1``][``0``]``        ``else``:``            ``# No ways to reach at this index``            ``A[i][``0``] ``=` `0` `    ``for` `i ``in` `range``(``1``,r):` `        ``for` `j ``in` `range``(``1``,c):``            ``# If current cell has no obstacle``            ``if` `(A[i][j] ``=``=` `0``):` `                ``A[i][j] ``=` `A[i ``-` `1``][j] ``+` `A[i][j ``-` `1``]``            ``else``:``                ``# No ways to reach at this index``                ``A[i][j] ``=` `0` `    ``# returning the bottom right``    ``# corner of Grid``    ``return` `A[r ``-` `1``]` `# Driver Code` `A ``=` `[ [ ``0``, ``0``, ``0` `], [ ``0``, ``1``, ``0` `], [ ``0``, ``0``, ``0` `] ]` `print``(uniquePathsWithObstacles(A))` `# This code is contributed by shinjanpatra`

C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `Program {``  ``static` `int` `uniquePathsWithObstacles(``int``[, ] A)``  ``{``    ``int` `r = A.GetLength(0);``    ``int` `c = A.GetLength(1);` `    ``// If obstacle is at starting position``    ``if` `(A[0, 0] != 0)``      ``return` `0;` `    ``//  Initializing starting position``    ``A[0, 0] = 1;``    ``for` `(``int` `j = 1; j < c; j++) {``      ``if` `(A[0, j] == 0) {``        ``A[0, j] = A[0, j - 1];``      ``}``      ``else` `{``        ``A[0, j] = 0;``      ``}``    ``}` `    ``// first row all are '1' until obstacle``    ``for` `(``int` `i = 1; i < r; i++) {``      ``if` `(A[i, 0] == 0) {``        ``A[i, 0] = A[i - 1, 0];``      ``}``      ``else` `{``        ``// No ways to reach at this index``        ``A[i, 0] = 0;``      ``}``    ``}` `    ``for` `(``int` `i = 1; i < r; i++) {``      ``for` `(``int` `j = 1; j < c; j++) {``        ``// If current cell has no obstacle``        ``if` `(A[i, j] == 0) {``          ``A[i, j] = A[i - 1, j] + A[i, j - 1];``        ``}``        ``else` `{``          ``// No ways to reach at this index``          ``A[i, j] = 0;``        ``}``      ``}``    ``}``    ``// returning the bottom right``    ``// corner of Grid``    ``return` `A[r - 1, c - 1];``  ``}``  ` `  ``// Driver code``  ``public` `static` `void` `Main(String[] args)``  ``{` `    ``int``[, ] A = ``new` `int``[3, 3] { { 0, 0, 0 },``                               ``{ 0, 1, 0 },``                               ``{ 0, 0, 0 } };` `    ``Console.WriteLine(uniquePathsWithObstacles(A));``  ``}``}` `// This code is contributed by Tapesh (tapeshdua420)`

Javascript

 ``

Output
```2

```

Time Complexity: O(m*n)
Auxiliary Space: O(1)

Unique paths in a Grid with Obstacles using 2D Dynamic Programming:

As Per Problem tell us that we can move in two ways  can either go to (x, y + 1) or (x + 1, y). So we just calculate all possible outcome in both ways and store in 2d dp vector and return the dp[0][0] i.e all possible ways that takes you from (0,0) to (n-1,m-1);

C++

 `#include ``#define int long long``using` `namespace` `std;``int` `n, m;``int` `path(vector >& dp,``         ``vector >& grid, ``int` `i, ``int` `j)``{``    ``if` `(i < n && j < m && grid[i][j] == 1)``        ``return` `0;``    ``if` `(i == n - 1 && j == m - 1)``        ``return` `1;``    ``if` `(i >= n || j >= m)``        ``return` `0;``    ``if` `(dp[i][j] != -1)``        ``return` `dp[i][j];``    ``int` `left = path(dp, grid, i + 1, j);``    ``int` `right = path(dp, grid, i, j + 1);``    ``return` `dp[i][j] = left + right;``}``int` `uniquePathsWithObstacles(vector >& grid)``{``    ``n = grid.size();``    ``m = grid[0].size();``    ``if` `(n == 1 && m == 1 && grid[0][0] == 0)``        ``return` `1;``    ``if` `(n == 1 && m == 1 && grid[0][0] == 1)``        ``return` `0;``    ``vector > dp(n, vector<``int``>(m, -1));``    ``// for(auto it:dp){``    ``//     for(auto vt:it)cout< > v{ { 0, 0, 0 },``                            ``{ 0, 1, 0 },``                            ``{ 0, 0, 0 } };``    ``cout << uniquePathsWithObstacles(v) << ``" \n"``;``    ``return` `0;``}`

Java

 `// Java code for the above approach``import` `java.util.*;` `class` `Main {``    ``static` `int` `n, m;` `    ``static` `int` `path(``int``[][] dp, ``int``[][] grid, ``int` `i, ``int` `j)``    ``{``        ``if` `(i < n && j < m && grid[i][j] == ``1``)``            ``return` `0``;``        ``if` `(i == n - ``1` `&& j == m - ``1``)``            ``return` `1``;``        ``if` `(i >= n || j >= m)``            ``return` `0``;``        ``if` `(dp[i][j] != -``1``)``            ``return` `dp[i][j];``        ``int` `left = path(dp, grid, i + ``1``, j);``        ``int` `right = path(dp, grid, i, j + ``1``);``        ``return` `dp[i][j] = left + right;``    ``}` `    ``static` `int` `uniquePathsWithObstacles(``int``[][] grid)``    ``{``        ``n = grid.length;``        ``m = grid[``0``].length;``        ``if` `(n == ``1` `&& m == ``1` `&& grid[``0``][``0``] == ``0``)``            ``return` `1``;``        ``if` `(n == ``1` `&& m == ``1` `&& grid[``0``][``0``] == ``1``)``            ``return` `0``;``        ``int``[][] dp = ``new` `int``[n][m];``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``for` `(``int` `j = ``0``; j < m; j++) {``                ``dp[i][j] = -``1``;``            ``}``        ``}``        ``path(dp, grid, ``0``, ``0``);``        ``if` `(dp[``0``][``0``] == -``1``)``            ``return` `0``;``        ``return` `dp[``0``][``0``];``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[][] v``            ``= { { ``0``, ``0``, ``0` `}, { ``0``, ``1``, ``0` `}, { ``0``, ``0``, ``0` `} };``        ``System.out.println(uniquePathsWithObstacles(v));``    ``}``}` `// This code is contributed by pradeepkumarppk2003`

Python3

 `# Python code for the above approach``def` `uniquePathsWithObstacles(grid):``    ``n ``=` `len``(grid)``    ``m ``=` `len``(grid[``0``])``    ``if` `n ``=``=` `1` `and` `m ``=``=` `1` `and` `grid[``0``][``0``] ``=``=` `0``:``        ``return` `1``    ``if` `n ``=``=` `1` `and` `m ``=``=` `1` `and` `grid[``0``][``0``] ``=``=` `1``:``        ``return` `0``    ``dp ``=` `[[``-``1` `for` `j ``in` `range``(m)] ``for` `i ``in` `range``(n)]` `    ``def` `path(dp, grid, i, j):``        ``if` `i < n ``and` `j < m ``and` `grid[i][j] ``=``=` `1``:``            ``return` `0``        ``if` `i ``=``=` `n ``-` `1` `and` `j ``=``=` `m ``-` `1``:``            ``return` `1``        ``if` `i >``=` `n ``or` `j >``=` `m:``            ``return` `0``        ``if` `dp[i][j] !``=` `-``1``:``            ``return` `dp[i][j]``        ``left ``=` `path(dp, grid, i ``+` `1``, j)``        ``right ``=` `path(dp, grid, i, j ``+` `1``)``        ``dp[i][j] ``=` `left ``+` `right``        ``return` `dp[i][j]``    ``path(dp, grid, ``0``, ``0``)``    ``if` `dp[``0``][``0``] ``=``=` `-``1``:``        ``return` `0``    ``return` `dp[``0``][``0``]`  `# Driver Code``grid ``=` `[[``0``, ``0``, ``0``], [``0``, ``1``, ``0``], [``0``, ``0``, ``0``]]``print``(uniquePathsWithObstacles(grid))` `# This code is contributed by lokeshpotta20.`

C#

 `using` `System;` `namespace` `UniquePathsWithObstacles {``    ``class` `Program {``        ``static` `void` `Main(``string``[] args)``        ``{``            ``int``[][] grid``                ``= ``new` `int``[][] { ``new` `int``[] { 0, 0, 0 },``                                ``new` `int``[] { 0, 1, 0 },``                                ``new` `int``[] { 0, 0, 0 } };``            ``Console.WriteLine(UniquePathsWithObstacles(grid));``        ``}` `        ``static` `int` `UniquePathsWithObstacles(``int``[][] grid)``        ``{``            ``int` `n = grid.Length;``            ``int` `m = grid[0].Length;``            ``if` `(n == 1 && m == 1 && grid[0][0] == 0)``                ``return` `1;``            ``if` `(n == 1 && m == 1 && grid[0][0] == 1)``                ``return` `0;` `            ``int``[][] dp = ``new` `int``[n][];``            ``for` `(``int` `i = 0; i < n; i++) {``                ``dp[i] = ``new` `int``[m];``                ``for` `(``int` `j = 0; j < m; j++) {``                    ``dp[i][j] = -1;``                ``}``            ``}` `            ``Path(dp, grid, 0, 0);``            ``if` `(dp[0][0] == -1)``                ``return` `0;``            ``return` `dp[0][0];``        ``}` `        ``static` `int` `Path(``int``[][] dp, ``int``[][] grid, ``int` `i, ``int` `j)``        ``{``            ``int` `n = grid.Length;``            ``int` `m = grid[0].Length;``            ``if` `(i < n && j < m && grid[i][j] == 1)``                ``return` `0;``            ``if` `(i == n - 1 && j == m - 1)``                ``return` `1;``            ``if` `(i >= n || j >= m)``                ``return` `0;``            ``if` `(dp[i][j] != -1)``                ``return` `dp[i][j];``            ``int` `left = Path(dp, grid, i + 1, j);``            ``int` `right = Path(dp, grid, i, j + 1);``            ``return` `dp[i][j] = left + right;``        ``}``    ``}``}`

Javascript

 `let n,m;``function` `path(dp, grid, i, j)``{``    ``if``(i=n || j>=m)``        ``return` `0;``    ``if``(dp[i][j]!=-1)``        ``return` `dp[i][j];``    ``let left=path(dp,grid,i+1,j);``    ``let right=path(dp,grid,i,j+1);``    ``return` `dp[i][j]=left+right;``}``function` `uniquePathsWithObstacles(grid) ``{``    ``n=grid.length;``    ``m=grid[0].length;``    ``if``(n==1 && m==1 && grid[0][0]==0)``        ``return` `1;``    ``if``(n==1 && m==1 && grid[0][0]==1)``        ``return` `0;``    ``let dp=``new` `Array(n);``    ``for``(let i=0; i

Output
```2

```

Time Complexity: O(M*N),For traversing all possible ways.
Auxiliary Space: O(M*N),For storing in 2D Dp Vector.

Previous
Next