Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Check for possible path in 2D matrix

  • Difficulty Level : Medium
  • Last Updated : 09 Jul, 2021

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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. 

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:

C++




// C++ program to find if there is path
// from top left to right bottom
#include <bits/stdc++.h>
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[4][2] = { {0,1}, {0,-1}, {1,0}, {-1,0}};
     
    //queue
    queue<pair<int,int> > 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][0];
            int b = p.second + dir[i][1];
             
            //not blocked and valid
            if(arr[a][b]!=-1&& a>=0 && b>=0
                    && a<row && b<col)
            {
                q.push(make_pair(a,b));
            }
        }
    }
    return false;
}
  
// 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[0][0] 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
import java.io.*;
import java.util.*;
 
class pair
{
    int Item1, Item2;
    pair(int f, int s)
    {
        Item1 = f;
        Item2 = s;
    }
}
 
class GFG{
     
static int row = 5;
static int col = 5;
  
// To find the path from
// top left to bottom right
static boolean isPath(int[][] arr)
{
     
    // Directions
    int[][] dir = { { 0, 1 }, { 0, -1 },
                    { 1, 0 }, { -1, 0 } };
        
    // Queue
    Queue<pair> q = new LinkedList<>();
      
    // Insert the top right corner.
    q.add(new pair(0, 0));
        
    // Until queue is empty
    while (q.size() > 0)
    {
        pair p = (q.peek());
        q.remove();
            
        // Mark as visited
        arr[p.Item1][ p.Item2] = -1;
            
        // Destination is reached.
        if (p == new 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.Item1 + dir[i][0];
            int b = p.Item2 + dir[i][1];
                
            // Not blocked and valid
            if (a >= 0 && b >= 0 &&
                a < row && b < col &&
                  arr[a][ b] != -1)
            {
                q.add(new pair(a, b));
            }
        }
    }
    return false;
}
  
// 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[0][0] to arr[row][col]
    if (isPath(arr))
        System.out.println("Yes");
    else
        System.out.println("No");
}
}
 
// This code is contributed by avanitrachhadiya2155

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) :
 
    # directions
    Dir = [ [0, 1], [0, -1], [1, 0], [-1, 0]]
     
    # queue
    q = []
     
    # insert the top right corner.
    q.append((0, 0))
     
    # until queue is empty
    while(len(q) > 0) :
        p = q[0]
        q.pop(0)
         
        # mark as visited
        arr[p[0]][p[1]] = -1
         
        # destination is reached.
        if(p == (row - 1, col - 1)) :
            return True
             
        # check all four directions
        for i in range(4) :
         
            # using the direction array
            a = p[0] + Dir[i][0]
            b = p[1] + Dir[i][1]
             
            # not blocked and valid
            if(a >= 0 and b >= 0 and a < row and b < col and arr[a][b] != -1) :           
                q.append((a, b))
    return False
   
# 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[0][0] to arr[row][col]
if (isPath(arr)) :
    print("Yes")
else :
    print("No")
 
    # This code is contributed by divyesh072019

C#




// C# program to find if there is path 
// from top left to right bottom
using System;
using System.Collections;
 
class GFG{
     
static int row = 5;
static int col = 5;
 
// To find the path from
// top left to bottom right
static bool isPath(int[,] arr)
{
     
    // Directions
    int[,] dir = { { 0, 1 }, { 0, -1 },
                   { 1, 0 }, { -1, 0 } };
       
    // Queue
    Queue q = new Queue();
     
    // Insert the top right corner.
    q.Enqueue(new Tuple<int, int>(0, 0));
       
    // Until queue is empty
    while (q.Count > 0)
    {
        Tuple<int, int> p = (Tuple<int, int>)(q.Peek());
        q.Dequeue();
           
        // Mark as visited
        arr[p.Item1, p.Item2] = -1;
           
        // Destination is reached. 
        if (p == new Tuple<int, int>(row - 1, col - 1))
            return true;
               
        // Check all four directions
        for(int i = 0; i < 4; i++)
        {
             
            // Using the direction array
            int a = p.Item1 + dir[i, 0];
            int b = p.Item2 + dir[i, 1];
               
            // Not blocked and valid
            if (a >= 0 && b >= 0 &&
               a < row && b < col &&
                  arr[a, b] != -1)
            {
                q.Enqueue(new Tuple<int, int>(a, b));
            }
        }
    }
    return false;
}
 
// Driver Code
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[0][0] to arr[row][col]
    if (isPath(arr))
        Console.Write("Yes");
    else
        Console.Write("No");
}
}
 
// This code is contributed by divyeshrabadiya07

Javascript




<script>
 
// JavaScript program to find if there is path 
// from top left to right bottom
 
var row = 5;
var col = 5;
 
// To find the path from
// top left to bottom right
function isPath(arr)
{
     
    // Directions
    var dir = [ [ 0, 1 ], [ 0, -1 ],
                   [ 1, 0 ], [ -1, 0 ] ];
       
    // Queue
    var q = [];
     
    // Insert the top right corner.
    q.push([0, 0]);
       
    // Until queue is empty
    while (q.length > 0)
    {
        var p = q[0];
        q.shift();
           
        // Mark as visited
        arr[p[0]][p[1]] = -1;
           
        // Destination is reached. 
        if (p == [row - 1][col - 1])
            return true;
               
        // Check all four directions
        for(var i = 0; i < 4; i++)
        {
             
            // Using the direction array
            var a = p[0] + dir[i][0];
            var b = p[1] + dir[i][1];
               
            // Not blocked and valid
            if (a >= 0 && b >= 0 &&
               a < row && b < col &&
                  arr[a][b] != -1)
            {
                q.push([a,b]);
            }
        }
    }
    return false;
}
 
// Driver Code
// Given array
var 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[0][0] to arr[row][col]
if (isPath(arr))
    document.write("Yes");
else
    document.write("No");
 
 
</script>

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++




// C++ program to find if there is path
// from top left to right bottom
#include <iostream>
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[0][0] = 1
    arr[0][0] = 1;
 
    // Mark reachable (from top left) nodes
    // in first row and first column.
    for (int i = 1; i < row; i++)
        if (arr[i][0] != -1)
            arr[i][0] = arr[i - 1][0];  
 
    for (int j = 1; j < col; j++)
        if (arr[0][j] != -1)
            arr[0][j] = arr[0][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[0][0] 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[0][0] = 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[0][0]
        // 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[0][0] = 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[0][0] 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[0][0] = 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[0][0]
        // to arr[row][col]
        if (isPath(arr))
            Console.WriteLine("Yes");
        else
            Console.WriteLine("No");
    }
}
 
// This code is contributed
// by vt_m

PHP




<?php
// PHP 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
function isPath($arr)
{
    global $row, $col;
     
    $arr[0][0] = 1;
 
    // Mark reachable (from
    // top left) nodes in
    // first row and first column.
    for ($i = 1; $i < $row; $i++)
        if ($arr[$i][0] != -1)
            $arr[$i][0] = $arr[$i - 1][0];
 
    for ($j = 1; $j < $col; $j++)
        if ($arr[0][$j] != -1)
            $arr[0][$j] = $arr[0][$j - 1];
 
    // Mark reachable nodes
    // in remaining matrix.
    for ($i = 1; $i < $row; $i++)
        for ($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
 
// Given array
$arr = array(array(0, 0, 0, 1, 0),
             array(-1, 0, 0, -1, -1),
             array(0, 0, 0, -1, 0),
             array(-1, 0, -1, 0, -1),
             array(0, 0, -1, 0, 0));
 
// path from arr[0][0]
// to arr[row][col]
if (isPath($arr))
echo "Yes";
else
echo "No";
     
// This code is contributed by anuj_67.
?>

Javascript




<script>
 
// JavaScript program to find if there is path
// from top left to right bottom
var arr = [[5], [5]]
// to find the path from
// top left to bottom right
function isPath(arr)
{
    // set arr[0][0] = 1
    arr[0][0] = 1;
  
    // Mark reachable (from top left) nodes
    // in first row and first column.
    for (var i = 1; i < 5; i++)
        if (arr[i][0] != -1)
            arr[i][0] = arr[i - 1][0];  
  
    for (var j = 1; j < 5; j++)
        if (arr[0][j] != -1)
            arr[0][j] = arr[0][j - 1];   
  
    // Mark reachable nodes in remaining
    // matrix.
    for (var i = 1; i < 5; i++)
        for (var 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
 
    // Given array
    var 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[0][0] to arr[row][col]
    if (isPath(arr))
      document.write("Yes");
    else
      document.write("No");
  
// This code is contributed by Mayank Tyagi
 
</script>

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.

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!