Open In App

Maximum of all distances to the nearest 1 cell from any 0 cell in a Binary matrix

Given a Matrix of size N*N filled with 1‘s and 0‘s, the task is to find the maximum distance from a 0-cell to its nearest 1-cell. If the matrix is filled with only 0’s or only 1’s, return -1.

Note: Only horizontal and vertical movements are allowed in the matrix.

Examples:  

Input: 
mat[][] = {{0, 1, 0},
           {0, 0, 1},
           {0, 0, 0}}
Output: 3
Explanation: 
Cell number (2, 0) is at the farthest
distance of 3 cells from both the
1-cells (0, 1) and (1, 2).

Input: 
mat[][] = {{1, 0, 0},
           {0, 0, 0},
           {0, 0, 0}}
Output: 4
Explanation: 
Cell number (2, 2) is at the farthest 
distance of 4 cells from the only 
1-cell (1, 1).

Approach 1: Naive Approach 
For each 0-cell, compute its distance from every 1-cell and store the minimum. The maximum of all those minimal distances is the answer.

Below is the implementation of the above approach: 




// C++ Program to find the maximum
// distance from a 0-cell to a 1-cell
  
#include <bits/stdc++.h>
using namespace std;
  
int maxDistance(vector<vector<int> >& grid)
{
    vector<pair<int, int> > one;
  
    int M = grid.size();
    int N = grid[0].size();
    int ans = -1;
  
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < N; ++j) {
            if (grid[i][j] == 1)
                one.emplace_back(i, j);
        }
    }
  
    // If the matrix consists of only 0's
    // or only 1's
    if (one.empty() || M * N == one.size())
        return -1;
  
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < N; ++j) {
  
            if (grid[i][j] == 1)
                continue;
  
            // If it's a 0-cell
            int dist = INT_MAX;
            for (auto& p : one) {
  
                // calculate its distance
                // with every 1-cell
                int d = abs(p.first - i)
                        + abs(p.second - j);
  
                // Compare and store the minimum
                dist = min(dist, d);
  
                if (dist <= ans)
                    break;
            }
  
            // Compare and store the maximum
            ans = max(ans, dist);
        }
    }
    return ans;
}
  
// Driver code
int main()
{
    vector<vector<int> > arr
        = { { 0, 0, 1 },
            { 0, 0, 0 },
            { 0, 0, 0 } };
  
    cout << maxDistance(arr) << endl;
    return 0;
}




// Java Program to find the maximum
// distance from a 0-cell to a 1-cell
   
  
import java.util.*;
  
class GFG{
      
static class pair
    int first, second; 
    public pair(int first, int second)  
    
        this.first = first; 
        this.second = second; 
    }    
}  
static int maxDistance(int [][]grid)
{
    Vector<pair> one = new Vector<pair>();
   
    int M = grid.length;
    int N = grid[0].length;
    int ans = -1;
   
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < N; ++j) {
            if (grid[i][j] == 1)
                one.add(new pair(i, j));
        }
    }
   
    // If the matrix consists of only 0's
    // or only 1's
    if (one.isEmpty() || M * N == one.size())
        return -1;
   
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < N; ++j) {
   
            if (grid[i][j] == 1)
                continue;
   
            // If it's a 0-cell
            int dist = Integer.MAX_VALUE;
            for (pair p : one) {
   
                // calculate its distance
                // with every 1-cell
                int d = Math.abs(p.first - i)
                        + Math.abs(p.second - j);
   
                // Compare and store the minimum
                dist = Math.min(dist, d);
   
                if (dist <= ans)
                    break;
            }
   
            // Compare and store the maximum
            ans = Math.max(ans, dist);
        }
    }
    return ans;
}
   
// Driver code
public static void main(String[] args)
{
    int [][]arr
        = { { 0, 0, 1 },
            { 0, 0, 0 },
            { 0, 0, 0 } };
   
    System.out.print(maxDistance(arr) +"\n");
}
}
  
// This code contributed by Princi Singh




# Python3 program to find the maximum
# distance from a 0-cell to a 1-cell
def maxDistance(grid):
    
  one = []
  M = len(grid)
  N = len(grid[0])
  ans = -1
    
  for i in range(M):
    for j in range(N):
      if (grid[i][j] == 1):
        one.append([i, j])
          
  # If the matrix consists of only 0's
  # or only 1's
  if (one == [] or M * N == len(one)):
    return -1
  
  for i in range(M):
    for j in range(N):
      if (grid[i][j] == 1):
        continue
  
      # If it's a 0-cell
      dist = float('inf')
        
      for p in one:
          
        # Calculate its distance
        # with every 1-cell
        d = abs(p[0] - i) + abs(p[1] - j)
          
        # Compare and store the minimum
        dist = min(dist, d)
          
        if (dist <= ans):
          break
  
        # Compare and store the maximum
        ans = max(ans, dist)
          
  return ans
  
# Driver code
arr = [ [ 0, 0, 1 ], 
        [ 0, 0, 0 ],
        [ 0, 0, 0 ] ]
  
print(maxDistance(arr))
  
# This code is contributed by rohitsingh07052




// C# program to find the maximum
// distance from a 0-cell to a 1-cell
using System;
using System.Collections.Generic;
  
class GFG{
class pair
    public int first, second; 
    public pair(int first, int second) 
    
        this.first = first; 
        this.second = second; 
    
  
static int maxDistance(int [,]grid)
{
    List<pair> one = new List<pair>();
  
    int M = grid.GetLength(0);
    int N = grid.GetLength(1);
    int ans = -1;
  
    for(int i = 0; i < M; ++i)
    {
       for(int j = 0; j < N; ++j)
       {
          if (grid[i, j] == 1)
              one.Add(new pair(i, j));
       }
    }
  
    // If the matrix consists of only 0's
    // or only 1's
    if (one.Count == 0 || M * N == one.Count)
        return -1;
  
    for(int i = 0; i < M; ++i)
    {
       for(int j = 0; j < N; ++j) 
       {
          if (grid[i, j] == 1)
              continue;
            
          // If it's a 0-cell
          int dist = int.MaxValue;
          foreach (pair p in one)
          {
                
              // Calculate its distance
              // with every 1-cell
              int d = Math.Abs(p.first - i) + 
                      Math.Abs(p.second - j);
                
              // Compare and store the minimum
              dist = Math.Min(dist, d);
                
              if (dist <= ans)
                  break;
          }
            
          // Compare and store the maximum
          ans = Math.Max(ans, dist);
       }
    }
    return ans;
}
  
// Driver code
public static void Main(String[] args)
{
    int [,]arr = { { 0, 0, 1 },
                   { 0, 0, 0 },
                   { 0, 0, 0 } };
  
    Console.Write(maxDistance(arr) + "\n");
}
}
  
// This code is contributed by Amit Katiyar




<script>
  
// JavaScript Program to find the maximum
// distance from a 0-cell to a 1-cell
  
  
function maxDistance(grid)
{
    let one = [];
  
    let M = grid.length;
    let N = grid[0].length;
    let ans = -1;
  
    for (let i = 0; i < M; ++i) {
        for (let j = 0; j < N; ++j) {
            if (grid[i][j] == 1)
                one.push([i, j]);
        }
    }
  
    // If the matrix consists of only 0's
    // or only 1's
    if (one.length==0 || M * N == one.length)
        return -1;
  
    for (let i = 0; i < M; ++i) {
        for (let j = 0; j < N; ++j) {
  
            if (grid[i][j] == 1)
                continue;
  
            // If it's a 0-cell
            let dist = Number.MAX_VALUE;
            for (let p of one) {
  
                // calculate its distance
                // with every 1-cell
                let d = Math.abs(p[0] - i)
                        + Math.abs(p[1] - j);
  
                // Compare and store the minimum
                dist = Math.min(dist, d);
  
                if (dist <= ans)
                    break;
            }
  
            // Compare and store the maximum
            ans = Math.max(ans, dist);
        }
    }
    return ans;
}
  
// Driver code
  
let arr = [ [ 0, 0, 1 ],
            [ 0, 0, 0 ],
            [ 0, 0, 0 ] ];
  
document.write(maxDistance(arr),"</br>");
  
// This code is contributed by shinjanpatra.
</script>

Output: 
4

 

Time complexity: O(M*N*P) where grid is of size M*N and P is the count of 1-cells. 
Auxiliary Space: O(P)

Approach 2: Using BFS 
Start from a 1-cell, and perform a Breadth First Search traversal, layer by layer. The maximum layer, up to which we can retrieve, is our answer.

Below is the implementation of the above approach:  




// C++ Program to find the maximum
// distance from a 0-cell to a 1-cell
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to find the maximum distance
int maxDistance(vector<vector<int> >& grid)
{
    // Queue to store all 1-cells
    queue<pair<int, int> > q;
  
    // Grid dimensions
    int M = grid.size();
    int N = grid[0].size();
    int ans = -1;
  
    // Directions traversable from
    // a given a particular cell
    int dirs[4][2] = { { 0, 1 },
                       { 1, 0 },
                       { 0, -1 },
                       { -1, 0 } };
  
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < N; ++j) {
            if (grid[i][j] == 1)
                q.emplace(i, j);
        }
    }
  
    // If the grid contains
    // only 0s or only 1s
    if (q.empty() || M * N == q.size())
        return -1;
  
    while (q.size()) {
  
        int cnt = q.size();
  
        while (cnt--) {
  
            // Access every 1-cell
            auto p = q.front();
            q.pop();
  
            // Traverse all possible
            // directions from the cells
            for (auto& dir : dirs) {
  
                int x = p.first + dir[0];
                int y = p.second + dir[1];
  
                // Check if the cell is
                // within the boundaries
                // or contains a 1
                if (x < 0 || x >= M
                    || y < 0 || y >= N
                    || grid[x][y])
                    continue;
  
                q.emplace(x, y);
                grid[x][y] = 1;
            }
        }
        ++ans;
    }
    return ans;
}
  
// Driver code
int main()
{
    vector<vector<int> > arr = { { 0, 0, 1 },
                                 { 0, 0, 0 },
                                 { 0, 0, 1 } };
  
    cout << maxDistance(arr) << endl;
    return 0;
}




// Java program to find the maximum
// distance from a 0-cell to a 1-cell
import java.util.*;
  
class GFG{
static class pair
    int first, second; 
      
    public pair(int first, int second) 
    
        this.first = first; 
        this.second = second; 
    
  
// Function to find the maximum distance
static int maxDistance(int [][]grid)
{
      
    // Queue to store all 1-cells
    Queue<pair> q = new LinkedList<pair>();
  
    // Grid dimensions
    int M = grid.length;
    int N = grid[0].length;
    int ans = -1;
  
    // Directions traversable from
    // a given a particular cell
    int dirs[][] = { { 0, 1 },
                     { 1, 0 },
                     { 0, -1 },
                     { -1, 0 } };
  
    for(int i = 0; i < M; ++i) 
    {
        for(int j = 0; j < N; ++j) 
        {
            if (grid[i][j] == 1)
                q.add(new pair(i, j));
        }
    }
  
    // If the grid contains
    // only 0s or only 1s
    if (q.isEmpty() || M * N == q.size())
        return -1;
  
    while (q.size() > 0
    {
        int cnt = q.size();
        while (cnt-->0)
        {
  
            // Access every 1-cell
            pair p = q.peek();
            q.remove();
  
            // Traverse all possible
            // directions from the cells
            for(int []dir : dirs) 
            {
                int x = p.first + dir[0];
                int y = p.second + dir[1];
  
                // Check if the cell is
                // within the boundaries
                // or contains a 1
                if (x < 0 || x >= M || 
                    y < 0 || y >= N ||
                    grid[x][y] > 0)
                    continue;
  
                q.add(new pair(x, y));
                grid[x][y] = 1;
            }
        }
        ++ans;
    }
    return ans;
}
  
// Driver code
public static void main(String[] args)
{
    int [][]arr = { { 0, 0, 1 },
                    { 0, 0, 0 },
                    { 0, 0, 1 } };
  
    System.out.print(maxDistance(arr) + "\n");
}
}
  
// This code is contributed by Amit Katiyar




# Python3 program to find the maximum
# distance from a 0-cell to a 1-cell
  
# Function to find the maximum distance
def maxDistance(grid):
  
    # Queue to store all 1-cells
    q = []
   
    # Grid dimensions
    M = len(grid)
    N = len(grid[0])
    ans = -1
   
    # Directions traversable from
    # a given a particular cell
    dirs = [ [ 0, 1 ], [ 1, 0 ], 
             [ 0, -1 ], [ -1, 0 ] ]
   
    for i in range(M):
        for j in range(N):
            if (grid[i][j] == 1):
                q.append([i, j])
   
    # If the grid contains
    # only 0s or only 1s
    if (len(q) == 0 or M * N == len(q)):
        return -1
   
    while (len(q) > 0):
        cnt = len(q)
   
        while (cnt > 0):
   
            # Access every 1-cell
            p = q[0]
            q.pop()
   
            # Traverse all possible
            # directions from the cells
            for Dir in dirs:
                x = p[0] + Dir[0]
                y = p[1] + Dir[1]
   
                # Check if the cell is
                # within the boundaries
                # or contains a 1
                if (x < 0 or x >= M or 
                    y < 0 or y >= N or 
                    grid[x][y]):
                    continue
   
                q.append([x, y])
                grid[x][y] = 1
                  
            cnt -= 1
              
        ans += 2
      
    return ans
      
# Driver code    
arr = [ [ 0, 0, 1 ], 
        [ 0, 0, 0 ], 
        [ 0, 0, 1 ] ]
          
print(maxDistance(arr))
  
# This code is contributed by divyeshrabadiya07




// C# program to find 
// the maximum distance 
// from a 0-cell to a 1-cell
using System;
using System.Collections.Generic;
class GFG{
      
static int index = 0;
class pair
  public int first, second; 
  public pair(int first, int second) 
  
    this.first = first; 
    this.second = second; 
  
  
// Function to find the 
// maximum distance
static int maxDistance(int [,]grid)
{
  // Queue to store all 1-cells
  Queue<pair> q = new Queue<pair>();
  
  // Grid dimensions
  int M = grid.GetLength(0);
  int N = grid.GetLength(1);
  int ans = -1;
  
  // Directions traversable from
  // a given a particular cell
  int [,]dirs = {{0, 1},
                 {1, 0},
                 {0, -1},
                 {-1, 0}};
  
  for(int i = 0; i < M; ++i) 
  {
    for(int j = 0; j < N; ++j) 
    {
      if (grid[i, j] == 1)
        q.Enqueue(new pair(i, j));
    }
  }
  
  // If the grid contains
  // only 0s or only 1s
  if (q.Count==0 || M * N == q.Count)
    return -1;
  
  while (q.Count > 0) 
  {
    int cnt = q.Count;
    while (cnt-- > 0)
    {
      // Access every 1-cell
      pair p = q.Peek();
      q.Dequeue();
  
      // Traverse all possible
      // directions from the cells
  
      for(int i = 0; i < dirs.GetLength(0);)
      {
        int []dir = GetRow(dirs, i++);
        int x = p.first + dir[0];
        int y = p.second + dir[1];
  
        // Check if the cell is
        // within the boundaries
        // or contains a 1
        if (x < 0 || x >= M || 
            y < 0 || y >= N ||
            grid[x, y] > 0)
          continue;
  
        q.Enqueue(new pair(x, y));
        grid[x, y] = 1;
      }
    }
    ++ans;
  }
  return ans;
}
    
public static int[] GetRow(int[,] matrix, 
                           int row)
{
  var rowLength = matrix.GetLength(1);
  var rowVector = new int[rowLength];
  
  for (var i = 0; i < rowLength; i++)
    rowVector[i] = matrix[row, i];
  return rowVector;
}
    
// Driver code
public static void Main(String[] args)
{
  int [,]arr = {{0, 0, 1},
                {0, 0, 0},
                {0, 0, 1}};
  Console.Write(maxDistance(arr) + "\n");
}
}
  
// This code is contributed by shikhasingrajput




<script>
  
// JavaScript program to find the maximum
// distance from a 0-cell to a 1-cell
  
// Function to find the maximum distance
function maxDistance(grid){
  
    // Queue to store all 1-cells
    let q = []
  
    // Grid dimensions
    let M = grid.length
    let N = grid[0].length
    let ans = -1
  
    // Directions traversable from
    // a given a particular cell
    let dirs = [ [ 0, 1 ], [ 1, 0 ],
            [ 0, -1 ], [ -1, 0 ] ]
  
    for(let i = 0; i < M; i++)
    {
        for(let j = 0; j < N; j++)
        {
            if (grid[i][j] == 1)
                q.push([i, j])
        }
    }
      
    // If the grid contains
    // only 0s or only 1s
    if (q.length == 0 || M * N == q.length)
        return -1
  
    while (q.length > 0){
        let cnt = q.length
  
        while (cnt > 0){
  
            // Access every 1-cell
            let p = q[0]
            q.pop()
  
            // Traverse all possible
            // directions from the cells
            for(let Dir of dirs){
                let x = p[0] + Dir[0]
                let y = p[1] + Dir[1]
  
                // Check if the cell is
                // within the boundaries
                // or contains a 1
                if (x < 0 || x >= M ||
                    y < 0 || y >= N ||
                    grid[x][y])
                    continue
  
                q.push([x, y])
                grid[x][y] = 1
            }    
            cnt -= 1
        }    
        ans += 2
    }
    return ans
}
      
// Driver code
let arr = [ [ 0, 0, 1 ],
        [ 0, 0, 0 ],
        [ 0, 0, 1 ] ]
          
console.log(maxDistance(arr))
  
// This code is contributed by shinjanpatra
  
</script>

Output: 
3

 

Time complexity: O(M*N) 
Auxiliary Space: O(M*N)

Approach 3: Using Dynamic Programming  

Below is the implementation of the above approach:  




// C++ Program to find the maximum
// distance from a 0-cell to a 1-cell
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to find the maximum distance
int maxDistance(vector<vector<int> >& grid)
{
    if (!grid.size())
        return -1;
    int N = grid.size();
  
    int INF = 1000000;
  
    // DP matrix
    vector<vector<int> >
    dp(N, vector<int>(N, 0));
  
    grid[0][0] = grid[0][0] == 1
                     ? 0
                     : INF;
  
    // Set up top row and left column
    for (int i = 1; i < N; i++)
        grid[0][i] = grid[0][i] == 1
                         ? 0
                         : grid[0][i - 1] + 1;
    for (int i = 1; i < N; i++)
        grid[i][0] = grid[i][0] == 1
                         ? 0
                         : grid[i - 1][0] + 1;
  
    // Pass one: top left to bottom right
    for (int i = 1; i < N; i++) {
        for (int j = 1; j < N; j++) {
            grid[i][j] = grid[i][j] == 1
                             ? 0
                             : min(grid[i - 1][j],
                                   grid[i][j - 1])
                                   + 1;
        }
    }
  
    // Check if there was no "One" Cell
    if (grid[N - 1][N - 1] >= INF)
        return -1;
  
    // Set up top row and left column
    int maxi = grid[N - 1][N - 1];
    for (int i = N - 2; i >= 0; i--) {
        grid[N - 1][i]
            = min(grid[N - 1][i],
                  grid[N - 1][i + 1] + 1);
        maxi = max(grid[N - 1][i], maxi);
    }
  
    for (int i = N - 2; i >= 0; i--) {
        grid[i][N - 1]
            = min(grid[i][N - 1],
                  grid[i + 1][N - 1] + 1);
        maxi = max(grid[i][N - 1], maxi);
    }
  
    // Past two: bottom right to top left
    for (int i = N - 2; i >= 0; i--) {
        for (int j = N - 2; j >= 0; j--) {
            grid[i][j] = min(grid[i][j],
                             min(grid[i + 1][j] + 1,
                                 grid[i][j + 1] + 1));
            maxi = max(grid[i][j], maxi);
        }
    }
  
    return !maxi ? -1 : maxi;
}
  
// Driver code
int main()
{
    vector<vector<int> > arr = { { 0, 0, 1 },
                                 { 0, 0, 0 },
                                 { 0, 0, 0 } };
  
    cout << maxDistance(arr) << endl;
    return 0;
}




// Java program to find the maximum
// distance from a 0-cell to a 1-cell
import java.util.*;
import java.lang.*;
  
class GFG{
      
// Function to find the maximum distance
static int maxDistance(int[][] grid)
{
    if (grid.length == 0)
        return -1;
          
    int N = grid.length;
    int INF = 1000000;
      
    grid[0][0] = grid[0][0] == 1 ? 0 : INF;
      
    // Set up top row and left column
    for(int i = 1; i < N; i++)
        grid[0][i] = grid[0][i] == 1 ? 0
                     grid[0][i - 1] + 1;
                       
    for(int i = 1; i < N; i++)
        grid[i][0] = grid[i][0] == 1 ? 0
                     grid[i - 1][0] + 1;
   
    // Pass one: top left to bottom right
    for(int i = 1; i < N; i++) 
    {
        for(int j = 1; j < N; j++)
        {
            grid[i][j] = grid[i][j] == 1 ? 0
                Math.min(grid[i - 1][j],
                         grid[i][j - 1]) + 1;
        }
    }
   
    // Check if there was no "One" Cell
    if (grid[N - 1][N - 1] >= INF)
        return -1;
   
    // Set up top row and left column
    int maxi = grid[N - 1][N - 1];
    for(int i = N - 2; i >= 0; i--)
    {
        grid[N - 1][i] = Math.min(
            grid[N - 1][i],
            grid[N - 1][i + 1] + 1);
              
        maxi = Math.max(grid[N - 1][i], maxi);
    }
   
    for(int i = N - 2; i >= 0; i--) 
    {
        grid[i][N - 1] = Math.min(
            grid[i][N - 1],
            grid[i + 1][N - 1] + 1);
              
        maxi = Math.max(grid[i][N - 1], maxi);
    }
   
    // Past two: bottom right to top left
    for(int i = N - 2; i >= 0; i--) 
    {
        for(int j = N - 2; j >= 0; j--)
        {
            grid[i][j] = Math.min(
                grid[i][j],
                Math.min(grid[i + 1][j] + 1,
                         grid[i][j + 1] + 1));
                           
            maxi = Math.max(grid[i][j], maxi);
        }
    }
   
    return maxi == 0 ? -1 : maxi;
}
  
// Driver code
public static void main(String[] args)
{
    int[][] arr = { { 0, 0, 1 },
                    { 0, 0, 0 },
                    { 0, 0, 0 } };
      
    System.out.println(maxDistance(arr));
}
}
  
// This code is contributed by offbeat




# Python3 program to find the maximum
# distance from a 0-cell to a 1-cell
  
# Function to find the maximum distance
def maxDistance(grid):
      
    if (len(grid) == 0):
        return -1
           
    N = len(grid)
    INF = 1000000
      
    if grid[0][0] == 1:
        grid[0][0] = 0
    else:
        grid[0][0] = INF
       
    # Set up top row and left column
    for i in range(1, N):
        if grid[0][i] == 1:
            grid[0][i] = 0
        else:
            grid[0][i] = grid[0][i - 1] + 1
                        
    for i in range(1, N):
        if grid[i][0] == 1:
            grid[i][0] = 0
        else:
            grid[i][0] = grid[i - 1][0] + 1
    
    # Pass one: top left to bottom right
    for i in range(1, N):
        for j in range(1, N):
            if grid[i][j] == 1:
                grid[i][j] = 0
            else:
                grid[i][j] = min(grid[i - 1][j], 
                                 grid[i][j - 1] + 1)
    
    # Check if there was no "One" Cell
    if (grid[N - 1][N - 1] >= INF):
        return -1
    
    # Set up top row and left column
    maxi = grid[N - 1][N - 1]
      
    for i in range(N - 2, -1, -1):
        grid[N - 1][i] = min(grid[N - 1][i], 
                             grid[N - 1][i + 1] + 1)
               
        maxi = max(grid[N - 1][i], maxi)
    
    for i in range(N - 2, -1, -1):
        grid[i][N - 1] = min(grid[i][N - 1], 
                             grid[i + 1][N - 1] + 1)
               
        maxi = max(grid[i][N - 1], maxi + 1)
    
    # Past two: bottom right to top left
    for i in range(N - 2, -1, -1):
        for j in range(N - 2, -1, -1):
            grid[i][j] = min(grid[i][j], 
                             min(grid[i + 1][j] + 1
                                 grid[i][j + 1] + 1))
                            
            maxi = max(grid[i][j], maxi)
              
    if maxi == 0:
        return -1
    else:
        return maxi
  
# Driver code        
arr = [ [ 0, 0, 1 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ]
       
print(maxDistance(arr))
  
# This code is contributed by divyesh072019




// C# program to find the maximum
// distance from a 0-cell to a 1-cell
using System;
class GFG {
  
    // Function to find the maximum distance
    static int maxDistance(int[, ] grid)
    {
        if (grid.GetLength(0) == 0)
            return -1;
  
        int N = grid.GetLength(0);
        int INF = 1000000;
  
        grid[0, 0] = grid[0, 0] == 1 ? 0 : INF;
  
        // Set up top row and left column
        for (int i = 1; i < N; i++)
            grid[0, i]
                = grid[0, i] == 1 ? 0 : grid[0, i - 1] + 1;
  
        for (int i = 1; i < N; i++)
            grid[i, 0]
                = grid[i, 0] == 1 ? 0 : grid[i - 1, 0] + 1;
  
        // Pass one: top left to bottom right
        for (int i = 1; i < N; i++) {
            for (int j = 1; j < N; j++) {
                grid[i, j] = grid[i, j] == 1
                                 ? 0
                                 : Math.Min(grid[i - 1, j],
                                            grid[i, j - 1])
                                       + 1;
            }
        }
  
        // Check if there was no "One" Cell
        if (grid[N - 1, N - 1] >= INF)
            return -1;
  
        // Set up top row and left column
        int maxi = grid[N - 1, N - 1];
        for (int i = N - 2; i >= 0; i--) {
            grid[N - 1, i] = Math.Min(
                grid[N - 1, i], grid[N - 1, i + 1] + 1);
  
            maxi = Math.Max(grid[N - 1, i], maxi);
        }
  
        for (int i = N - 2; i >= 0; i--) {
            grid[i, N - 1] = Math.Min(
                grid[i, N - 1], grid[i + 1, N - 1] + 1);
  
            maxi = Math.Max(grid[i, N - 1], maxi);
        }
  
        // Past two: bottom right to top left
        for (int i = N - 2; i >= 0; i--) {
            for (int j = N - 2; j >= 0; j--) {
                grid[i, j] = Math.Min(
                    grid[i, j],
                    Math.Min(grid[i + 1, j] + 1,
                             grid[i, j + 1] + 1));
  
                maxi = Math.Max(grid[i, j], maxi);
            }
        }
  
        return maxi == 0 ? -1 : maxi;
    }
  
    // Driver code
    public static void Main()
    {
        int[, ] arr
            = { { 0, 0, 1 }, { 0, 0, 0 }, { 0, 0, 0 } };
  
        Console.WriteLine(maxDistance(arr));
    }
}
  
// This code is contributed by subhammahato348




<script>
  
// JavaScript Program to find the maximum
// distance from a 0-cell to a 1-cell
  
// Function to find the maximum distance
function maxDistance(grid)
{
    if (!grid.length)
        return -1
    let N = grid.length
  
    let INF = 1000000
  
    // DP matrix
    let dp = new Array(N)
    for(let i=0;i<N;i++){
        dp[i] = new Array(N).fill(0)
    }
  
    grid[0][0] = grid[0][0] == 1
                     ? 0
                     : INF
  
    // Set up top row and left column
    for (let i = 1; i < N; i++)
        grid[0][i] = grid[0][i] == 1
                         ? 0
                         : grid[0][i - 1] + 1;
    for (let i = 1; i < N; i++)
        grid[i][0] = grid[i][0] == 1
                         ? 0
                         : grid[i - 1][0] + 1;
  
    // Pass one: top left to bottom right
    for (let i = 1; i <N; i++) {
        for (let j = 1; j < N; j++) {
            grid[i][j] = grid[i][j] == 1
                             ? 0
                             : Math.min(grid[i - 1][j],
                                   grid[i][j - 1])
                                   + 1;
        }
    }
  
    // Check if there was no "One" Cell
    if (grid[N - 1][N - 1] >= INF)
        return -1;
  
    // Set up top row and left column
    let maxi = grid[N - 1][N - 1];
    for (let i = N - 2; i >= 0; i--) {
        grid[N - 1][i]
            = Math.min(grid[N - 1][i],
                  grid[N - 1][i + 1] + 1);
        maxi = Math.max(grid[N - 1][i], maxi);
    }
  
    for (let i = N - 2; i >= 0; i--) {
        grid[i][N - 1]
            = Math.min(grid[i][N - 1],
                  grid[i + 1][N - 1] + 1);
        maxi = Math.max(grid[i][N - 1], maxi);
    }
  
    // Past two: bottom right to top left
    for (let i = N - 2; i >= 0; i--) {
        for (let j = N - 2; j >= 0; j--) {
            grid[i][j] = Math.min(grid[i][j],
                             Math.min(grid[i + 1][j] + 1,
                                 grid[i][j + 1] + 1));
            maxi = Math.max(grid[i][j], maxi);
        }
    }
  
    return !maxi ? -1 : maxi;
}
  
// Driver code
  
let arr = [ [ 0, 0, 1 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ]
document.write(maxDistance(arr),"</br>")
  
// This code is contributed by shinjanpatra
  
</script>

Output
4

Time complexity: O(M*N) 
Auxiliary Space: O(N2)


Article Tags :