Skip to content
Related Articles
Open in App
Not now

Related Articles

Distance of nearest cell having 1 in a binary matrix

Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 27 Jan, 2023
Improve Article
Save Article

Given a binary matrix of N x M, containing at least a value 1. The task is to find the distance of the nearest 1 in the matrix for each cell. The distance is calculated as |i1 – i2| + |j1 – j2|, where i1, j1 are the row number and column number of the current cell, and i2, j2 are the row number and column number of the nearest cell having value 1

Examples: 

Input: N = 3, M = 4
mat[][] = { {0, 0, 0, 1}, {0, 0, 1, 1}, {0, 1, 1, 0} }
Output: 
3 2 1 0
2 1 0 0
1 0 0 1
Explanation: For cell at (0, 0), nearest 1 is at (0, 3).
So distance = (0 – 0) + (3 – 0) = 3.
Similarly, all the distance can be calculated

Input: N = 3, M = 3
mat[][] = { {1, 0, 0}, {0, 0, 1}, {0, 1, 1} }
Output:  
0 1 1
1 1 0
1 0 0 
Explanation:  For cell at (0, 1), nearest 1 is at (0, 0). 
So distance is 1. Similarly, all the distance can be calculated.

Naive Approach: To solve the problem follow the below idea:

The idea is to traverse the matrix for each cell and find the minimum distance, To find the minimum distance traverse the matrix and find the cell which contains 1 and calculate the distance between two cells and store the minimum distance

Follow the given steps to solve the problem:

  • Traverse the matrix from start to end (using two nested loops)
  • For every element find the closest element which contains 1. 
    • To find the closest element traverse the matrix and find the minimum distance
    • Fill the minimum distance in the matrix.
  • Return the matrix filled with the distance values as the required answer.

Below is the implementation of the above approach:

C++




// C++ program to find distance of nearest
// cell having 1 in a binary matrix.
#include <bits/stdc++.h>
#define N 3
#define M 4
using namespace std;
 
// Print the distance of nearest cell
// having 1 for each cell.
void printDistance(int mat[N][M])
{
    int ans[N][M];
 
    // Initialize the answer matrix with INT_MAX.
    for (int i = 0; i < N; i++)
        for (int j = 0; j < M; j++)
            ans[i][j] = INT_MAX;
 
    // For each cell
    for (int i = 0; i < N; i++)
        for (int j = 0; j < M; j++) {
            // Traversing the whole matrix
            // to find the minimum distance.
            for (int k = 0; k < N; k++)
                for (int l = 0; l < M; l++) {
                    // If cell contain 1, check
                    // for minimum distance.
                    if (mat[k][l] == 1)
                        ans[i][j]
                            = min(ans[i][j],
                                  abs(i - k) + abs(j - l));
                }
        }
 
    // Printing the answer.
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++)
            cout << ans[i][j] << " ";
 
        cout << endl;
    }
}
 
// Driver code
int main()
{
    int mat[N][M] = { 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0 };
 
      // Function call
    printDistance(mat);
 
    return 0;
}


Java




// Java program to find distance of nearest
// cell having 1 in a binary matrix.
 
import java.io.*;
 
class GFG {
 
    static int N = 3;
    static int M = 4;
 
    // Print the distance of nearest cell
    // having 1 for each cell.
    static void printDistance(int mat[][])
    {
        int ans[][] = new int[N][M];
 
        // Initialize the answer matrix with INT_MAX.
        for (int i = 0; i < N; i++)
            for (int j = 0; j < M; j++)
                ans[i][j] = Integer.MAX_VALUE;
 
        // For each cell
        for (int i = 0; i < N; i++)
            for (int j = 0; j < M; j++) {
                // Traversing the whole matrix
                // to find the minimum distance.
                for (int k = 0; k < N; k++)
                    for (int l = 0; l < M; l++) {
                        // If cell contain 1, check
                        // for minimum distance.
                        if (mat[k][l] == 1)
                            ans[i][j] = Math.min(
                                ans[i][j],
                                Math.abs(i - k)
                                    + Math.abs(j - l));
                    }
            }
 
        // Printing the answer.
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++)
                System.out.print(ans[i][j] + " ");
 
            System.out.println();
        }
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int mat[][] = { { 0, 0, 0, 1 },
                        { 0, 0, 1, 1 },
                        { 0, 1, 1, 0 } };
 
          // Function call
        printDistance(mat);
    }
}
 
// This code is contributed by anuj_67.


Python3




# Python3 program to find distance of
# nearest cell having 1 in a binary matrix.
 
# Print distance of nearest cell
# having 1 for each cell.
 
 
def printDistance(mat):
    global N, M
    ans = [[None] * M for i in range(N)]
 
    # Initialize the answer matrix
    # with INT_MAX.
    for i in range(N):
        for j in range(M):
            ans[i][j] = 999999999999
 
    # For each cell
    for i in range(N):
        for j in range(M):
 
            # Traversing the whole matrix
            # to find the minimum distance.
            for k in range(N):
                for l in range(M):
 
                    # If cell contain 1, check
                    # for minimum distance.
                    if (mat[k][l] == 1):
                        ans[i][j] = min(ans[i][j],
                                        abs(i - k) + abs(j - l))
 
    # Printing the answer.
    for i in range(N):
        for j in range(M):
            print(ans[i][j], end=" ")
        print()
 
 
# Driver Code
if __name__ == '__main__':
  N = 3
  M = 4
  mat = [[0, 0, 0, 1],
         [0, 0, 1, 1],
         [0, 1, 1, 0]]
 
  # Function call
  printDistance(mat)
 
# This code is contributed by PranchalK


C#




// C# program to find the distance of nearest
// cell having 1 in a binary matrix.
 
using System;
 
class GFG {
 
    static int N = 3;
    static int M = 4;
 
    // Print the distance of nearest cell
    // having 1 for each cell.
    static void printDistance(int[, ] mat)
    {
        int[, ] ans = new int[N, M];
 
        // Initialise the answer matrix with int.MaxValue.
        for (int i = 0; i < N; i++)
            for (int j = 0; j < M; j++)
                ans[i, j] = int.MaxValue;
 
        // For each cell
        for (int i = 0; i < N; i++)
            for (int j = 0; j < M; j++) {
                // Traversing thewhole matrix
                // to find the minimum distance.
                for (int k = 0; k < N; k++)
                    for (int l = 0; l < M; l++) {
                        // If cell contain 1, check
                        // for minimum distance.
                        if (mat[k, l] == 1)
                            ans[i, j] = Math.Min(
                                ans[i, j],
                                Math.Abs(i - k)
                                    + Math.Abs(j - l));
                    }
            }
 
        // Printing the answer.
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++)
                Console.Write(ans[i, j] + " ");
 
            Console.WriteLine();
        }
    }
 
    // Driver code
    public static void Main()
    {
        int[, ] mat = { { 0, 0, 0, 1 },
                        { 0, 0, 1, 1 },
                        { 0, 1, 1, 0 } };
 
          // Function call
        printDistance(mat);
    }
}
 
// This code is contributed by anuj_67.


PHP




<?php
// PHP program to find distance of nearest
// cell having 1 in a binary matrix.
$N = 3;
$M = 4;
 
// Print the distance of nearest cell
// having 1 for each cell.
function printDistance( $mat)
{
    global $N,$M;
    $ans = array(array());
 
    // Initialize the answer
    // matrix with INT_MAX.
    for($i = 0; $i < $N; $i++)
        for ( $j = 0; $j < $M; $j++)
            $ans[$i][$j] = PHP_INT_MAX;
 
    // For each cell
    for ( $i = 0; $i < $N; $i++)
        for ( $j = 0; $j < $M; $j++)
        {
             
            // Traversing the whole matrix
            // to find the minimum distance.
            for ($k = 0; $k < $N; $k++)
                for ( $l = 0; $l < $M; $l++)
                {
                     
                    // If cell contain 1, check
                    // for minimum distance.
                    if ($mat[$k][$l] == 1)
                        $ans[$i][$j] = min($ans[$i][$j],
                            abs($i-$k) + abs($j - $l));
                }
        }
 
    // Printing the answer.
    for ( $i = 0; $i < $N; $i++)
    {
        for ( $j = 0; $j < $M; $j++)
            echo $ans[$i][$j] , " ";
 
    echo "\n";
    }
}
 
    // Driver Code
    $mat = array(array(0, 0, 0, 1),
                 array(0, 0, 1, 1),
                 array(0, 1, 1, 0));
 
    // Function call
    printDistance($mat);
 
// This code is contributed by anuj_67.
?>


Javascript




<script>
// Javascript program to find distance of nearest
// cell having 1 in a binary matrix.
     
    let N = 3;
    let M = 4;
 
// Print the distance of nearest cell
    // having 1 for each cell.
function printDistance(mat)
{
    let ans= new Array(N);
    for(let i=0;i<N;i++)
    {
        ans[i]=new Array(M);
        for(let j = 0; j < M; j++)
        {
            ans[i][j] = Number.MAX_VALUE;
        }
    }
     
    // For each cell
        for (let i = 0; i < N; i++)
            for (let j = 0; j < M; j++)
            {
                // Traversing the whole matrix
                // to find the minimum distance.
                for (let k = 0; k < N; k++)
                    for (let l = 0; l < M; l++)
                    {
                        // If cell contain 1, check
                        // for minimum distance.
                        if (mat[k][l] == 1)
                            ans[i][j] =
                              Math.min(ans[i][j],
                                   Math.abs(i-k)
                                   + Math.abs(j-l));
                    }
            }
      
        // Printing the answer.
        for (let i = 0; i < N; i++)
        {
            for (let j = 0; j < M; j++)
                document.write( ans[i][j] + " ");
      
            document.write("<br>");
        }
     
}
 
// Driven Program
let mat = [[0, 0, 0, 1],
       [0, 0, 1, 1],
       [0, 1, 1, 0]]
printDistance(mat);
 
 
// This code is contributed by patel2127
</script>


Output

3 2 1 0 
2 1 0 0 
1 0 0 1 

Time Complexity: O(N2 * M2). For every element in the matrix, the matrix is traversed and there are N*M elements.
Auxiliary Space: O(N * M)

Distance of nearest cell having 1 in a binary matrix using the queue:

To solve the problem follow the below idea:

The idea is to load the i and j coordinates of each ‘1′ in the Matrix into a Queue and then traverse all the “0” Matrix elements and compare the distance between all the  1’s from the Queue to get a minimum distance

Follow the given steps to solve the problem:

  • Traverse once the Matrix and Load all 1’s i and j coordinates into the queue
  • Once loaded, Traverse all the Matrix elements. If the element is “0”, then check the minimum distance by de-queuing Queue elements one by one
    • Once distance for a “0” element from a “1” element is obtained, push back the 1’s coordinates back into the queue again for the next “0” element
  • Determine Min distance from the individual distances for every “0” element

Below is the implementation of the above approach:

C++




#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include  <climits>
 
using namespace std;
 
struct matrix_element
{
  int row;
  int col;
  matrix_element(int row, int col) : row(row), col(col) {}
};
 
void printDistance(vector<vector<int>> arr)
{
  int Row_Count = arr.size();
  int Col_Count = arr[0].size();
  vector<matrix_element> q;
  // Adding all ones in vector
  for (int i = 0; i < Row_Count; i++)
  {
    for (int j = 0; j < Col_Count; j++)
    {
      if (arr[i][j] == 1)
        q.emplace_back(i, j);
    }
  }
  // In order to find min distance we will again
  // traverse all elements in Matrix. If its zero then
  // it will check against all 1's in vector. Whatever
  // will be dequeued from vector, will be enqueued
  // back again.
 
  int vector_size = q.size();
  for (int i = 0; i < Row_Count; i++)
  {
    for (int j = 0; j < Col_Count; j++)
    {
      int distance = 0;
      int min_distance = INT_MAX;
      if (arr[i][j] == 0)
      {
        for (int k = 0; k < vector_size; k++)
        {
          matrix_element One_Pos = q[0];
          q.erase(q.begin());
          int One_Row = One_Pos.row;
          int One_Col = One_Pos.col;
          distance = abs(One_Row - i) + abs(One_Col - j);
          min_distance = min(min_distance, distance);
          if (min_distance == 1)
          {
            arr[i][j] = 1;
            q.emplace_back(One_Row, One_Col);
            break;
          }
          q.emplace_back(One_Row, One_Col);
        }
        arr[i][j] = min_distance;
      }
      else
      {
        arr[i][j] = 0;
      }
    }
  }
 
  // print the elements
  for (int i = 0; i < Row_Count; i++)
  {
    for (int j = 0; j < Col_Count; j++)
      cout << arr[i][j] << " ";
 
    cout << endl;
  }
}
 
int main()
{
  vector<vector<int>> arr = {{0, 0, 0, 1},
                             {0, 0, 1, 1},
                             {0, 1, 1, 0}};
 
  // Function call
  printDistance(arr);
 
  return 0;
}
 
// This code is contributed by phasing17


Java




// Java program for the above approach
 
import java.io.*;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
class GFG {
 
    static class matrix_element {
        int row;
        int col;
        matrix_element(int row, int col)
        {
            this.row = row;
            this.col = col;
        }
    }
 
    static void printDistance(int arr[][])
    {
        int Row_Count = arr.length;
        int Col_Count = arr[0].length;
        Queue<matrix_element> q
            = new LinkedList<matrix_element>();
        // Adding all ones in queue
        for (int i = 0; i < Row_Count; i++) {
            for (int j = 0; j < Col_Count; j++) {
                if (arr[i][j] == 1)
                    q.add(new matrix_element(i, j));
            }
        }
        // In order to find min distance we will again
        // traverse all elements in Matrix. If its zero then
        // it will check against all 1's in Queue. Whatever
        // will be dequeued from queued, will be enqueued
        // back again.
 
        int Queue_Size = q.size();
        for (int i = 0; i < Row_Count; i++) {
            for (int j = 0; j < Col_Count; j++) {
                int distance = 0;
                int min_distance = Integer.MAX_VALUE;
                if (arr[i][j] == 0) {
                    for (int k = 0; k < Queue_Size; k++) {
                        matrix_element One_Pos = q.poll();
                        int One_Row = One_Pos.row;
                        int One_Col = One_Pos.col;
                        distance = Math.abs(One_Row - i)
                                   + Math.abs(One_Col - j);
                        min_distance = Math.min(
                            min_distance, distance);
                        if (min_distance == 1) {
                            arr[i][j] = 1;
                            q.add(new matrix_element(
                                One_Row, One_Col));
                            break;
                        }
                        q.add(new matrix_element(One_Row,
                                                 One_Col));
                    }
                    arr[i][j] = min_distance;
                }
                else {
                    arr[i][j] = 0;
                }
            }
        }
 
        // print the elements
        for (int i = 0; i < Row_Count; i++) {
            for (int j = 0; j < Col_Count; j++)
                System.out.print(arr[i][j] + " ");
 
            System.out.println();
        }
    }
 
      // Driver code
    public static void main(String[] args)
    {
        int arr[][] = { { 0, 0, 0, 1 },
                        { 0, 0, 1, 1 },
                        { 0, 1, 1, 0 } };
 
          // Function call
        printDistance(arr);
    }
}
//// This code is contributed by prithi_raj


Python3




# Python3 program for the above approach
 
import sys
 
 
class matrix_element:
 
    def __init__(self, row, col):
        self.row = row
        self.col = col
 
 
def printDistance(arr):
    Row_Count = len(arr)
    Col_Count = len(arr[0])
 
    q = []
 
    # Adding all ones in queue
    for i in range(Row_Count):
        for j in range(Col_Count):
            if (arr[i][j] == 1):
                q.append(matrix_element(i, j))
 
    # In order to find min distance we will again
    # traverse all elements in Matrix. If its zero then
    # it will check against all 1's in Queue. Whatever
    # will be dequeued from queued, will be enqueued
    # back again.
 
    Queue_Size = len(q)
    for i in range(Row_Count):
 
        for j in range(Col_Count):
 
            distance = 0
            min_distance = sys.maxsize
 
            if (arr[i][j] == 0):
 
                for k in range(Queue_Size):
 
                    One_Pos = q[0]
                    q = q[1:]
                    One_Row = One_Pos.row
                    One_Col = One_Pos.col
                    distance = abs(One_Row - i) + abs(One_Col - j)
                    min_distance = min(min_distance, distance)
                    if (min_distance == 1):
 
                        arr[i][j] = 1
                        q.append(matrix_element(One_Row, One_Col))
                        break
 
                    q.append(matrix_element(One_Row, One_Col))
 
                    arr[i][j] = min_distance
 
            else:
                arr[i][j] = 0
 
    # print elements
    for i in range(Row_Count):
        for j in range(Col_Count):
            print(arr[i][j], end=" ")
 
        print()
 
 
# Driver code
if __name__ == '__main__':
  arr = [[0, 0, 0, 1], [0, 0, 1, 1], [0, 1, 1, 0]]
 
  # Function call
  printDistance(arr)
 
# This code is contributed by shinjanpatra


C#




// C# program for the above approach
 
using System;
using System.Collections.Generic;
 
class matrix_element {
  public int row;
  public int col;
  public matrix_element(int row, int col)
  {
    this.row = row;
    this.col = col;
  }
}
 
class GFG {
 
  static void printDistance(int[, ] arr)
  {
    int Row_Count = arr.GetLength(0);
    int Col_Count = arr.GetLength(1);
    List<matrix_element> q = new List<matrix_element>();
    // Adding all ones in List
    for (int i = 0; i < Row_Count; i++) {
      for (int j = 0; j < Col_Count; j++) {
        if (arr[i, j] == 1)
          q.Add(new matrix_element(i, j));
      }
    }
    // In order to find min distance we will again
    // traverse all elements in Matrix. If its zero then
    // it will check against all 1's in List. Whatever
    // will be deListd from Listd, will be enListd
    // back again.
 
    int List_Size = q.Count;
    for (int i = 0; i < Row_Count; i++) {
      for (int j = 0; j < Col_Count; j++) {
        int distance = 0;
        int min_distance = Int32.MaxValue;
        if (arr[i, j] == 0) {
          for (int k = 0; k < List_Size; k++) {
            matrix_element One_Pos = q[0];
            q.RemoveAt(0);
            int One_Row = One_Pos.row;
            int One_Col = One_Pos.col;
            distance = Math.Abs(One_Row - i)
              + Math.Abs(One_Col - j);
            min_distance = Math.Min(
              min_distance, distance);
            if (min_distance == 1) {
              arr[i, j] = 1;
              q.Add(new matrix_element(
                One_Row, One_Col));
              break;
            }
            q.Add(new matrix_element(One_Row,
                                     One_Col));
          }
          arr[i, j] = min_distance;
        }
        else {
          arr[i, j] = 0;
        }
      }
    }
 
    // print the elements
    for (int i = 0; i < Row_Count; i++) {
      for (int j = 0; j < Col_Count; j++)
        Console.Write(arr[i, j] + " ");
 
      Console.WriteLine();
    }
  }
 
  // Driver code
  public static void Main(string[] args)
  {
    int[, ] arr = { { 0, 0, 0, 1 },
                   { 0, 0, 1, 1 },
                   { 0, 1, 1, 0 } };
 
    // Function call
    printDistance(arr);
  }
}
 
//// This code is contributed by phasing17


Javascript




<script>
class matrix_element{
     
    constructor(row, col){
        this.row = row
        this.col = col
    }
 
}
         
function printDistance(arr){
    let Row_Count = arr.length
    let Col_Count = arr[0].length
         
    let q = []
 
    // Adding all ones in queue
    for(let i = 0; i < Row_Count; i++){
        for(let j = 0; j < Col_Count; j++){
            if (arr[i][j] == 1)
                q.push(new matrix_element(i, j))
        }
    }
             
    // In order to find min distance we will again
    // traverse all elements in Matrix. If its zero then
    // it will check against all 1's in Queue. Whatever
    // will be dequeued from queued, will be enqueued
    // back again.
 
    let Queue_Size = q.length
    for(let i = 0; i < Row_Count; i++)
    {
     
        for(let j = 0; j < Col_Count; j++)
        {
     
            let distance = 0
            let min_distance = Number.MAX_VALUE
             
            if (arr[i][j] == 0){
                 
                for(let k = 0; k < Queue_Size; k++)
                {
         
                    let One_Pos = q.shift()
                    let One_Row = One_Pos.row
                    let One_Col = One_Pos.col
                    distance = Math.abs(One_Row - i) + Math.abs(One_Col - j)
                    min_distance = Math.min(min_distance, distance)
                    if (min_distance == 1){
 
                        arr[i][j] = 1
                        q.push(new matrix_element(One_Row, One_Col))
                        break
                    }
                     
                    q.push(new matrix_element(One_Row,One_Col))
                     
                    arr[i][j] = min_distance
                }
            }
                 
            else
                arr[i][j] = 0
        }
    }
                                 
    // print elements
    for(let i = 0; i < Row_Count; i++)
    {
        for(let j = 0; j < Col_Count; j++)
        {
            document.write(arr[i][j] ," ")
        }
 
        document.write("</br>")
    }
}
         
// driver code
let arr = [ [ 0, 0, 0, 1 ], [ 0, 0, 1, 1 ], [ 0, 1, 1, 0 ] ]
printDistance(arr)
 
// This code is contributed by shinjanpatra
 
</script>


Output

3 2 1 0 
2 1 0 0 
1 0 0 1 

Time Complexity: O(N2 * M2)
Auxiliary Space: O(N * M)

Distance of nearest cell having 1 in a binary matrix using the BFS method:

To solve the problem follow the below idea:

The idea is to use multisource Breadth-First Search. Consider each cell as a node and each boundary between any two adjacent cells be an edge. Number each cell from 1 to N*M. Now, push all the nodes whose corresponding cell value is 1 in the matrix in the queue. Apply BFS using this queue to find the minimum distance of the adjacent node

Follow the given steps to solve the problem:

  • Create a graph with values assigned from 1 to M*N to all vertices. The purpose is to store position and adjacent information.
  • Create an empty queue.
  • Traverse all matrix elements and insert positions of all 1s in the queue.
  • Now do a BFS traversal of the graph using the above-created queue.
    • Run a loop till the size of the queue is greater than 0 then extract the front node of the queue and remove it and insert all its adjacent and unmarked elements. 
    • Update the minimum distance as the distance of the current node +1 and insert the element in the queue.
  • Return the matrix containing the distances as the required answer.

Below is the implementation of the above approach:

C++




// C++ program to find distance of nearest
// cell having 1 in a binary matrix.
#include <bits/stdc++.h>
#define MAX 500
#define N 3
#define M 4
using namespace std;
 
// Making a class of graph with bfs function.
class graph {
private:
    vector<int> g[MAX];
    int n, m;
 
public:
    graph(int a, int b)
    {
        n = a;
        m = b;
    }
 
    // Function to create graph with N*M nodes
    // considering each cell as a node and each
    // boundary as an edge.
    void createGraph()
    {
        int k = 1; // A number to be assigned to a cell
 
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                // If last row, then add edge on right side.
                if (i == n) {
                    // If not bottom right cell.
                    if (j != m) {
                        g[k].push_back(k + 1);
                        g[k + 1].push_back(k);
                    }
                }
 
                // If last column, then add edge toward
                // down.
                else if (j == m) {
                    g[k].push_back(k + m);
                    g[k + m].push_back(k);
                }
 
                // Else makes an edge in all four
                // directions.
                else {
                    g[k].push_back(k + 1);
                    g[k + 1].push_back(k);
                    g[k].push_back(k + m);
                    g[k + m].push_back(k);
                }
 
                k++;
            }
        }
    }
 
    // BFS function to find minimum distance
    void bfs(bool visit[], int dist[], queue<int> q)
    {
        while (!q.empty()) {
            int temp = q.front();
            q.pop();
 
            for (int i = 0; i < g[temp].size(); i++) {
                if (visit[g[temp][i]] != 1) {
                    dist[g[temp][i]] = min(dist[g[temp][i]],
                                           dist[temp] + 1);
 
                    q.push(g[temp][i]);
                    visit[g[temp][i]] = 1;
                }
            }
        }
    }
 
    // Printing the solution
    void print(int dist[])
    {
        for (int i = 1, c = 1; i <= n * m; i++, c++) {
            cout << dist[i] << " ";
 
            if (c % m == 0)
                cout << endl;
        }
    }
};
 
// Find minimum distance
void findMinDistance(bool mat[N][M])
{
    // Creating a graph with nodes values assigned
    // from 1 to N x M and matrix adjacent.
    graph g1(N, M);
    g1.createGraph();
 
    // To store minimum distance
    int dist[MAX];
 
    // To mark each node as visited or not in BFS
    bool visit[MAX] = { 0 };
 
    // Initialising the value of distance and visit.
    for (int i = 1; i <= M * N; i++) {
        dist[i] = INT_MAX;
        visit[i] = 0;
    }
 
    // Inserting nodes whose value in matrix
    // is 1 in the queue.
    int k = 1;
    queue<int> q;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            if (mat[i][j] == 1) {
                dist[k] = 0;
                visit[k] = 1;
                q.push(k);
            }
            k++;
        }
    }
 
    // Calling for Bfs with given Queue.
    g1.bfs(visit, dist, q);
 
    // Printing the solution.
    g1.print(dist);
}
 
// Driver code
int main()
{
    bool mat[N][M] = { 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0 };
 
      // Function call
    findMinDistance(mat);
 
    return 0;
}


Java




// Java program to find distance of nearest
// cell having 1 in a binary matrix.
import java.util.*;
 
class gfg {
 
  static int N = 3;
  static int M = 4;
  static int MAX = 500;
 
  // Making a class of graph with bfs function.
  static class graph {
 
    ArrayList<ArrayList<Integer> > g;
    int n, m;
 
    graph(int a, int b)
    {
      g = new ArrayList<>();
      n = a;
      m = b;
    }
 
    // Function to create graph with N*M nodes
    // considering each cell as a node and each
    // boundary as an edge.
    void createGraph()
    {
      int k = 1; // A number to be assigned to a cell
      for (int i = 0; i <= MAX; i++) {
        g.add(new ArrayList<>());
      }
 
      for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
          // If last row, then add edge on right
          // side.
          if (i == n) {
            // If not bottom right cell.
            if (j != m) {
              g.get(k).add(k + 1);
              g.get(k + 1).add(k);
            }
          }
 
          // If last column, then add edge toward
          // down.
          else if (j == m) {
            g.get(k).add(k + m);
            g.get(k + m).add(k);
          }
 
          // Else makes an edge in all four
          // directions.
          else {
            g.get(k).add(k + 1);
            g.get(k + 1).add(k);
            g.get(k).add(k + m);
            g.get(k + m).add(k);
          }
 
          k++;
        }
      }
    }
 
    // BFS function to find minimum distance
    void bfs(boolean visit[], int dist[],
             Queue<Integer> q)
    {
      while (!q.isEmpty()) {
        int temp = q.peek();
        q.remove();
 
        for (int i = 0; i < g.get(temp).size();
             i++) {
          if (visit[g.get(temp).get(i)] != true) {
            dist[g.get(temp).get(i)] = Math.min(
              dist[g.get(temp).get(i)],
              dist[temp] + 1);
 
            q.add(g.get(temp).get(i));
            visit[g.get(temp).get(i)] = true;
          }
        }
      }
    }
 
    // Printing the solution
    void print(int dist[])
    {
      for (int i = 1, c = 1; i <= n * m; i++, c++) {
        System.out.print(dist[i] + " ");
 
        if (c % m == 0)
          System.out.println();
      }
    }
  };
 
  // Find minimum distance
  static void findMinDistance(boolean mat[][])
  {
    // Creating a graph with nodes values assigned
    // from 1 to N x M and matrix adjacent.
    graph g1 = new graph(N, M);
    g1.createGraph();
 
    // To store minimum distance
    int dist[] = new int[MAX];
 
    // To mark each node as visited or not in BFS
    boolean visit[] = new boolean[MAX];
 
    // Initialising the value of distance and visit.
    for (int i = 1; i <= M * N; i++) {
      dist[i] = Integer.MAX_VALUE;
      visit[i] = false;
    }
 
    // Inserting nodes whose value in matrix
    // is 1 in the queue.
    int k = 1;
    Queue<Integer> q = new ArrayDeque<>();
    for (int i = 0; i < N; i++) {
      for (int j = 0; j < M; j++) {
        if (mat[i][j]) {
          dist[k] = 0;
          visit[k] = true;
          q.add(k);
        }
        k++;
      }
    }
 
    // Calling for Bfs with given Queue.
    g1.bfs(visit, dist, q);
 
    // Printing the solution.
    g1.print(dist);
  }
 
  // Driver code
  public static void main(String[] args)
  {
    int matrix[][] = { { 0, 0, 0, 1 },
                      { 0, 0, 1, 1 },
                      { 0, 1, 1, 0 } };
    boolean[][] mat = new boolean[N][M];
    for (int i = 0; i < N; i++) {
      for (int j = 0; j < M; j++) {
        if (matrix[i][j] == 1)
          mat[i][j] = true;
      }
    }
     
    // Function call
    findMinDistance(mat);
  }
}
 
// This code is contributed by karandeep1234


Python3




# Python3 program to find distance of nearest
# cell having 1 in a binary matrix.
from collections import deque
 
MAX = 500
N = 3
M = 4
 
# Making a class of graph with bfs function.
g = [[] for i in range(MAX)]
n, m = 0, 0
 
# Function to create graph with N*M nodes
# considering each cell as a node and each
# boundary as an edge.
 
 
def createGraph():
 
    global g, n, m
 
    # A number to be assigned to a cell
    k = 1
 
    for i in range(1, n + 1):
        for j in range(1, m + 1):
 
            # If last row, then add edge on right side.
            if (i == n):
 
                # If not bottom right cell.
                if (j != m):
                    g[k].append(k + 1)
                    g[k + 1].append(k)
 
            # If last column, then add edge toward down.
            elif (j == m):
                g[k].append(k+m)
                g[k + m].append(k)
 
            # Else makes an edge in all four directions.
            else:
                g[k].append(k + 1)
                g[k + 1].append(k)
                g[k].append(k+m)
                g[k + m].append(k)
 
            k += 1
 
# BFS function to find minimum distance
 
 
def bfs(visit, dist, q):
 
    global g
    while (len(q) > 0):
        temp = q.popleft()
 
        for i in g[temp]:
            if (visit[i] != 1):
                dist[i] = min(dist[i], dist[temp] + 1)
                q.append(i)
                visit[i] = 1
 
    return dist
 
# Printing the solution.
 
 
def prt(dist):
 
    c = 1
    for i in range(1, n * m + 1):
        print(dist[i], end=" ")
        if (c % m == 0):
            print()
 
        c += 1
 
# Find minimum distance
 
 
def findMinDistance(mat):
 
    global g, n, m
 
    # Creating a graph with nodes values assigned
    # from 1 to N x M and matrix adjacent.
    n, m = N, M
    createGraph()
 
    # To store minimum distance
    dist = [0] * MAX
 
    # To mark each node as visited or not in BFS
    visit = [0] * MAX
 
    # Initialising the value of distance and visit.
    for i in range(1, M * N + 1):
        dist[i] = 10**9
        visit[i] = 0
 
    # Inserting nodes whose value in matrix
    # is 1 in the queue.
    k = 1
    q = deque()
    for i in range(N):
        for j in range(M):
            if (mat[i][j] == 1):
                dist[k] = 0
                visit[k] = 1
                q.append(k)
 
            k += 1
 
    # Calling for Bfs with given Queue.
    dist = bfs(visit, dist, q)
 
    # Printing the solution.
    prt(dist)
 
 
# Driver code
if __name__ == '__main__':
 
    mat = [[0, 0, 0, 1],
           [0, 0, 1, 1],
           [0, 1, 1, 0]]
 
    # Function call
    findMinDistance(mat)
 
# This code is contributed by mohit kumar 29


C#




// C# program to find distance of nearest
// cell having 1 in a binary matrix.
 
using System;
using System.Collections;
using System.Collections.Generic;
 
class gfg {
 
    static int N = 3;
    static int M = 4;
    static int MAX = 500;
 
    // Making a class of graph with bfs function.
    public class graph {
 
        public List<List<int> > g;
        public int n, m;
 
        public graph(int a, int b)
        {
            g = new List<List<int> >();
            n = a;
            m = b;
        }
 
        // Function to create graph with N*M nodes
        // considering each cell as a node and each
        // boundary as an edge.
        public void createGraph()
        {
            int k = 1; // A number to be assigned to a cell
            for (int i = 0; i <= MAX; i++) {
                g.Add(new List<int>());
            }
 
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= m; j++) {
                    // If last row, then add edge on right
                    // side.
                    if (i == n) {
                        // If not bottom right cell.
                        if (j != m) {
                            g[k].Add(k + 1);
                            g[k + 1].Add(k);
                        }
                    }
 
                    // If last column, then add edge toward
                    // down.
                    else if (j == m) {
                        g[k].Add(k + m);
                        g[k + m].Add(k);
                    }
 
                    // Else makes an edge in all four
                    // directions.
                    else {
                        g[k].Add(k + 1);
                        g[k + 1].Add(k);
                        g[k].Add(k + m);
                        g[k + m].Add(k);
                    }
 
                    k++;
                }
            }
        }
 
        // BFS function to find minimum distance
        public void bfs(bool[] visit, int[] dist,
                        Queue<int> q)
        {
            while (q.Count != 0) {
                int temp = q.Peek();
                q.Dequeue();
 
                for (int i = 0; i < g[temp].Count; i++) {
                    if (visit[g[temp][i]] != true) {
                        dist[g[temp][i]]
                            = Math.Min(dist[g[temp][i]],
                                       dist[temp] + 1);
 
                        q.Enqueue(g[temp][i]);
                        visit[g[temp][i]] = true;
                    }
                }
            }
        }
 
        // Printing the solution
        public void print(int[] dist)
        {
            for (int i = 1, c = 1; i <= n * m; i++, c++) {
                Console.Write(dist[i] + " ");
 
                if (c % m == 0)
                    Console.WriteLine();
            }
        }
    };
 
    // Find minimum distance
    static void findMinDistance(bool[, ] mat)
    {
        // Creating a graph with nodes values assigned
        // from 1 to N x M and matrix adjacent.
        graph g1 = new graph(N, M);
        g1.createGraph();
 
        // To store minimum distance
        int[] dist = new int[MAX];
 
        // To mark each node as visited or not in BFS
        bool[] visit = new bool[MAX];
 
        // Initialising the value of distance and visit.
        for (int i = 1; i <= M * N; i++) {
            dist[i] = Int32.MaxValue;
            visit[i] = false;
        }
 
        // Inserting nodes whose value in matrix
        // is 1 in the queue.
        int k = 1;
        Queue<int> q = new Queue<int>();
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (mat[i, j]) {
                    dist[k] = 0;
                    visit[k] = true;
                    q.Enqueue(k);
                }
                k++;
            }
        }
 
        // Calling for Bfs with given Queue.
        g1.bfs(visit, dist, q);
 
        // Printing the solution.
        g1.print(dist);
    }
 
    // Driver code
    public static void Main(string[] args)
    {
        int[, ] matrix = { { 0, 0, 0, 1 },
                           { 0, 0, 1, 1 },
                           { 0, 1, 1, 0 } };
        bool[, ] mat = new bool[N, M];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (matrix[i, j] == 1)
                    mat[i, j] = true;
            }
        }
 
        // Function call
        findMinDistance(mat);
    }
}
 
// This code is contributed by karandeep1234


Javascript




let MAX = 500;
let N = 3;
let M = 4;
 
let dist, visit;
 
// Making a class of graph with bfs function.
let g = new Array(MAX);
for (var i = 0; i < MAX; i++)
    g[i] = []
let n = 0, m = 0;
 
// Function to create graph with N*M nodes
// considering each cell as a node and each
// boundary as an edge.
function createGraph() {
  // A number to be assigned to a cell
  let k = 1;
 
  for (let i = 1; i <= n + 1; i++) {
    for (let j = 1; j <= m + 1; j++) {
      // If last row, then add edge on right side.
      if (i === n) {
        // If not bottom right cell.
        if (j !== m) {
          g[k].push(k + 1);
          g[k + 1].push(k);
        }
      }
      // If last column, then add edge toward down.
      else if (j === m) {
        g[k].push(k + m);
        g[k + m].push(k);
      }
      // Else makes an edge in all four directions.
      else {
        g[k].push(k + 1);
        g[k + 1].push(k);
        g[k].push(k + m);
        g[k + m].push(k);
      }
 
      k += 1;
    }
  }
}
 
// BFS function to find minimum distance
function bfs(visit, dist, q) {
  while (q.length > 0) {
    let temp = q.shift();
 
    for (let i of g[temp]) {
      if (visit[i] !== 1) {
        dist[i] = Math.min(dist[i], dist[temp] + 1);
        q.push(i);
        visit[i] = 1;
      }
    }
  }
 
  return dist;
}
 
// Printing the solution.
function prt(dist) {
  let c = 1;
  for (let i = 1; i <= n * m + 1; i++) {
    process.stdout.write(dist[i] + " ");
    if (c % m === 0) {
      console.log();
    }
    c += 1;
  }
}
 
// Find minimum distance
function findMinDistance(mat) {
  // Creating a graph with nodes values assigned
  // from 1 to N x M and matrix adjacent.
  n = N;
  m = M;
  createGraph();
 
  // To store minimum distance
  dist = new Array(MAX).fill(0);
 
  // To mark each node as visited or not in BFS
  visit = new Array(MAX).fill(0);
 
  // Initialising the value of distance and visit.
  for (var i = 1; i <= M * N; i++)
    {
        dist[i] = 10**9
        visit[i] = 0
    }
     
    // Inserting nodes whose value in matrix
    // is 1 in the queue.
    let k = 1
    let q = []
    for (var i = 0; i < N; i++)
    {
        for (var j = 0; j < M; j++)
        {
            if (mat[i][j] == 1)
            {
                dist[k] = 0
                visit[k] = 1
                q.push(k)
            }
 
            k += 1
        }
    }
 
    // Calling for Bfs with given Queue.
    dist = bfs(visit, dist, q)
 
    // Printing the solution.
    prt(dist)
}
 
// Driver code
let mat = [[0, 0, 0, 1],
           [0, 0, 1, 1],
           [0, 1, 1, 0]]
 
    // Function call
    findMinDistance(mat)
 
// This code is contributed by phasing17


Output

3 2 1 0 
2 1 0 0 
1 0 0 1 

Time Complexity: O(N*M). In BFS traversal every element is traversed only once so the time Complexity is O(M*N).
Space Complexity: O(M*N). To store every element in the matrix O(M*N) space is required.

This article is contributed by Anuj Chauhan. 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.

Distance of nearest cell having 1 in a binary matrix using the BFS method using same grid (given matrix):

To solve the problem follow the below idea:

The idea is to use multisource Breadth-First Search.First we need to mark all the initial 1s present in given matrix
by storing there index(i,j) in queue<pair<int,int>>,we also know that these 1s are the starting point (meaning 
from their index distance will be calculated.) so we make all these 1s to 0, then we can also say that all the 0s 
present initially in matrix will soon replaced by distance so we assume the distance as infinite,so we make all 0s 
present in initial matrix as INT_MAX.
eg:
    n = 3 ,m=4          (∞ = INT_MAX)                           _____________________________________
    0 1 0 0             ∞ 0 ∞ ∞                              |       |      |         |       |
    1 1 0 0     ----->  0 0 ∞ ∞                  queue<int,int> | {0,1} |{1,1} | {2,2} | {2,3}    |        
    0 0 1 1             ∞ ∞ 0 0                                 |_______|______|_______|_______|__________

Follow the given steps to solve the problem:

 NOTE: grid[ i ][ j ]==0 means this is the starting point and grid[ i ][ j ]==INT_MAX is imaginary distance. this concept will be used for visited and unvisited purposes. Only grid[ i ][ j ]==INT_MAX will be treated as unvisited, everything else will be treated as visited. 

  • Create a queue<pair<int,int>> q
  • Traverse the matrix and do two tasks if (grid[i][j]==1) { q.push( { i , j } ); grid[ i ][ j ] = 0; }    else { grid[ i ][ j ] = INT_MAX; }
  • Now do a BFS traversal of the graph using the above-created queue.
  • Run while loop till the size of the queue is greater than 0 then extract the front node of the queue and remove it and insert all its valid adjacent nodes if (grid[ i ][ j ] = INT_MAX) // it means this node is unvisited till now.

C++




// C++ program to find distance of nearest
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> >
printDistance(vector<vector<int> >& grid)
{
    // Code here
    int n = grid.size(),
        m
        = grid[0]
              .size(); // n = no. of row , m = no. of column
    queue<pair<int, int> >
        q; // to do multisource Breadth-First Search store
           // the initial index of 1s
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (grid[i][j]) {
                q.push({ i, j });
                grid[i][j]
                    = 0; // mark the starting index as 0.
            }
            else
                grid[i][j]
                    = INT_MAX; // rest marked as infinity.
                               // (Not visited)
        }
    }
    int row[4] = { -1, 1, 0, 0 }, col[4] = {
        0, 0, -1, 1
    }; // (up,down,left,right index from current (x,y))
    while (!q.empty()) { // till it visit each index
        auto top = q.front();
        q.pop();
        int x = top.first // current
            ,
            y = top.second // current
            ,
            time = grid[x][y]; // time of current distance
                               // at index (x,y)
        for (int i = 0; i < 4; i++) {
            int newx = x + row[i], newy = y + col[i];
            if (newx >= 0 && newx < n && newy >= 0
                && newy < m
                && grid[newx][newy]
                       == INT_MAX) { // only for Non visited
                grid[newx][newy]
                    = time + 1; // time of current distance
                                // at index (x,y) + 1
                q.push(
                    { newx,
                      newy }); // storing index for getting
                               // the index of adjacent of
                               // {newx,newy}.
            }
        }
    }
    return grid; // returning the updated matrix
}
// Driver code
int main()
{
    vector<vector<int> > grid = { { 0, 1, 0, 0 },
                                  { 1, 1, 0, 0 },
                                  { 0, 0, 1, 1 } };
    printDistance(grid);
    for (auto row : grid) {
        for (auto eachcal : row) {
            cout << eachcal << " ";
        }
        cout << endl;
    }
    return 0;
}


Java




// Java program to find distance of nearest
import java.util.*;
 
public class GFG {
  static class pair {
    int first, second;
    pair(int f, int s)
    {
      first = f;
      second = s;
    }
  }
  static int[][] printDistance(int[][] grid)
  {
     
    // Code here
    int n = grid.length, m = grid[0].length;
     
    // n = no. of row , m = no. of column
    Queue<pair> q = new ArrayDeque<>();
     
    // to do multisource Breadth-First Search store
    // the initial index of 1s
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        if (grid[i][j] != 0) {
          q.add(new pair(i, j));
          grid[i][j] = 0; // mark the starting
          // index as 0.
        }
        else
          grid[i][j]
          = Integer
          .MAX_VALUE; // rest marked as
        // infinity. (Not
        // visited)
      }
    }
    int row[] = { -1, 1, 0, 0 }, col[] = {
      0, 0, -1, 1
      }; // (up,down,left,right index from current (x,y))
    while (q.size() != 0) { // till it visit each index
      pair top = q.peek();
      q.remove();
      int x = top.first // current
        ,
      y = top.second // current
        ,
      time
        = grid[x][y]; // time of current distance
      // at index (x,y)
      for (int i = 0; i < 4; i++) {
        int newx = x + row[i], newy = y + col[i];
        if (newx >= 0 && newx < n && newy >= 0
            && newy < m
            && grid[newx][newy]
            == Integer
            .MAX_VALUE) { // only for
          // Non
          // visited
          grid[newx][newy]
            = time
            + 1; // time of current distance
          // at index (x,y) + 1
          q.add(new pair(newx, newy));
           
          // storing index for getting
          // the index of adjacent of
          // {newx,newy}.
        }
      }
    }
    return grid; // returning the updated matrix
  }
   
  // Driver code
  public static void main(String[] args)
  {
    int[][] grid = { { 0, 1, 0, 0 },
                    { 1, 1, 0, 0 },
                    { 0, 0, 1, 1 } };
    grid = printDistance(grid);
    for (int[] row : grid) {
      for (int eachcal : row) {
        System.out.print(eachcal + " ");
      }
      System.out.println();
    }
  }
}
 
// This code is contributed by Karandeep1234


C#




// C# program to find distance of nearest
using System;
using System.Collections;
using System.Collections.Generic;
 
public class GFG {
  public class pair {
    public int first, second;
    public pair(int f, int s)
    {
      first = f;
      second = s;
    }
  }
  static List<List<int> >
    printDistance(List<List<int> > grid)
  {
 
    // Code here
    int n = grid.Count, m = grid[0].Count;
 
    // n = no. of row , m = no. of column
    Queue<pair> q = new Queue<pair>();
 
    // to do multisource Breadth-First Search store
    // the indial index of 1s
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        if (grid[i][j] != 0) {
          q.Enqueue(new pair(i, j));
          grid[i][j] = 0; // mark the starting
          // index as 0.
        }
        else
          grid[i][j] = Int32.MaxValue;
        // rest marked as
        // infinity. (Not
        // visited)
      }
    }
    int[] row = { -1, 1, 0, 0 }, col = {
      0, 0, -1, 1
      }; // (up,down,left,right index from current (x,y))
    while (q.Count != 0) { // till it visit each index
      pair top = q.Peek();
      q.Dequeue();
      int x = top.first // current
        ,
      y = top.second // current
        ,
      time
        = grid[x][y]; // time of current distance
      // at index (x,y)
      for (int i = 0; i < 4; i++) {
        int newx = x + row[i], newy = y + col[i];
        if (newx >= 0 && newx < n && newy >= 0
            && newy < m
            && grid[newx][newy]
            == Int32.MaxValue) { // only for
          // Non
          // visited
          grid[newx][newy]
            = time
            + 1; // time of current distance
          // at index (x,y) + 1
          q.Enqueue(new pair(newx, newy));
 
          // storing index for getting
          // the index of adjacent of
          // {newx,newy}.
        }
      }
    }
    return grid; // returning the updated matrix
  }
 
  // Driver code
  public static void Main(string[] args)
  {
    List<List<int> > grid = new List<List<int> >{
      new List<int>{ 0, 1, 0, 0 },
      new List<int>{ 1, 1, 0, 0 },
      new List<int>{ 0, 0, 1, 1 }
    };
    grid = printDistance(grid);
    foreach(List<int> row in grid)
    {
      foreach(int eachcal in row)
      {
        Console.Write(eachcal + " ");
      }
      Console.WriteLine();
    }
  }
}
 
// This code is contributed by Karandeep1234


Javascript




// JS code to implement the approach
 
// JavaScript program to find distance of nearest
const printDistance = (grid) => {
    // Code here
    let n = grid.length,
        m = grid[0].length; // n = no. of row , m = no. of column
    let q = new Array(); // to do multisource Breadth-First Search store
                        // the initial index of 1s
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < m; j++) {
            if (grid[i][j]) {
                q.push([i, j]);
                grid[i][j] = 0; // mark the starting index as 0.
            }
            else
                grid[i][j] = Number.MAX_VALUE; // rest marked as infinity.
                                               // (Not visited)
        }
    }
    let row = [-1, 1, 0, 0], col = [0, 0, -1, 1]; // (up,down,left,right index from current (x,y))
    while (q.length) { // till it visit each index
        let top = q.shift();
        let x = top[0], y = top[1], time = grid[x][y]; // time of current distance
                                                      // at index (x,y)
        for (let i = 0; i < 4; i++) {
            let newx = x + row[i], newy = y + col[i];
            if (newx >= 0 && newx < n && newy >= 0
                && newy < m
                && grid[newx][newy] === Number.MAX_VALUE) { // only for Non visited
                grid[newx][newy] = time + 1; // time of current distance
                                             // at index (x,y) + 1
                q.push([newx, newy]); // storing index for getting
                                      // the index of adjacent of
                                      // {newx,newy}.
            }
        }
    }
    return grid; // returning the updated matrix
}
 
// Driver code
let grid = [[0, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 1]];
console.log(printDistance(grid).join("\n"));
 
 
// This code is contributed by phasing17


Output

1 0 1 2 
0 0 1 1 
1 1 0 0 

Time Complexity: O(N*M).
Auxiliary Space: O(M*N) 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!