Find whether there is path between two cells in matrix

12 May, 2022
Given N X N matrix filled with 1, 0, 2, 3. Find whether there is a path possible from source to destination, traversing through blank cells only. You can traverse up, down, right, and left. 
A value of cell 1 means Source.
A value of cell 2 means Destination.
A value of cell 3 means Blank cell.
A value of cell 0 means Blank Wall.
Note: there are an only a single source and single destination(sink). 
Examples: 
Input: M[3][3] = {{ 0, 3, 2 }, { 3, 3, 0 }, { 1, 3, 0 }}; Output : Yes Explanation:  
Input: M[4][4] = {{ 0, 3, 1, 0 }, { 3, 0, 3, 3 }, { 2, 3, 0, 3 }, { 0, 3, 3, 3 }}; Output: Yes Explanation:  
 
Asked in: Adobe Interview  
Simple Solution: Recursion.Approach: Find the source index of the cell in each matrix and then recursively find a path from source index to destination in the matrix. The algorithm involves recursively finding all the paths until a final path is found to the destination.
Algorithm :  
Traverse the matrix and find the starting index of the matrix.Create a recursive function that takes the index and visited matrix.Mark the current cell and check if the current cell is a destination or not. If the current cell is destination return true.Call the recursion function for all adjacent empty and unvisited cells.If any of the recursive functions returns true then unmark the cell and return true else unmark the cell and return false.
Traverse the matrix and find the starting index of the matrix.
Create a recursive function that takes the index and visited matrix.
Mark the current cell and check if the current cell is a destination or not. If the current cell is destination return true.
Call the recursion function for all adjacent empty and unvisited cells.
If any of the recursive functions returns true then unmark the cell and return true else unmark the cell and return false.
C++
Java
Python3
C#
Javascript
// C++ program to find path between two// cell in matrix#include <iostream>using namespace std;#define N 4 // Method for checking boundariesbool isSafe(int i, int j, int matrix[][N]){  if (i >= 0 && i < N && j >= 0 && j < N)    return true;  return false;} // Returns true if there is a// path from a source (a// cell with value 1) to a// destination (a cell with// value 2)bool isPath(int matrix[][N], int i, int j,            bool visited[][N]){  // Checking the boundaries, walls and  // whether the cell is unvisited  if (isSafe(i, j, matrix) && matrix[i][j] != 0      && !visited[i][j])  {    // Make the cell visited    visited[i][j] = true;     // if the cell is the required    // destination then return true    if (matrix[i][j] == 2)      return true;     // traverse up    bool up = isPath(matrix, i - 1, j, visited);     // if path is found in up    // direction return true    if (up)      return true;     // traverse left    bool left = isPath(matrix, i, j - 1, visited);     // if path is found in left    // direction return true    if (left)      return true;     // traverse down    bool down = isPath(matrix, i + 1, j, visited);     // if path is found in down    // direction return true    if (down)      return true;     // traverse right    bool right = isPath(matrix, i, j + 1, visited);     // if path is found in right    // direction return true    if (right)      return true;  }   // no path has been found  return false;} // Method for finding and printing// whether the path exists or notvoid isPath(int matrix[][N]){   // Defining visited array to keep  // track of already visited indexes  bool visited[N][N];   // Flag to indicate whether the  // path exists or not  bool flag = false;  for (int i = 0; i < N; i++)  {    for (int j = 0; j < N; j++)    {      // if matrix[i][j] is source      // and it is not visited      if (matrix[i][j] == 1 && !visited[i][j])         // Starting from i, j and        // then finding the path        if (isPath(matrix, i, j, visited))        {           // if path exists          flag = true;          break;        }    }  }  if (flag)    cout << "YES";  else    cout << "NO";} // Driver program to// check above functionint main(){  int matrix[N][N] = { { 0, 3, 0, 1 },                      { 3, 0, 3, 3 },                      { 2, 3, 3, 3 },                      { 0, 3, 3, 3 } };   // calling isPath method  isPath(matrix);  return 0;} // This code is contributed by sudhanshugupta2019a.
// Java program to find path between two// cell in matrixclass Path {     // Method for finding and printing    // whether the path exists or not    public static void isPath(        int matrix[][], int n)    {        // Defining visited array to keep        // track of already visited indexes        boolean visited[][]            = new boolean[n][n];         // Flag to indicate whether the        // path exists or not        boolean flag = false;         for (int i = 0; i < n; i++) {            for (int j = 0; j < n; j++) {                // if matrix[i][j] is source                // and it is not visited                if (                    matrix[i][j] == 1                    && !visited[i][j])                     // Starting from i, j and                    // then finding the path                    if (isPath(                            matrix, i, j, visited)) {                        // if path exists                        flag = true;                        break;                    }            }        }        if (flag)            System.out.println("YES");        else            System.out.println("NO");    }     // Method for checking boundaries    public static boolean isSafe(        int i, int j,        int matrix[][])    {         if (            i >= 0 && i < matrix.length            && j >= 0            && j < matrix[0].length)            return true;        return false;    }     // Returns true if there is a    // path from a source (a    // cell with value 1) to a    // destination (a cell with    // value 2)    public static boolean isPath(        int matrix[][],        int i, int j,        boolean visited[][])    {         // Checking the boundaries, walls and        // whether the cell is unvisited        if (            isSafe(i, j, matrix)            && matrix[i][j] != 0            && !visited[i][j]) {            // Make the cell visited            visited[i][j] = true;             // if the cell is the required            // destination then return true            if (matrix[i][j] == 2)                return true;             // traverse up            boolean up = isPath(                matrix, i - 1,                j, visited);             // if path is found in up            // direction return true            if (up)                return true;             // traverse left            boolean left                = isPath(                    matrix, i, j - 1, visited);             // if path is found in left            // direction return true            if (left)                return true;             // traverse down            boolean down = isPath(                matrix, i + 1, j, visited);             // if path is found in down            // direction return true            if (down)                return true;             // traverse right            boolean right                = isPath(                    matrix, i, j + 1,                    visited);             // if path is found in right            // direction return true            if (right)                return true;        }        // no path has been found        return false;    }     // driver program to    // check above function    public static void main(String[] args)    {         int matrix[][] = { { 0, 3, 0, 1 },                           { 3, 0, 3, 3 },                           { 2, 3, 3, 3 },                           { 0, 3, 3, 3 } };         // calling isPath method        isPath(matrix, 4);    }} /* This code is contributed by Madhu Priya */
# Python3 program to find# path between two cell in matrix # Method for finding and printing# whether the path exists or notdef isPath(matrix, n):     # Defining visited array to keep    # track of already visited indexes    visited = [[False for x in range (n)]                      for y in range (n)]        # Flag to indicate whether the    # path exists or not    flag = False     for i in range (n):        for j in range (n):                       # If matrix[i][j] is source            # and it is not visited            if (matrix[i][j] == 1 and not                visited[i][j]):                 # Starting from i, j and                # then finding the path                if (checkPath(matrix, i,                              j, visited)):                                       # If path exists                    flag = True                    break    if (flag):        print("YES")    else:        print("NO") # Method for checking boundariesdef isSafe(i, j, matrix):       if (i >= 0 and i < len(matrix) and        j >= 0 and j < len(matrix[0])):        return True    return False # Returns true if there is a# path from a source(a# cell with value 1) to a# destination(a cell with# value 2)def checkPath(matrix, i, j,              visited):     # Checking the boundaries, walls and    # whether the cell is unvisited    if (isSafe(i, j, matrix) and        matrix[i][j] != 0 and not        visited[i][j]):               # Make the cell visited        visited[i][j] = True         # If the cell is the required        # destination then return true        if (matrix[i][j] == 2):           return True         # traverse up        up = checkPath(matrix, i - 1,                       j, visited)         # If path is found in up        # direction return true        if (up):           return True         # Traverse left        left = checkPath(matrix, i,                         j - 1, visited)         # If path is found in left        # direction return true        if (left):           return True         # Traverse down        down = checkPath(matrix, i + 1,                         j, visited)         # If path is found in down        # direction return true        if (down):           return True         # Traverse right        right = checkPath(matrix, i,                          j + 1, visited)         # If path is found in right        # direction return true        if (right):           return True         # No path has been found    return False # Driver codeif __name__ == "__main__":       matrix = [[0, 3, 0, 1],              [3, 0, 3, 3],              [2, 3, 3, 3],              [0, 3, 3, 3]]     # calling isPath method    isPath(matrix, 4) # This code is contributed by Chitranayal
// C# program to find path between two// cell in matrixusing System; class GFG{ // Method for finding and printing// whether the path exists or notstatic void isPath(int[,] matrix, int n){         // Defining visited array to keep    // track of already visited indexes    bool[,] visited = new bool[n, n];         // Flag to indicate whether the    // path exists or not    bool flag = false;     for(int i = 0; i < n; i++)    {        for(int j = 0; j < n; j++)        {                         // If matrix[i][j] is source            // and it is not visited            if (matrix[i, j] == 1 &&              !visited[i, j])                               // Starting from i, j and                // then finding the path                if (isPath(matrix, i, j,                           visited))                {                                         // If path exists                    flag = true;                    break;                }        }    }    if (flag)        Console.WriteLine("YES");    else        Console.WriteLine("NO");} // Method for checking boundariespublic static bool isSafe(int i, int j,                          int[,] matrix){    if (i >= 0 && i < matrix.GetLength(0) &&        j >= 0 && j < matrix.GetLength(1))        return true;             return false;} // Returns true if there is a path from// a source (a cell with value 1) to a// destination (a cell with value 2)public static bool isPath(int[,] matrix, int i,                          int j, bool[,] visited){         // Checking the boundaries, walls and    // whether the cell is unvisited    if (isSafe(i, j, matrix) &&           matrix[i, j] != 0 &&         !visited[i, j])    {                 // Make the cell visited        visited[i, j] = true;         // If the cell is the required        // destination then return true        if (matrix[i, j] == 2)            return true;         // Traverse up        bool up = isPath(matrix, i - 1,                         j, visited);         // If path is found in up        // direction return true        if (up)            return true;         // Traverse left        bool left = isPath(matrix, i,                           j - 1, visited);         // If path is found in left        // direction return true        if (left)            return true;         // Traverse down        bool down = isPath(matrix, i + 1,                           j, visited);         // If path is found in down        // direction return true        if (down)            return true;         // Traverse right        bool right = isPath(matrix, i, j + 1,                            visited);         // If path is found in right        // direction return true        if (right)            return true;    }         // No path has been found    return false;} // Driver code  static void Main(){    int[,] matrix = { { 0, 3, 0, 1 },                      { 3, 0, 3, 3 },                      { 2, 3, 3, 3 },                      { 0, 3, 3, 3 } };     // Calling isPath method    isPath(matrix, 4);}} // This code is contributed by divyeshrabadiya07
<script> // JavaScript program to find path between two// cell in matrix     // Method for finding and printing    // whether the path exists or notfunction isPath(matrix,n){         // Defining visited array to keep        // track of already visited indexes        let visited = new Array(n);            for(let i=0;i<n;i++)            {                visited[i]=new Array(n);                for(let j=0;j<n;j++)                {                    visited[i][j]=false;                }            }          // Flag to indicate whether the        // path exists or not        let flag = false;          for (let i = 0; i < n; i++) {            for (let j = 0; j < n; j++) {                // if matrix[i][j] is source                // and it is not visited                if (                    matrix[i][j] == 1                    && !visited[i][j])                      // Starting from i, j and                    // then finding the path                    if (checkPath(                            matrix, i, j, visited)) {                        // if path exists                        flag = true;                        break;                    }            }        }        if (flag)            document.write("YES<br>");        else            document.write("NO<br>");} // Method for checking boundariesfunction isSafe(i,j,matrix){    if (            i >= 0 && i < matrix.length            && j >= 0            && j < matrix[0].length)            return true;        return false;} // Returns true if there is a    // path from a source (a    // cell with value 1) to a    // destination (a cell with    // value 2)function checkPath(matrix,i,j,visited){    // Checking the boundaries, walls and        // whether the cell is unvisited        if (            isSafe(i, j, matrix)            && matrix[i][j] != 0            && !visited[i][j]) {            // Make the cell visited            visited[i][j] = true;              // if the cell is the required            // destination then return true            if (matrix[i][j] == 2)                return true;              // traverse up            let up = checkPath(                matrix, i - 1,                j, visited);              // if path is found in up            // direction return true            if (up)                return true;              // traverse left            let left                = checkPath(                    matrix, i, j - 1, visited);              // if path is found in left            // direction return true            if (left)                return true;              // traverse down            let down = checkPath(                matrix, i + 1, j, visited);              // if path is found in down            // direction return true            if (down)                return true;              // traverse right            let right                = checkPath(                    matrix, i, j + 1,                    visited);              // if path is found in right            // direction return true            if (right)                return true;        }        // no path has been found        return false;} // driver program to// check above functionlet matrix= [[ 0, 3, 0, 1 ],             [ 3, 0, 3, 3 ],             [ 2, 3, 3, 3 ],             [ 0, 3, 3, 3 ]];          // calling isPath method        isPath(matrix, 4); // This code is contributed by ab2127 </script>
YES
Complexity Analysis:  
Time Complexity: O(n*m), In the worst case, we have to visit each cell only one time because we keep the visited array for not visiting the already visited cell.
Space Complexity: O(n*m), Space is required to store the visited array.
Efficient solution: Graph.Approach: The idea is to use Breadth-First Search. Consider each cell as a node and each boundary between any two adjacent cells be an edge. so the total number of Node is N * N. So the idea is to do a breadth-first search from the starting cell till the ending cell is found.
Algorithm:  
Create an empty Graph having N*N node(Vertex), push all nodes into a graph, and note down the source and sink vertex.Now apply BFS on the graph, create a queue and insert the source node in the queueRun a loop till the size of the queue is greater than 0Remove the front node of the queue and check if the node is the destination if the destination returns true. mark the nodeCheck all adjacent cells if unvisited and blank insert them in the queue.If the destination is not reached return true.
Create an empty Graph having N*N node(Vertex), push all nodes into a graph, and note down the source and sink vertex.
Now apply BFS on the graph, create a queue and insert the source node in the queue
Run a loop till the size of the queue is greater than 0
Remove the front node of the queue and check if the node is the destination if the destination returns true. mark the node
Check all adjacent cells if unvisited and blank insert them in the queue.
If the destination is not reached return true.
C++
Java
Python3
Javascript
// C++ program to find path// between two cell in matrix#include <bits/stdc++.h>using namespace std;#define N 4 class Graph {    int V;    list<int>* adj; public:    Graph(int V)    {        this->V = V;        adj = new list<int>[V];    }    void addEdge(int s, int d);    bool BFS(int s, int d);}; // add edge to graphvoid Graph::addEdge(int s, int d){    adj[s].push_back(d);} // BFS function to find path// from source to sinkbool Graph::BFS(int s, int d){    // Base case    if (s == d)        return true;     // Mark all the vertices as not visited    bool* visited = new bool[V];    for (int i = 0; i < V; i++)        visited[i] = false;     // Create a queue for BFS    list<int> queue;     // Mark the current node as visited and    // enqueue it    visited[s] = true;    queue.push_back(s);     // it will be used to get all adjacent    // vertices of a vertex    list<int>::iterator i;     while (!queue.empty()) {        // Dequeue a vertex from queue        s = queue.front();        queue.pop_front();         // Get all adjacent vertices of the        // dequeued vertex s. If a adjacent has        // not been visited, then mark it visited        // and enqueue it        for (            i = adj[s].begin(); i != adj[s].end(); ++i) {            // If this adjacent node is the            // destination node, then return true            if (*i == d)                return true;             // Else, continue to do BFS            if (!visited[*i]) {                visited[*i] = true;                queue.push_back(*i);            }        }    }     // If BFS is complete without visiting d    return false;} bool isSafe(int i, int j, int M[][N]){    if (        (i < 0 || i >= N)        || (j < 0 || j >= N)        || M[i][j] == 0)        return false;    return true;} // Returns true if there is// a path from a source (a// cell with value 1) to a// destination (a cell with// value 2)bool findPath(int M[][N]){    // source and destination    int s, d;    int V = N * N + 2;    Graph g(V);     // create graph with n*n node    // each cell consider as node    // Number of current vertex    int k = 1;    for (int i = 0; i < N; i++) {        for (int j = 0; j < N; j++) {            if (M[i][j] != 0) {                // connect all 4 adjacent                // cell to current cell                if (isSafe(i, j + 1, M))                    g.addEdge(k, k + 1);                if (isSafe(i, j - 1, M))                    g.addEdge(k, k - 1);                if (i < N - 1 && isSafe(i + 1, j, M))                    g.addEdge(k, k + N);                if (i > 0 && isSafe(i - 1, j, M))                    g.addEdge(k, k - N);            }             // Source index            if (M[i][j] == 1)                s = k;             // Destination index            if (M[i][j] == 2)                d = k;            k++;        }    }     // find path Using BFS    return g.BFS(s, d);} // driver program to check// above functionint main(){    int M[N][N] = { { 0, 3, 0, 1 },                    { 3, 0, 3, 3 },                    { 2, 3, 3, 3 },                    { 0, 3, 3, 3 } };     (findPath(M) == true) ? cout << "Yes" : cout << "No" << endl;     return 0;}
// Java program to find path between two// cell in matriximport java.util.*; class Graph {    int V;    List<List<Integer> > adj;     Graph(int V)    {        this.V = V;        adj = new ArrayList<>(V);        for (int i = 0; i < V; i++) {            adj.add(i, new ArrayList<>());        }    }     // add edge to graph    void addEdge(int s, int d)    {        adj.get(s).add(d);    }     // BFS function to find path    // from source to sink    boolean BFS(int s, int d)    {        // Base case        if (s == d)            return true;         // Mark all the vertices as not visited        boolean[] visited = new boolean[V];         // Create a queue for BFS        Queue<Integer> queue            = new LinkedList<>();         // Mark the current node as visited and        // enqueue it        visited[s] = true;        queue.offer(s);         // it will be used to get all adjacent        // vertices of a vertex        List<Integer> edges;         while (!queue.isEmpty()) {            // Dequeue a vertex from queue            s = queue.poll();             // Get all adjacent vertices of the            // dequeued vertex s. If a adjacent has            // not been visited, then mark it visited            // and enqueue it            edges = adj.get(s);            for (int curr : edges) {                // If this adjacent node is the                // destination node, then return true                if (curr == d)                    return true;                 // Else, continue to do BFS                if (!visited[curr]) {                    visited[curr] = true;                    queue.offer(curr);                }            }        }         // If BFS is complete without visiting d        return false;    }     static boolean isSafe(        int i, int j, int[][] M)    {        int N = M.length;        if (            (i < 0 || i >= N)            || (j < 0 || j >= N)            || M[i][j] == 0)            return false;        return true;    }     // Returns true if there is a    // path from a source (a    // cell with value 1) to a    // destination (a cell with    // value 2)    static boolean findPath(int[][] M)    {        // Source and destination        int s = -1, d = -1;        int N = M.length;        int V = N * N + 2;        Graph g = new Graph(V);         // Create graph with n*n node        // each cell consider as node        int k = 1; // Number of current vertex        for (int i = 0; i < N; i++) {            for (int j = 0; j < N; j++) {                if (M[i][j] != 0) {                     // connect all 4 adjacent                    // cell to current cell                    if (isSafe(i, j + 1, M))                        g.addEdge(k, k + 1);                    if (isSafe(i, j - 1, M))                        g.addEdge(k, k - 1);                    if (i < N - 1                        && isSafe(i + 1, j, M))                        g.addEdge(k, k + N);                    if (i > 0 && isSafe(i - 1, j, M))                        g.addEdge(k, k - N);                }                 // source index                if (M[i][j] == 1)                    s = k;                 // destination index                if (M[i][j] == 2)                    d = k;                k++;            }        }         // find path Using BFS        return g.BFS(s, d);    }     // Driver program to check above function    public static void main(        String[] args) throws Exception    {        int[][] M = { { 0, 3, 0, 1 },                      { 3, 0, 3, 3 },                      { 2, 3, 3, 3 },                      { 0, 3, 3, 3 } };         System.out.println(            ((findPath(M)) ? "Yes" : "No"));    }} // This code is contributed by abhay379201
# Python3 program to find path between two# cell in matrixfrom collections import defaultdictclass Graph:    def __init__(self):        self.graph = defaultdict(list)         # add edge to graph    def addEdge(self, u, v):        self.graph[u].append(v)     # BFS function to find path from source to sink        def BFS(self, s, d):                 # Base case        if s == d:            return True                     # Mark all the vertices as not visited        visited = [False]*(len(self.graph) + 1)         # Create a queue for BFS        queue = []        queue.append(s)         # Mark the current node as visited and        # enqueue it        visited[s] = True        while(queue):             # Dequeue a vertex from queue            s = queue.pop(0)             # Get all adjacent vertices of the            # dequeued vertex s. If a adjacent has            # not been visited, then mark it visited            # and enqueue it            for i in self.graph[s]:                                 # If this adjacent node is the destination                # node, then return true                if i == d:                    return True                 # Else, continue to do BFS                if visited[i] == False:                    queue.append(i)                    visited[i] = True         # If BFS is complete without visiting d        return False def isSafe(i, j, matrix):    if i >= 0 and i <= len(matrix) and j >= 0 and j <= len(matrix[0]):        return True    else:        return False # Returns true if there is a path from a source (a# cell with value 1) to a destination (a cell with# value 2)def findPath(M):    s, d = None, None # source and destination    N = len(M)    g = Graph()     # create graph with n * n node    # each cell consider as node    k = 1 # Number of current vertex    for i in range(N):        for j in range(N):            if (M[i][j] != 0):                 # connect all 4 adjacent cell to                # current cell                if (isSafe(i, j + 1, M)):                    g.addEdge(k, k + 1)                if (isSafe(i, j - 1, M)):                    g.addEdge(k, k - 1)                if (isSafe(i + 1, j, M)):                    g.addEdge(k, k + N)                if (isSafe(i - 1, j, M)):                    g.addEdge(k, k - N)                         if (M[i][j] == 1):                s = k             # destination index                if (M[i][j] == 2):                d = k            k += 1     # find path Using BFS    return g.BFS(s, d) # Driver codeif __name__=='__main__':    M =[[0, 3, 0, 1], [3, 0, 3, 3], [2, 3, 3, 3], [0, 3, 3, 3]]    if findPath(M):        print("Yes")    else:        print("No") # This Code is Contributed by Vikash Kumar 37
<script> // JavaScript program to find path between two// cell in matrix let V;let adj=[]; function Graph(v){    V=v;    for (let i = 0; i < V; i++)    {        adj.push([]);    }} // add edge to graphfunction addEdge(s,d){    adj[s].push(d);} // BFS function to find path    // from source to sinkfunction  BFS(s,d){    // Base case        if (s == d)            return true;          // Mark all the vertices as not visited        let visited = new Array(V);        for(let i=0;i<V;i++)        {            visited[i]=false;        }          // Create a queue for BFS        let queue=[];          // Mark the current node as visited and        // enqueue it        visited[s] = true;        queue.push(s);          // it will be used to get all adjacent        // vertices of a vertex        let edges;          while (queue.length!=0) {            // Dequeue a vertex from queue            s = queue.shift();              // Get all adjacent vertices of the            // dequeued vertex s. If a adjacent has            // not been visited, then mark it visited            // and enqueue it            edges = adj[s];            for (let curr=0;curr< edges.length;curr++) {                // If this adjacent node is the                // destination node, then return true                if (edges[curr] == d)                    return true;                  // Else, continue to do BFS                if (!visited[edges[curr]]) {                    visited[edges[curr]] = true;                    queue.push(edges[curr]);                }            }        }          // If BFS is complete without visiting d        return false;} function isSafe(i,j,M){    let N = M.length;        if (            (i < 0 || i >= N)            || (j < 0 || j >= N)            || M[i][j] == 0)            return false;        return true;} // Returns true if there is a    // path from a source (a    // cell with value 1) to a    // destination (a cell with    // value 2)function findPath(M){    // Source and destination        let s = -1, d = -1;        let N = M.length;        let V = N * N + 2;        Graph(V);          // Create graph with n*n node        // each cell consider as node        let k = 1; // Number of current vertex        for (let i = 0; i < N; i++) {            for (let j = 0; j < N; j++) {                if (M[i][j] != 0) {                      // connect all 4 adjacent                    // cell to current cell                    if (isSafe(i, j + 1, M))                        addEdge(k, k + 1);                    if (isSafe(i, j - 1, M))                        addEdge(k, k - 1);                    if (i < N - 1                        && isSafe(i + 1, j, M))                        addEdge(k, k + N);                    if (i > 0 && isSafe(i - 1, j, M))                        addEdge(k, k - N);                }                  // source index                if (M[i][j] == 1)                    s = k;                  // destination index                if (M[i][j] == 2)                    d = k;                k++;            }        }          // find path Using BFS        return BFS(s, d);}  // Driver program to check above functionlet M = [[ 0, 3, 0, 1 ],                      [ 3, 0, 3, 3 ],                      [ 2, 3, 3, 3 ],                      [ 0, 3, 3, 3 ]];document.write(((findPath(M)) ? "Yes" : "No"));  // This code is contributed by patel2127 </script>
Yes
Complexity Analysis:  
Time Complexity: O(n*m). Every cell of the matrix is visited only once so the time complexity is O(n*m).
Space Complexity: O(n*m). Space is required to store the visited array and to create the queue.
Simple and Efficient solution: The graph is the matrix in itself.
Approach: The idea is to use Breadth-First Search on the matrix itself.
Consider a cell=(i,j) as a vertex v in the BFS queue. A new vertex u is placed in the BFS queue if u=(i+1,j) or u=(i-1,j) or u=(i,j+1) or u=(i,j-1). Starting the BFS algorithm from cell=(i,j) such that M[i][j] is 1 and stopping either if there was a reachable vertex u=(i,j) such that M[i][j] is 2 and returning true or every cell was covered and there was no such a cell and returning false.
Algorithm:  
1) Create BFS queue q
2) scan the matrix, if there exists a cell in the matrix such that its value is 1 then push it to q
3) run BFS algorithm with q, skipping cells which are not valid. i.e: they are walls (value is 0) or outside the matrix bounds and marking them as walls upon successful visitation.
   3.1) if in the BFS algorithm process there was a vertex x=(i,j) such that M[i][j] is 2 stop and return true
4) BFS algorithm terminated without returning true then there was no element M[i][j] which is 2, then return false
C++
Java
Python3
C#
Javascript
#include <iostream>#include <queue>using namespace std;#define R 4#define C 4 // Structure to define a vertex u=(i,j)typedef struct BFSElement {    BFSElement(int i, int j)    {        this->i = i;        this->j = j;    }    int i;    int j;} BFSElement; bool findPath(int M[R][C]){    // 1) Create BFS queue q    queue<BFSElement> q;     // 2)scan the matrix    for (int i = 0; i < R; ++i) {        for (int j = 0; j < C; ++j) {                       // if there exists a cell in the matrix such            // that its value is 1 then push it to q            if (M[i][j] == 1) {                q.push(BFSElement(i, j));                break;            }        }    }       // 3) run BFS algorithm with q.    while (!q.empty()) {        BFSElement x = q.front();        q.pop();        int i = x.i;        int j = x.j;               // skipping cells which are not valid.        // if outside the matrix bounds        if (i < 0 || i > R || j < 0 || j > C)            continue;               // if they are walls (value is 0).        if (M[i][j] == 0)            continue;         // 3.1) if in the BFS algorithm process there was a        // vertex x=(i,j) such that M[i][j] is 2 stop and        // return true        if (M[i][j] == 2)            return true;               // marking as wall upon successful visitation        M[i][j] = 0;         // pushing to queue u=(i,j+1),u=(i,j-1)        //                 u=(i+1,j),u=(i-1,j)        for (int k = -1; k <= 1; k += 2) {            q.push(BFSElement(i + k, j));            q.push(BFSElement(i, j + k));        }    }       // BFS algorithm terminated without returning true    // then there was no element M[i][j] which is 2, then    // return false    return false;} // Main Driver codeint main(){     int M[R][C] = { { 0, 3, 0, 1 },                    { 3, 0, 3, 3 },                    { 2, 3, 3, 3 },                    { 0, 3, 3, 3 } };     (findPath(M) == true) ? cout << "Yes"                          : cout << "No" << endl;     return 0;}
import java.io.*;import java.util.*; class BFSElement{    int i, j;    BFSElement(int i, int j)    {        this.i = i;        this.j = j;    }} class GFG {    static int R = 4, C = 4;    BFSElement b;         static boolean findPath(int M[][])    {               // 1) Create BFS queue q        Queue<BFSElement> q = new LinkedList<>();               // 2)scan the matrix        for (int i = 0; i < R; ++i)        {            for (int j = 0; j < C; ++j)            {                                // if there exists a cell in the matrix such                // that its value is 1 then push it to q                if (M[i][j] == 1) {                    q.add(new BFSElement(i, j));                    break;                }            }                 }             // 3) run BFS algorithm with q.        while (q.size() != 0)        {            BFSElement x = q.peek();            q.remove();            int i = x.i;            int j = x.j;                       // skipping cells which are not valid.            // if outside the matrix bounds            if (i < 0 || i >= R || j < 0 || j >= C)                continue;                        // if they are walls (value is 0).            if (M[i][j] == 0)                continue;                  // 3.1) if in the BFS algorithm process there was a            // vertex x=(i,j) such that M[i][j] is 2 stop and            // return true            if (M[i][j] == 2)                return true;                        // marking as wall upon successful visitation            M[i][j] = 0;                  // pushing to queue u=(i,j+1),u=(i,j-1)            // u=(i+1,j),u=(i-1,j)            for (int k = -1; k <= 1; k += 2)            {                q.add(new BFSElement(i + k, j));                q.add(new BFSElement(i, j + k));            }        }                     // BFS algorithm terminated without returning true        // then there was no element M[i][j] which is 2, then        // return false        return false;         }       // Main Driver code    public static void main (String[] args)    {        int M[][] = { { 0, 3, 0, 1 },                    { 3, 0, 3, 3 },                    { 2, 3, 3, 3 },                    { 0, 3, 3, 3 } };                 if(findPath(M) == true)            System.out.println("Yes");        else            System.out.println("No");         }} // This code is contributed by avanitrachhadiya2155
class BFSElement:    def __init__(self, i, j):        self.i = i        self.j = j R,C = 4,4 def findPath(M):     # 1) Create BFS queue q    q = []             # 2)scan the matrix    for i in range(R):        for j in range(C):                         # if there exists a cell in the matrix such            # that its value is 1 then append it to q            if (M[i][j] == 1):                q.append(BFSElement(i, j))                break             # 3) run BFS algorithm with q.    while (len(q) != 0):        x = q[0]        q = q[1:]                     i = x.i        j = x.j                     # skipping cells which are not valid.        # if outside the matrix bounds        if (i < 0 or i >= R or j < 0 or j >= C):            continue                     # if they are walls (value is 0).        if (M[i][j] == 0):            continue             # 3.1) if in the BFS algorithm process there was a        # vertex x=(i,j) such that M[i][j] is 2 stop and        # return True        if (M[i][j] == 2):            return True                     # marking as wall upon successful visitation        M[i][j] = 0             # appending to queue u=(i,j+1),u=(i,j-1)        # u=(i+1,j),u=(i-1,j)        for k in range(-1, 2, 2):            q.append(BFSElement(i + k, j))            q.append(BFSElement(i, j + k))         # BFS algorithm terminated without returning True    # then there was no element M[i][j] which is 2, then    # return false    return False # Main Driver codeM = [[ 0, 3, 0, 1 ],    [ 3, 0, 3, 3 ],    [ 2, 3, 3, 3 ],    [ 0, 3, 3, 3 ]]if(findPath(M) == True):    print("Yes")else:    print("No") # This code is contributed by shinjanpatra
using System;using System.Collections.Generic; public class BFSElement{  public int i, j;  public BFSElement(int i, int j)  {    this.i = i;    this.j = j;  }} public class GFG{     static int R = 4, C = 4;    static bool findPath(int[,] M)  {     // 1) Create BFS queue q    Queue<BFSElement> q = new Queue<BFSElement>();     // 2)scan the matrix    for (int i = 0; i < R; ++i)    {      for (int j = 0; j < C; ++j)      {         // if there exists a cell in the matrix such        // that its value is 1 then push it to q        if (M[i, j] == 1) {          q.Enqueue(new BFSElement(i, j));          break;        }      }     }     // 3) run BFS algorithm with q.    while (q.Count != 0)    {      BFSElement x = q.Peek();      q.Dequeue();      int i = x.i;      int j = x.j;       // skipping cells which are not valid.      // if outside the matrix bounds      if (i < 0 || i >= R || j < 0 || j >= C)        continue;       // if they are walls (value is 0).      if (M[i, j] == 0)        continue;       // 3.1) if in the BFS algorithm process there was a      // vertex x=(i,j) such that M[i][j] is 2 stop and      // return true      if (M[i, j] == 2)        return true;       // marking as wall upon successful visitation      M[i, j] = 0;       // pushing to queue u=(i,j+1),u=(i,j-1)      // u=(i+1,j),u=(i-1,j)      for (int k = -1; k <= 1; k += 2)      {        q.Enqueue(new BFSElement(i + k, j));        q.Enqueue(new BFSElement(i, j + k));      }    }     // BFS algorithm terminated without returning true    // then there was no element M[i][j] which is 2, then    // return false    return false;   }   // Main Driver code  static public void Main (){    int[,] M = { { 0, 3, 0, 1 },                { 3, 0, 3, 3 },                { 2, 3, 3, 3 },                { 0, 3, 3, 3 } };     if(findPath(M) == true)      Console.WriteLine("Yes");    else      Console.WriteLine("No");    }} // This code is contributed by rag2127
<script> class BFSElement{    constructor(i,j)    {        this.i=i;        this.j=j;    }} let R = 4, C = 4;let  b; function findPath(M){    // 1) Create BFS queue q        let q = [];             // 2)scan the matrix        for (let i = 0; i < R; ++i)        {            for (let j = 0; j < C; ++j)            {                                 // if there exists a cell in the matrix such                // that its value is 1 then push it to q                if (M[i][j] == 1) {                    q.push(new BFSElement(i, j));                    break;                }            }                  }          // 3) run BFS algorithm with q.        while (q.length != 0)        {            let x = q.shift();                         let i = x.i;            let j = x.j;                        // skipping cells which are not valid.            // if outside the matrix bounds            if (i < 0 || i >= R || j < 0 || j >= C)                continue;                         // if they are walls (value is 0).            if (M[i][j] == 0)                continue;                   // 3.1) if in the BFS algorithm process there was a            // vertex x=(i,j) such that M[i][j] is 2 stop and            // return true            if (M[i][j] == 2)                return true;                         // marking as wall upon successful visitation            M[i][j] = 0;                   // pushing to queue u=(i,j+1),u=(i,j-1)            // u=(i+1,j),u=(i-1,j)            for (let k = -1; k <= 1; k += 2)            {                q.push(new BFSElement(i + k, j));                q.push(new BFSElement(i, j + k));            }        }                  // BFS algorithm terminated without returning true    // then there was no element M[i][j] which is 2, then    // return false        return false;} // Main Driver codelet M=[[ 0, 3, 0, 1 ],                    [ 3, 0, 3, 3 ],                    [ 2, 3, 3, 3 ],                    [ 0, 3, 3, 3 ]];if(findPath(M) == true)    document.write("Yes");else    document.write("No");  // This code is contributed by unknown2108</script>
Yes
Time Complexity:  O(n*m).
Space Complexity: O(n*m).
The improvement is contributed by Ephi F.
This article is contributed by Nishant Singh. 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.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
madhu priya
Vikash Kumar 37
RambhagwanPrajapat
abhay379201
andrew1234
vashisthamadhur2
ukasp
divyeshrabadiya07
ephi2g
sudhanshugupta2019a
avanitrachhadiya2155
rag2127
simranarora5sos
ab2127
patel2127
unknown2108
shinjanpatra
ayushak969
Adobe
Amazon
BFS
Morgan Stanley
Graph
Matrix
Morgan Stanley
Amazon
Adobe
Matrix
Graph
BFS
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.