# Distance of nearest cell having 1 in a binary matrix

Given a binary matrix of N x M, containing at least a value 1. The task is to find the distance of 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

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

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Method 1 (Brute Force):
The idea is to traverse the matrix for each cell and find the minimum distance.

Below is the implementation of this 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; ` `    ``} ` `} ` ` `  `// Driven Program ` `int` `main() ` `{ ` `    ``int` `mat[N][M] = ` `    ``{ ` `        ``0, 0, 0, 1, ` `        ``0, 0, 1, 1, ` `        ``0, 1, 1, 0 ` `    ``}; ` ` `  `    ``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(); ` `        ``} ` `    ``} ` `     `  `    ``// Driven Program ` `    ``public` `static` `void` `main (String[] args) ` `    ``{ ` `        ``int` `mat[][] = { {``0``, ``0``, ``0``, ``1``}, ` `                        ``{``0``, ``0``, ``1``, ``1``}, ` `                        ``{``0``, ``1``, ``1``, ``0``} }; ` `     `  `        ``printDistance(mat); ` `    ``} ` `} ` ` `  `// This code is contributed by anuj_67. `

## Python3

 `# Python3 program to find distance of  ` `# nearest cell having 1 in a binary matrix.  ` ` `  `# Prthe 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 ` `N ``=` `3` `M ``=` `4` `mat ``=` `[[``0``, ``0``, ``0``, ``1``],  ` `       ``[``0``, ``0``, ``1``, ``1``], ` `       ``[``0``, ``1``, ``1``, ``0``]] ` ` `  `printDistance(mat) ` ` `  `# This code is contributed by PranchalK `

## C#

 `// C# program to find 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(); ` `        ``} ` `    ``} ` `     `  `    ``// Driven Program ` `    ``public` `static` `void` `Main () ` `    ``{ ` `        ``int` `[,]mat = { {0, 0, 0, 1}, ` `                        ``{0, 0, 1, 1}, ` `                        ``{0, 1, 1, 0} }; ` `     `  `        ``printDistance(mat); ` `    ``} ` `} ` ` `  `// This code is contributed by anuj_67. `

## PHP

 ` `

Output:

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

Time Complexity: O(N2*M2).

Method 2 (using BFS):
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 node 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.

1. Create a graph with values assigned from 1 to M*N to all vertices. The purpose is to store position and adjacent information.
2. Create an empty queue.
3. Traverse all matrix elements and insert positions of all 1s in queue.
4. Now do a BFS traversal of graph using above created queue. In BFS, we first explore immediate adjacent of all 1’s, then adjacent of adjacent, and so on. Therefore we find minimum distance.

Below is C++ implementation of this approach:

 `// 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 make edge in all four direction. ` `                ``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); ` `} ` ` `  `// Driven Program ` `int` `main() ` `{ ` `    ``bool` `mat[N][M] = ` `    ``{ ` `        ``0, 0, 0, 1, ` `        ``0, 0, 1, 1, ` `        ``0, 1, 1, 0 ` `    ``}; ` ` `  `    ``findMinDistance(mat); ` ` `  `    ``return` `0; ` `} `

Output :

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

Time Complexity: O(N * M).

This article is contributed by Anuj Chauhan. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.