# Distance of nearest cell having 1 in a binary matrix

Last Updated : 30 Jan, 2023

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 ` `#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

 ``

## Javascript

 ``

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 ` `#include ` `#include ` `#include ` `#include  `   `using` `namespace` `std;`   `struct` `matrix_element` `{` `  ``int` `row;` `  ``int` `col;` `  ``matrix_element(``int` `row, ``int` `col) : row(row), col(col) {}` `};`   `void` `printDistance(vector> arr)` `{` `  ``int` `Row_Count = arr.size();` `  ``int` `Col_Count = arr[0].size();` `  ``vector 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> 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 q` `            ``= ``new` `LinkedList();` `        ``// 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 q = ``new` `List();` `    ``// 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

 ``

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 ` `#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 > 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 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 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 > g;` `        ``public` `int` `n, m;`   `        ``public` `graph(``int` `a, ``int` `b)` `        ``{` `            ``g = ``new` `List >();` `            ``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.

## 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 ` `using` `namespace` `std;` `vector >` `printDistance(vector >& grid)` `{` `    ``// Code here` `    ``int` `n = grid.size(),` `        ``m` `        ``= grid[0]` `              ``.size(); ``// n = no. of row , m = no. of column` `    ``queue >` `        ``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 > 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 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`

## Python3

 `# Python3 code to implement the approach`   `# Function to find distance of nearest` `def` `printDistance(grid):` `    ``# Code here` `    ``n ``=` `len``(grid)` `    ``m ``=` `len``(grid[``0``]) ``# n = no. of row , m = no. of column` `    ``q ``=` `[] ``# to do multisource Breadth-First Search store` `            ``# the initial index of 1s` `    ``for` `i ``in` `range``(n):` `        ``for` `j ``in` `range``(m):` `            ``if` `grid[i][j]:` `                ``q.append([i, j])` `                ``grid[i][j] ``=` `0` `# mark the starting index as 0.` `            ``else``:` `                ``grid[i][j] ``=` `float``(``"inf"``) ``# rest marked as infinity. (Not visited)` `    ``row ``=` `[``-``1``, ``1``, ``0``, ``0``]` `    ``col ``=` `[``0``, ``0``, ``-``1``, ``1``] ``# (up,down,left,right index from current (x,y))` `    ``while` `len``(q): ``# till it visit each index` `        ``top ``=` `q.pop(``0``)` `        ``x ``=` `top[``0``]` `        ``y ``=` `top[``1``]` `        ``time ``=` `grid[x][y] ``# time of current distance at index (x,y)` `        ``for` `i ``in` `range``(``4``):` `            ``newx ``=` `x ``+` `row[i]` `            ``newy ``=` `y ``+` `col[i]` `            ``if` `newx >``=` `0` `and` `newx < n ``and` `newy >``=` `0` `and` `newy < m ``and` `grid[newx][newy] ``=``=` `float``(``"inf"``): ``# only for Non visited` `                ``grid[newx][newy] ``=` `time ``+` `1` `# time of current distance at index (x,y) + 1` `                ``q.append([newx, newy]) ``# storing index for getting the index of adjacent of {newx,newy}.` `    ``return` `grid ``# returning the updated matrix`   `# Driver code` `grid ``=` `[[``0``, ``1``, ``0``, ``0``], [``1``, ``1``, ``0``, ``0``], [``0``, ``0``, ``1``, ``1``]]` `print``(``*``printDistance(grid), sep ``=` `'\n'``)`

## 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 >` `    ``printDistance(List > grid)` `  ``{`   `    ``// Code here` `    ``int` `n = grid.Count, m = grid[0].Count;`   `    ``// n = no. of row , m = no. of column` `    ``Queue q = ``new` `Queue();`   `    ``// 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 > grid = ``new` `List >{` `      ``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)

Previous
Next