# Check for possible path in 2D matrix

Given a 2D array(m x n). The task is to check if there is any path from top left to bottom right. In the matrix, -1 is considered as blockage (can’t go through this cell) and 0 is considered path cell (can go through it).

Note: Top left cell always contains 0

Examples:

Input : arr[][] = {{ 0, 0, 0, -1, 0},
{-1, 0, 0, -1, -1},
{ 0, 0, 0, -1, 0},
{-1, 0, 0, 0, 0},
{ 0, 0, -1, 0, 0}}
Output : Yes
Explanation: The red cells are blocked, white cell denotes the path and the green cells are not blocked cells.

Input : arr[][] = {{ 0, 0, 0, -1, 0},
{-1, 0, 0, -1, -1},
{ 0, 0, 0, -1, 0},
{-1, 0, -1, 0, 0},
{ 0, 0, -1, 0, 0}}
Output : No
Explanation: There exists no path from start to end. The red cells are blocked, white cell denotes the path and the green cells are not blocked cells.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Method 1

• Approach: The solution is to perform BFS or DFS to find whether there is a path or not. The graph needs not to be created to perform the bfs, but the matrix itself will be used as a graph. Start the traversal from the top right corner and if there is a way to reach the bottom right corner then there is a path.
• Algorithm:

1. Create a queue that stores pairs (i,j) and insert the (0,0) in the queue.
2. Run a loop till the queue is empty.
3. In each iteration dequeue the queue (a,b), if the front element is the destination (row-1,col-1) then return 1, i,e there is a path and change the value of mat[a][b] to -1, i.e. visited.
4. Else insert the adjacent indices where the value of matrix[i][j] is not -1.
• Implementation:

 `// CPP program to find if there is path  ` `// from top left to right bottom ` `#include ` `using` `namespace` `std; ` `  `  `#define row 5 ` `#define col 5 ` ` `  `  `  `// to find the path from ` `// top left to bottom right ` `bool` `isPath(``int` `arr[row][col]) ` `{ ` `    ``//directions ` `    ``int` `dir = { {0,1}, {0,-1}, {1,0}, {-1,1}}; ` `     `  `    ``//queue  ` `    ``queue > q; ` `     `  `    ``//insert the top right corner. ` `    ``q.push(make_pair(0,0)); ` `     `  `    ``//until queue is empty ` `    ``while``(q.size()>0) ` `    ``{ ` `        ``pair<``int``,``int``> p = q.front(); ` `        ``q.pop(); ` `         `  `        ``//mark as visited ` `        ``arr[p.first][p.second] = -1; ` `         `  `        ``//destination is reached. ` `        ``if``(p == make_pair(row-1,col-1)) ` `            ``return` `true``; ` `             `  `        ``//check all four directions ` `        ``for``(``int` `i=0; i<4 ;i++) ` `        ``{ ` `            ``//using the direction array ` `            ``int` `a = p.first + dir[i]; ` `            ``int` `b = p.second + dir[i]; ` `             `  `            ``//not blocked and valid ` `            ``if``(arr[a][b]!=-1&& a>=0 && b>=0 ` `                    ``&& a

Output:

```No
```
• Complexity Analysis:

• Time Complexity: O(R*C).
Every element of the matrix can be inserted once in the queue, so time Complexity is O(R*C).
• Space Complexity: O(R*C).
To store all the elements in a queue O(R*C) space is needed.

Method 2

• Approach: The only problem with the above solution is it uses extra space. This approach will eliminate the need for extra space. The basic idea is very similar. This algorithm will also perform BFS but the need for extra space will be eliminated by marking the array. So First run a loop and check which elements of the first column and the first row is accessible from 0,0 by using only the first row and column. mark them as 1. Now traverse the matrix from start to the end row-wise in increasing index of rows and columns. If the cell is not blocked then check that any of its adjacent cells is marked 1 or not. If marked 1 then mark the cell 1.
• Algorithm:

1. Mark the cell 0,0 as 1.
2. Run a loop from 0 to row length and if the cell above is marked 1 and the current cell is not blocked then mark the current cell as 1.
3. Run a loop from 0 to column length and if the left cell is marked 1 and the current cell is not blocked then mark the current cell as 1.
4. Traverse the matrix from start to the end row-wise in increasing index of rows and columns.
5. If the cell is not blocked then check that any of its adjacent cells (check only the cell above and the cell to the left). is marked 1 or not. If marked 1 then mark the cell 1.
6. If the cell (row-1, col-1) is marked 1 return true else return false.
• Implementation:

## C++

 `// CPP program to find if there is path  ` `// from top left to right bottom ` `#include ` `using` `namespace` `std; ` ` `  `#define row 5 ` `#define col 5 ` ` `  `// to find the path from ` `// top left to bottom right ` `bool` `isPath(``int` `arr[row][col]) ` `{ ` `    ``// set arr = 1 ` `    ``arr = 1; ` ` `  `    ``// Mark reachable (from top left) nodes  ` `    ``// in first row and first column. ` `    ``for` `(``int` `i = 1; i < row; i++)  ` `        ``if` `(arr[i] != -1) ` `            ``arr[i] = arr[i - 1];    ` ` `  `    ``for` `(``int` `j = 1; j < col; j++)  ` `        ``if` `(arr[j] != -1) ` `            ``arr[j] = arr[j - 1];     ` ` `  `    ``// Mark reachable nodes in remaining ` `    ``// matrix. ` `    ``for` `(``int` `i = 1; i < row; i++)  ` `        ``for` `(``int` `j = 1; j < col; j++)  ` `          ``if` `(arr[i][j] != -1) ` `              ``arr[i][j] = max(arr[i][j - 1], ` `                            ``arr[i - 1][j]);        ` `     `  `    ``// return yes if right bottom  ` `    ``// index is 1 ` `    ``return` `(arr[row - 1][col - 1] == 1); ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Given array ` `    ``int` `arr[row][col] = { { 0, 0, 0, -1, 0 }, ` `                          ``{ -1, 0, 0, -1, -1 }, ` `                          ``{ 0, 0, 0, -1, 0 }, ` `                          ``{ -1, 0, -1, 0, -1 }, ` `                          ``{ 0, 0, -1, 0, 0 } }; ` ` `  `    ``// path from arr to arr[row][col] ` `    ``if` `(isPath(arr)) ` `      ``cout << ``"Yes"``; ` `    ``else` `      ``cout << ``"No"``; ` ` `  `return` `0; ` `} `

## Java

 `// Java program to find if there is path ` `// from top left to right bottom ` `class` `GFG ` `{ ` `    ``// to find the path from ` `    ``// top left to bottom right ` `    ``static` `boolean` `isPath(``int` `arr[][]) ` `    ``{ ` `        ``// set arr = 1 ` `        ``arr[``0``][``0``] = ``1``; ` ` `  `        ``// Mark reachable (from top left) nodes ` `        ``// in first row and first column. ` `        ``for` `(``int` `i = ``1``; i < ``5``; i++) ` `            ``if` `(arr[``0``][i] != -``1``) ` `                ``arr[``0``][i] = arr[``0``][i - ``1``]; ` `        ``for` `(``int` `j = ``1``; j < ``5``; j++) ` `            ``if` `(arr[j][``0``] != -``1``) ` `                ``arr[j][``0``] = arr[j - ``1``][``0``]; ` ` `  `        ``// Mark reachable nodes in ` `        ``//  remaining matrix. ` `        ``for` `(``int` `i = ``1``; i < ``5``; i++) ` `            ``for` `(``int` `j = ``1``; j < ``5``; j++) ` `                ``if` `(arr[i][j] != -``1``) ` `                    ``arr[i][j] = Math.max(arr[i][j - ``1``], ` `                                        ``arr[i - ``1``][j]); ` ` `  `        ``// return yes if right  ` `        ``// bottom index is 1 ` `        ``return` `(arr[``5` `- ``1``][``5` `- ``1``] == ``1``); ` `    ``} ` `      `  `    ``//Driver code  ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``// Given array ` `        ``int` `arr[][] = { { ``0``, ``0``, ``0``, -``1``, ``0` `}, ` `                        ``{ -``1``, ``0``, ``0``, -``1``, -``1` `}, ` `                        ``{ ``0``, ``0``, ``0``, -``1``, ``0` `}, ` `                        ``{ -``1``, ``0``, -``1``, ``0``, -``1` `}, ` `                        ``{ ``0``, ``0``, -``1``, ``0``, ``0` `} }; ` ` `  `        ``// path from arr  ` `        ``// to arr[row][col] ` `        ``if` `(isPath(arr)) ` `            ``System.out.println(``"Yes"``); ` `        ``else` `            ``System.out.println(``"No"``); ` `    ``} ` `} ` `// This code is contributed  ` `// by prerna saini  `

## Python3

 `# Python3 program to find if there  ` `# is path from top left to right bottom  ` `row ``=` `5` `col ``=` `5` ` `  `# to find the path from  ` `# top left to bottom right  ` `def` `isPath(arr): ` `     `  `    ``# set arr = 1 ` `    ``arr[``0``][``0``] ``=` `1` ` `  `    ``# Mark reachable (from top left)  ` `    ``# nodes in first row and first column.  ` `    ``for` `i ``in` `range``(``1``, row): ` `        ``if` `(arr[i][``0``] !``=` `-``1``): ` `            ``arr[i][``0``] ``=` `arr[i``-``1``][``0``] ` ` `  `    ``for` `j ``in` `range``(``1``, col): ` `        ``if` `(arr[``0``][j] !``=` `-``1``): ` `            ``arr[``0``][j] ``=` `arr[``0``][j``-``1``] ` `             `  `    ``# Mark reachable nodes in  ` `    ``# remaining matrix.  ` `    ``for` `i ``in` `range``(``1``, row): ` `        ``for` `j ``in` `range``(``1``, col): ` `            ``if` `(arr[i][j] !``=` `-``1``): ` `                ``arr[i][j] ``=` `max``(arr[i][j ``-` `1``],  ` `                                ``arr[i ``-` `1``][j]) ` `                                 `  `    ``# return yes if right  ` `    ``# bottom index is 1 ` `    ``return` `(arr[row ``-` `1``][col ``-` `1``] ``=``=` `1``) ` ` `  `# Driver Code  ` ` `  `# Given array  ` `arr ``=` `[[ ``0``, ``0``, ``0``, ``-``1``, ``0` `],  ` `       ``[``-``1``, ``0``, ``0``, ``-``1``, ``-``1``],  ` `       ``[ ``0``, ``0``, ``0``, ``-``1``, ``0` `],  ` `       ``[``-``1``, ``0``, ``-``1``, ``0``, ``-``1``],  ` `       ``[ ``0``, ``0``, ``-``1``, ``0``, ``0` `]]  ` ` `  `# path from arr to arr[row][col]  ` `if` `(isPath(arr)): ` `    ``print``(``"Yes"``)  ` `else``: ` `    ``print``(``"No"``) ` ` `  `# This code is contributed  ` `# by sahilshelangia `

## C#

 `// C# program to find if there is path ` `// from top left to right bottom ` `using` `System; ` ` `  `class` `GFG ` `{ ` `    ``// to find the path from ` `    ``// top left to bottom right ` `    ``static` `bool` `isPath(``int` `[,]arr) ` `    ``{ ` `        ``// set arr = 1 ` `        ``arr[0, 0] = 1; ` ` `  `        ``// Mark reachable (from top left) nodes ` `        ``// in first row and first column. ` `        ``for` `(``int` `i = 1; i < 5; i++) ` `            ``if` `(arr[i, 0] != -1) ` `                ``arr[i, 0] = arr[i - 1, 0]; ` `        ``for` `(``int` `j = 1; j < 5; j++) ` `            ``if` `(arr[0,j] != -1) ` `                ``arr[0,j] = arr[0, j - 1]; ` ` `  `        ``// Mark reachable nodes in ` `        ``// remaining matrix. ` `        ``for` `(``int` `i = 1; i < 5; i++) ` `            ``for` `(``int` `j = 1; j < 5; j++) ` `                ``if` `(arr[i, j] != -1) ` `                    ``arr[i, j] = Math.Max(arr[i, j - 1], ` `                                        ``arr[i - 1, j]); ` ` `  `        ``// return yes if right  ` `        ``// bottom index is 1 ` `        ``return` `(arr[5 - 1, 5 - 1] == 1); ` `    ``} ` `     `  `    ``//Driver code  ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``// Given array ` `        ``int` `[,]arr = { { 0, 0, 0, -1, 0 }, ` `                        ``{ -1, 0, 0, -1, -1 }, ` `                        ``{ 0, 0, 0, -1, 0 }, ` `                        ``{ -1, 0, -1, 0, -1 }, ` `                        ``{ 0, 0, -1, 0, 0 } }; ` ` `  `        ``// path from arr  ` `        ``// to arr[row][col] ` `        ``if` `(isPath(arr)) ` `            ``Console.WriteLine(``"Yes"``); ` `        ``else` `            ``Console.WriteLine(``"No"``); ` `    ``} ` `} ` ` `  `// This code is contributed  ` `// by vt_m `

## PHP

 ` `

Output:

```No
```
• Complexity Analysis:

• Time Complexity: O(R*C).
Every element of the matrix is traversed, so time Complexity is O(R*C).
• Space Complexity: O(1).
No extra space is needed.

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.