Count number of ways to reach destination in a Maze

• Difficulty Level : Medium
• Last Updated : 26 Oct, 2021

Given a maze with obstacles, count the number of paths to reach the rightmost-bottommost cell from the topmost-leftmost cell. A cell in the given maze has a value of -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 the 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 the above idea.

C++

// C++ program to count number of paths in a maze
// with obstacles.
#include<bits/stdc++.h>
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<R; i++)
{
if (maze[i] == 0)
maze[i] = 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[i] == 0)
maze[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<C; j++)
{
// 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
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==-1)
return 0;

// Initializing the leftmost column
for (int i = 0; i < R; i++)
{
if (maze[i] == 0)
maze[i] = 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[i] == 0)
maze[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 <C ; j++)
{
// 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
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 == -1):
return 0

# Initializing the leftmost column
for i in range(R):
if (maze[i] == 0):
maze[i] = 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[i] == 0):
maze[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 <C ; j++)
{
// 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
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

<?php
// PHP 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)
function countPaths( \$maze)
{
global \$R, \$C;

// If the initial cell is
// blocked, there is no
// way of moving anywhere
if (\$maze == - 1)
return 0;

// Initializing the
// leftmost column
for ( \$i = 0; \$i < \$R; \$i++)
{
if (\$maze[\$i] == 0)
\$maze[\$i] = 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 = 1; \$i < \$C; \$i++)
{
if (\$maze[\$i] == 0)
\$maze[\$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 = 1; \$i < \$R; \$i++)
{
for(\$j = 1; \$j < \$C; \$j++)
{

// 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,
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.
?>

Javascript

<script>

// JavaScript program to count number
// of paths in a maze with obstacles.
let R = 4;
let C = 4;

// Returns count of possible paths in
// a maze[R][C] from (0,0) to (R-1,C-1)
function countPaths(maze)
{

// If the initial cell is blocked,
// there is no way of moving anywhere
if (maze == -1)
return 0;

// Initializing the leftmost column
for(let i = 0; i < R; i++)
{
if (maze[i] == 0)
maze[i] = 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(let i = 1; i < C; i++)
{
if (maze[i] == 0)
maze[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(let i = 1; i < R; i++)
{
for(let j = 1; j < C; j++)
{

// 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
return (maze[R - 1][C - 1] > 0) ?
maze[R - 1][C - 1] : 0;
}

// Driver Code
let maze = [ [ 0, 0, 0, 0 ],
[ 0, -1, 0, 0 ],
[ -1, 0, 0, 0 ],
[ 0, 0, 0, 0 ] ];

document.write(countPaths(maze));

// This code is contributed by code_hunt

</script>

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 write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.