Distance of nearest cell having 1 in a binary matrix - GeeksforGeeks

23 Mar, 2022
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
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.
Method 1: This method uses a simple brute force approach to arrive at the solution.
Approach: 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 calculates the distance between two cells and store the minimum distance.
Algorithm : 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.
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.
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.
Implementation: 
C++
Java
Python3
C#
PHP
Javascript
// C++ program to find distance of nearest// cell having 1 in a binary matrix.#include<bits/stdc++.h>#define N 3#define M 4using 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 Programint main(){    int mat[N][M] =    {        0, 0, 0, 1,        0, 0, 1, 1,        0, 1, 1, 0    };     printDistance(mat);     return 0;}
// 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 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 CodeN = 3M = 4mat = [[0, 0, 0, 1],       [0, 0, 1, 1],       [0, 1, 1, 0]] printDistance(mat) # This code is contributed by PranchalK
// 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();        }    }         // 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// 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));     printDistance($mat); // This code is contributed by anuj_67.?>
<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 Programlet mat = [[0, 0, 0, 1],       [0, 0, 1, 1],       [0, 1, 1, 0]]printDistance(mat);  // This code is contributed by patel2127</script>
3 2 1 0 
2 1 0 0 
1 0 0 1 

Complexity Analysis: 
Time Complexity: O(N2*M2). For every element in the matrix, the matrix is traversed and there are N*M elements So the time complexity is O(N2*M2).
Space Complexity: O(1). No extra space is required.
 Method 1(a): Improved Brute-Force approach.
Approach: The idea is to load the 1’s  i and j coordinates in the Matrix into a Queue and then traverse all the “0” Matrix elements and compare the distance between all the  1’s from Queue to get minimum distance.
Algorithm :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” elements from “1” element is obtained, push back the 1’s coordinates back into queue again for the next “0” element.Determine Min distance from the individual distances for every “0” element.
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” elements from “1” element is obtained, push back the 1’s coordinates back into queue again for the next “0” element.
Determine Min distance from the individual distances for every “0” element.
Implementation
Java
/*package whatever //do not write package name here */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();        }    }     public static void main(String[] args){        int arr[][]        = { { 0, 0, 0, 1 }, { 0, 0, 1, 1 }, { 0, 1, 1, 0 } };             printDistance(arr);    }}//// This code is contributed by prithi_raj
3 2 1 0 
2 1 0 0 
1 0 0 1 

Method 2: This method uses the BFS or breadth-first search technique to arrive at the solution.
Approach: 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.
Algorithm: 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 queue.Now do a BFS traversal of graph using 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 distance of current node +1 and insert the element in the queue.
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 queue.Now do a BFS traversal of graph using 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 distance of current node +1 and insert the element in the queue.
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 queue.
Now do a BFS traversal of graph using 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 distance of current node +1 and insert the element in the queue.
Implementation: 
C++
Python3
// 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 4using 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 distancevoid 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 Programint main(){    bool mat[N][M] =    {        0, 0, 0, 1,        0, 0, 1, 1,        0, 1, 1, 0    };     findMinDistance(mat);     return 0;}
# Python3 program to find distance of nearest# cell having 1 in a binary matrix.from collections import deque MAX = 500N = 3M = 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 distancedef 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 distancedef 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 codeif __name__ == '__main__':         mat = [ [ 0, 0, 0, 1 ],            [ 0, 0, 1, 1 ],            [ 0, 1, 1, 0 ] ]     findMinDistance(mat) # This code is contributed by mohit kumar 29
3 2 1 0 
2 1 0 0 
1 0 0 1 

Complexity Analysis: 
Time Complexity: O(N*M). In BFS traversal every element is traversed only once so 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.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
vt_m
PranchalKatiyar
Akanksha_Rai
ManasChhabra2
andrew1234
mohit kumar 29
patel2127
khushboogoyal499
prithicogni89
Amazon
BFS
Graph
Matrix
Queue
Amazon
Matrix
Graph
Queue
BFS
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2
Topological Sorting
Bellman–Ford Algorithm | DP-23
Detect Cycle in a Directed Graph
Floyd Warshall Algorithm | DP-16
Matrix Chain Multiplication | DP-8
Program to find largest element in an array
Sudoku | Backtracking-7
Rat in a Maze | Backtracking-2
Divide and Conquer | Set 5 (Strassen's Matrix Multiplication)