Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

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++




// 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




// 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




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




// 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


Javascript




<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++




// 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




// 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




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




// 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


Javascript




<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  

  • Keep updating the matrix of the maximum distances that have been traveled.
  • Traverse from the top left-hand cell (0, 0) of the matrix to the bottom right. Let grid[i][j] represent the maximum distance from the nearest 1-cell on the left or above(or of course on itself).
  • Do a second pass from bottom right to top left, updating the grid array, defining the cell grid[i][j] as the minimum of grid[i][j], grid[i+1][j], and grid[i][j+1].
  • Keep track of the maximum value during the bottom right to top left traversal and return the value at the end. In case the value is 0, i.e the grid is filled with only 0’s or only 1’s, return -1.

Below is the implementation of the above approach:  

C++




// 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




// 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




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




// 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


Javascript




<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)



Last Updated : 24 Jul, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads