# Count number of ways to reach destination in a Maze

Given a maze with obstacles, count number of paths to reach rightmost-bottommost cell from topmost-leftmost cell. A cell in given maze has value -1 if it is a blockage or dead end, else 0.

From a given cell, we are allowed to move to cells (i+1, j) and (i, j+1) only.

Examples:

```Input: maze[R][C] =  {{0,  0, 0, 0},
{0, -1, 0, 0},
{-1, 0, 0, 0},
{0,  0, 0, 0}};
Output: 4
There are four possible paths as shown in
below diagram. ```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

This problem is an extension of below problem.

Backtracking | Set 2 (Rat in a Maze)

In this post a different solution is discussed that can be used to solve the above Rat in a Maze problem also.

The idea is to modify the given grid[][] so that grid[i][j] contains count of paths to reach (i, j) from (0, 0) if (i, j) is not a blockage, else grid[i][j] remains -1.

```We can recursively compute grid[i][j] using below
formula and finally return grid[R-1][C-1]

// If current cell is a blockage
if (maze[i][j] == -1)
maze[i][j] = -1; //  Do not change

// If we can reach maze[i][j] from maze[i-1][j]
// then increment count.
else if (maze[i-1][j] > 0)
maze[i][j] = (maze[i][j] + maze[i-1][j]);

// If we can reach maze[i][j] from maze[i][j-1]
// then increment count.
else if (maze[i][j-1] > 0)
maze[i][j] = (maze[i][j] + maze[i][j-1]);
```

Below is the implementation of above idea.

## C++

 `// C++ program to count number of paths in a maze ` `// with obstacles. ` `#include ` `using` `namespace` `std; ` `#define R 4 ` `#define C 4 ` ` `  `// Returns count of possible paths in a maze[R][C] ` `// from (0,0) to (R-1,C-1) ` `int` `countPaths(``int` `maze[][C]) ` `{ ` `    ``// If the initial cell is blocked, there is no ` `    ``// way of moving anywhere ` `    ``if` `(maze==-1) ` `        ``return` `0; ` ` `  `    ``// Initializing the leftmost column ` `    ``for` `(``int` `i=0; i 0) ` `                ``maze[i][j] = (maze[i][j] + maze[i-1][j]); ` ` `  `            ``// If we can reach maze[i][j] from maze[i][j-1] ` `            ``// then increment count. ` `            ``if` `(maze[i][j-1] > 0) ` `                ``maze[i][j] = (maze[i][j] + maze[i][j-1]); ` `        ``} ` `    ``} ` ` `  `    ``// If the final cell is blocked, output 0, otherwise ` `    ``// the answer ` `    ``return` `(maze[R-1][C-1] > 0)? maze[R-1][C-1] : 0; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `maze[R][C] =  {{0,  0, 0, 0}, ` `                       ``{0, -1, 0, 0}, ` `                       ``{-1, 0, 0, 0}, ` `                       ``{0,  0, 0, 0}}; ` `    ``cout << countPaths(maze); ` `    ``return` `0; ` `} `

## Java

 `// Java program to count number of paths in a maze ` `// with obstacles. ` `import` `java.io.*; ` ` `  `class` `GFG  ` `{ ` `    ``static` `int` `R = ``4``; ` `    ``static` `int` `C = ``4``; ` `     `  `    ``// Returns count of possible paths in  ` `    ``// a maze[R][C] from (0,0) to (R-1,C-1) ` `    ``static` `int` `countPaths(``int` `maze[][]) ` `    ``{ ` `        ``// If the initial cell is blocked,  ` `        ``// there is no way of moving anywhere ` `        ``if` `(maze[``0``][``0``]==-``1``) ` `            ``return` `0``; ` `     `  `        ``// Initializing the leftmost column ` `        ``for` `(``int` `i = ``0``; i < R; i++) ` `        ``{ ` `            ``if` `(maze[i][``0``] == ``0``) ` `                ``maze[i][``0``] = ``1``; ` `     `  `            ``// If we encounter a blocked cell  ` `            ``// in leftmost row, there is no way  ` `            ``// of visiting any cell directly below it. ` `            ``else` `                ``break``; ` `        ``} ` `     `  `        ``// Similarly initialize the topmost row ` `        ``for` `(``int` `i =``1` `; i< C ; i++) ` `        ``{ ` `            ``if` `(maze[``0``][i] == ``0``) ` `                ``maze[``0``][i] = ``1``; ` `     `  `            ``// If we encounter a blocked cell in  ` `            ``// bottommost row, there is no way of  ` `            ``// visiting any cell directly below it. ` `            ``else` `                ``break``; ` `        ``} ` `     `  `        ``// The only difference is that if a cell  ` `        ``// is -1, simply ignore it else recursively  ` `        ``// compute count value maze[i][j] ` `        ``for` `(``int` `i = ``1``; i < R; i++) ` `        ``{ ` `            ``for` `(``int` `j = ``1``; j ``0``) ` `                    ``maze[i][j] = (maze[i][j] +  ` `                                 ``maze[i - ``1``][j]); ` `     `  `                ``// If we can reach maze[i][j] from ` `                ``//  maze[i][j-1] then increment count. ` `                ``if` `(maze[i][j - ``1``] > ``0``) ` `                    ``maze[i][j] = (maze[i][j] +  ` `                                  ``maze[i][j - ``1``]); ` `            ``} ` `        ``} ` `     `  `        ``// If the final cell is blocked,  ` `        ``// output 0, otherwise the answer ` `        ``return` `(maze[R - ``1``][C - ``1``] > ``0``) ?  ` `                ``maze[R - ``1``][C - ``1``] : ``0``; ` `    ``} ` `     `  `    ``// Driver code ` ` `  `    ``public` `static` `void` `main (String[] args)  ` `    ``{ ` `        ``int` `maze[][] = {{``0``, ``0``, ``0``, ``0``}, ` `                       ``{``0``, -``1``, ``0``, ``0``}, ` `                       ``{-``1``, ``0``, ``0``, ``0``}, ` `                       ``{``0``, ``0``, ``0``, ``0``}}; ` `        ``System.out.println (countPaths(maze)); ` `     `  `    ``} ` ` `  `} ` ` `  `// This code is contributed by vt_m `

## Python3

 `# Python 3 program to count number of paths  ` `# in a maze with obstacles. ` ` `  `R ``=` `4` `C ``=` `4` ` `  `# Returns count of possible paths in a ` `# maze[R][C] from (0,0) to (R-1,C-1) ` `def` `countPaths(maze): ` `     `  `    ``# If the initial cell is blocked,  ` `    ``# there is no way of moving anywhere ` `    ``if` `(maze[``0``][``0``] ``=``=` `-``1``): ` `        ``return` `0` ` `  `    ``# Initializing the leftmost column ` `    ``for` `i ``in` `range``(R): ` `        ``if` `(maze[i][``0``] ``=``=` `0``): ` `            ``maze[i][``0``] ``=` `1` ` `  `        ``# If we encounter a blocked cell in  ` `        ``# leftmost row, there is no way of  ` `        ``# visiting any cell directly below it. ` `        ``else``: ` `            ``break` ` `  `    ``# Similarly initialize the topmost row ` `    ``for` `i ``in` `range``(``1``, C, ``1``): ` `        ``if` `(maze[``0``][i] ``=``=` `0``): ` `            ``maze[``0``][i] ``=` `1` ` `  `        ``# If we encounter a blocked cell in  ` `        ``# bottommost row, there is no way of ` `        ``# visiting any cell directly below it. ` `        ``else``: ` `            ``break` ` `  `    ``# The only difference is that if a cell is -1, ` `    ``# simply ignore it else recursively compute ` `    ``# count value maze[i][j] ` `    ``for` `i ``in` `range``(``1``, R, ``1``): ` `        ``for` `j ``in` `range``(``1``, C, ``1``): ` `             `  `            ``# If blockage is found, ignore this cell  ` `            ``if` `(maze[i][j] ``=``=` `-``1``): ` `                ``continue` ` `  `            ``# If we can reach maze[i][j] from  ` `            ``# maze[i-1][j] then increment count. ` `            ``if` `(maze[i ``-` `1``][j] > ``0``): ` `                ``maze[i][j] ``=` `(maze[i][j] ``+` `                              ``maze[i ``-` `1``][j]) ` ` `  `            ``# If we can reach maze[i][j] from  ` `            ``# maze[i][j-1] then increment count. ` `            ``if` `(maze[i][j ``-` `1``] > ``0``): ` `                ``maze[i][j] ``=` `(maze[i][j] ``+` `                              ``maze[i][j ``-` `1``]) ` ` `  `    ``# If the final cell is blocked,  ` `    ``# output 0, otherwise the answer ` `    ``if` `(maze[R ``-` `1``][C ``-` `1``] > ``0``): ` `        ``return` `maze[R ``-` `1``][C ``-` `1``]  ` `    ``else``: ` `        ``return` `0` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``maze ``=` `[[``0``, ``0``, ``0``, ``0``], ` `            ``[``0``, ``-``1``, ``0``, ``0``], ` `            ``[``-``1``, ``0``, ``0``, ``0``], ` `            ``[``0``, ``0``, ``0``, ``0` `]] ` `    ``print``(countPaths(maze)) ` ` `  `# This code is contributed by ` `# Surendra_Gangwar `

## C#

 `// C# program to count number of paths in a maze ` `// with obstacles. ` `using` `System; ` ` `  `class` `GFG { ` `     `  `    ``static` `int` `R = 4; ` `    ``static` `int` `C = 4; ` `     `  `    ``// Returns count of possible paths in  ` `    ``// a maze[R][C] from (0,0) to (R-1,C-1) ` `    ``static` `int` `countPaths(``int` `[,]maze) ` `    ``{ ` `         `  `        ``// If the initial cell is blocked,  ` `        ``// there is no way of moving anywhere ` `        ``if` `(maze[0,0]==-1) ` `            ``return` `0; ` `     `  `        ``// Initializing the leftmost column ` `        ``for` `(``int` `i = 0; i < R; i++) ` `        ``{ ` `            ``if` `(maze[i,0] == 0) ` `                ``maze[i,0] = 1; ` `     `  `            ``// If we encounter a blocked cell  ` `            ``// in leftmost row, there is no way  ` `            ``// of visiting any cell directly below it. ` `            ``else` `                ``break``; ` `        ``} ` `     `  `        ``// Similarly initialize the topmost row ` `        ``for` `(``int` `i =1 ; i< C ; i++) ` `        ``{ ` `            ``if` `(maze[0,i] == 0) ` `                ``maze[0,i] = 1; ` `     `  `            ``// If we encounter a blocked cell in  ` `            ``// bottommost row, there is no way of  ` `            ``// visiting any cell directly below it. ` `            ``else` `                ``break``; ` `        ``} ` `     `  `        ``// The only difference is that if a cell  ` `        ``// is -1, simply ignore it else recursively  ` `        ``// compute count value maze[i][j] ` `        ``for` `(``int` `i = 1; i < R; i++) ` `        ``{ ` `            ``for` `(``int` `j = 1; j 0) ` `                    ``maze[i,j] = (maze[i,j] +  ` `                                ``maze[i - 1,j]); ` `     `  `                ``// If we can reach maze[i][j] from ` `                ``// maze[i][j-1] then increment count. ` `                ``if` `(maze[i,j - 1] > 0) ` `                    ``maze[i,j] = (maze[i,j] +  ` `                                ``maze[i,j - 1]); ` `            ``} ` `        ``} ` `     `  `        ``// If the final cell is blocked,  ` `        ``// output 0, otherwise the answer ` `        ``return` `(maze[R - 1,C - 1] > 0) ?  ` `                ``maze[R - 1,C - 1] : 0; ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main ()  ` `    ``{ ` `        ``int` `[,]maze = { {0, 0, 0, 0}, ` `                        ``{0, -1, 0, 0}, ` `                        ``{-1, 0, 0, 0}, ` `                        ``{0, 0, 0, 0}}; ` `                         `  `        ``Console.Write (countPaths(maze)); ` `    ``} ` ` `  `} ` ` `  `// This code is contributed by nitin mittal. `

## PHP

 ` 0) ` `                ``\$maze``[``\$i``][``\$j``] = (``\$maze``[``\$i``][``\$j``] +  ` `                           ``\$maze``[``\$i` `- 1][``\$j``]); ` ` `  `            ``// If we can reach maze[i][j] ` `            ``// from maze[i][j-1] ` `            ``// then increment count. ` `            ``if` `(``\$maze``[``\$i``][``\$j` `- 1] > 0) ` `                ``\$maze``[``\$i``][``\$j``] = (``\$maze``[``\$i``][``\$j``] +  ` `                             ``\$maze``[``\$i``][``\$j` `- 1]); ` `        ``} ` `    ``} ` ` `  `    ``// If the final cell is  ` `    ``// blocked, output 0,  ` `    ``// otherwise the answer ` `    ``return` `(``\$maze``[``\$R` `- 1][``\$C` `- 1] > 0) ? ` `            ``\$maze``[``\$R` `- 1][``\$C` `- 1] : 0; ` `} ` ` `  `    ``// Driver Code ` `    ``\$maze` `= ``array``(``array``(0, 0, 0, 0), ` `                  ``array``(0, -1, 0, 0), ` `                  ``array``(-1, 0, 0, 0), ` `                  ``array``(0, 0, 0, 0)); ` `    ``echo` `countPaths(``\$maze``); ` ` `  `// This code is contributed by anuj_67. ` `?> `

Output:

```4
```

Time Complexity : O(R x C)

This article is contributed by Roshni Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.