Open In App

Minimum time required to fill the entire matrix with 1’s

Improve
Improve
Like Article
Like
Save
Share
Report

Given a matrix of size N consisting of 0‘s and 1‘s, the task is to find the minimum time required to fill the entire matrix with 1‘s. Every 1 at an instant in the matrix, can convert all 0‘s to 1 in its eight adjacent cells,i.e. a 1 present at (i,j) can convert all 0‘s to 1 at positions (i, j-1), (i, j+1), (i-1, j), (i+1, j), (i-1, j-1), (i-1, j+1), (i+1, j-1), (i+1, j+1).

Examples:  

Input: N = 3, mtrx[][] = {{1,0,0},{0,0,1},{0,0,0}} 
Output:
Explanation: 
Initially the matrix appears to be 
1, 0, 0 
0, 0, 1 
0, 0, 0 
After the first instant of time, the new matrix is 
1, 1, 1 
1, 1, 1 
0, 1, 1 
After the 2nd instant the remaining 0 is converted to 1.

Input: N = 5, 
mtrx[][] = {{0,0,0,0,0}, 
{1,0,0,0,0}, 
{0,0,0,0,0}, 
{0,0,1,0,0}, 
{0,0,0,1,0}}
Output:

Approach: 
In order to solve this problem, we are using the BFS approach. Traverse through the matrix and store the indices of the matrix with 1 initially in a queue. Loop until the queue gets empty and converts the adjacent valid cells of all queue elements to 1. The number of levels of BFS traversal that has led to the conversion of at least one 0 to 1 is the answer.

The below code is the implementation of the above approach:

C++




// C++ program to calculate the number of steps
// in fill all entire matrix with '1'
#include<bits/stdc++.h>
using namespace std;
 
// Function to return total number
// of steps required to fill
// entire matrix with '1'
int numberOfSteps(int n,vector<vector<int>> mtrx)
{
    // Queue to store indices with 1
    queue<pair<int,int>> q;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (mtrx[i][j] == 1) {
                q.push({i,j});
            }
        }
    }
     
    // Initialise step variable as zero
    int step = 0 ;
 
    // BFS approach
    while (!q.empty())
    {
        int qsize = q.size();
        // Visit all indices with 1 and
        // fill its neighbouring cells by 1
        while (qsize--)
        {
            pair<int,int> p  = q.front();
            q.pop();
            int i = p.first;
            int j = p.second;
            // Convert the neighbour from '0' to '1'
            if((j > 0) && mtrx[i][j-1] == 0)
            {
                mtrx[i][j-1] = 1;
                q.push({i,j-1});
            }
            // Convert the neighbour from '0' to '1'
            if((i < n-1) && mtrx[i+1][j] == 0)
            {
                mtrx[i+1][j] = 1;
                q.push({i+1,j});
            }
            // Convert the neighbour from '0' to '1'
            if((j < n-1) && mtrx[i][j+1] == 0)
            {
                mtrx[i][j+1] = 1;
                q.push({i,j + 1});
            }
            // Convert the neighbour from '0' to '1'
            if((i > 0) && mtrx[i-1][j] == 0)
            {
                mtrx[i-1][j] = 1;
                q.push({i-1,j});
            }
            // Convert the neighbour from '0' to '1'
            if((i > 0) && (j > 0) &&
                                mtrx[i-1][j-1] == 0)
            {
                mtrx[i-1][j-1] = 1;
                q.push({i-1,j-1});
            }
            // Convert the neighbour from '0' to '1'
            if((i > 0) && (j < (n-1)) &&
                                mtrx[i-1][j+1] == 0)
            {
                mtrx[i-1][j+1] = 1;
                q.push({i-1,j+1});
            }
            // Convert the neighbour from '0' to '1'
            if((i < (n-1)) && (j < (n-1)) &&
                                mtrx[i+1][j+1] == 0)
            {
                mtrx[i+1][j+1] = 1;
                q.push({i+1,j + 1});
            }
            // Convert the neighbour from '0' to '1'
            if((i < (n-1)) && (j > 0) &&
                                mtrx[i+1][j-1] == 0)
            {
                mtrx[i+1][j-1] = 1;
                q.push({i+1,j-1});
            }
        }
        //count steps
        step++;
    }
     
    return step-1;
}
 
// Driver code
int main()
{
    int n = 5 ; //dimension of matrix NXN
    vector<vector<int>> mtrx = {{0,0,0,0,0},
                                {1,0,0,0,0},
                                {0,0,0,0,0},
                                {0,0,1,0,0},
                                {0,0,0,1,0}};
    // Print number of steps
    cout << numberOfSteps(n, mtrx);
 
    return 0;
}


Java




// Java program to calculate the
// number of steps in fill all
// entire matrix with '1'
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 return total number
// of steps required to fill
// entire matrix with '1'
static int numberOfSteps(int n, int[][] mtrx)
{
     
    // Queue to store indices with 1
    Queue<pair> q = new LinkedList<>();
     
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            if (mtrx[i][j] == 1)
            {
                q.add(new pair(i, j));
            }
        }
    }
 
    // Initialise step variable as zero
    int step = 0;
 
    // BFS approach
    while (!q.isEmpty())
    {
        int qsize = q.size();
         
        // Visit all indices with 1 and
        // fill its neighbouring cells by 1
        while (qsize-- > 0)
        {
            pair p  = q.peek();
            q.remove();
             
            int i = p.first;
            int j = p.second;
             
            // Convert the neighbour from '0' to '1'
            if ((j > 0) && mtrx[i][j - 1] == 0)
            {
                mtrx[i][j - 1] = 1;
                q.add(new pair(i, j - 1));
            }
             
            // Convert the neighbour from '0' to '1'
            if ((i < n - 1) && mtrx[i + 1][j] == 0)
            {
                mtrx[i + 1][j] = 1;
                q.add(new pair(i + 1, j));
            }
             
            // Convert the neighbour from '0' to '1'
            if ((j < n - 1) && mtrx[i][j + 1] == 0)
            {
                mtrx[i][j + 1] = 1;
                q.add(new pair(i, j + 1));
            }
             
            // Convert the neighbour from '0' to '1'
            if ((i > 0) && mtrx[i - 1][j] == 0)
            {
                mtrx[i - 1][j] = 1;
                q.add(new pair(i - 1, j));
            }
             
            // Convert the neighbour from '0' to '1'
            if ((i > 0) && (j > 0) &&
                mtrx[i - 1][j - 1] == 0)
            {
                mtrx[i - 1][j - 1] = 1;
                q.add(new pair(i - 1, j - 1));
            }
             
            // Convert the neighbour from '0' to '1'
            if ((i > 0) && (j < (n - 1)) &&
                mtrx[i - 1][j + 1] == 0)
            {
                mtrx[i - 1][j + 1] = 1;
                q.add(new pair(i - 1, j + 1));
            }
             
            // Convert the neighbour from '0' to '1'
            if ((i < (n - 1)) && (j < (n - 1)) &&
                mtrx[i + 1][j + 1] == 0)
            {
                mtrx[i + 1][j + 1] = 1;
                q.add(new pair(i + 1, j + 1));
            }
             
            // Convert the neighbour from '0' to '1'
            if ((i < (n - 1)) && (j > 0) &&
                mtrx[i + 1][j - 1] == 0)
            {
                mtrx[i + 1][j - 1] = 1;
                q.add(new pair(i + 1, j - 1));
            }
        }
         
        // Count steps
        step++;
    }
    return step - 1;
}
 
// Driver code
public static void main(String[] args)
{
     
    // Dimension of matrix NXN
    int n = 5;
    int [][]mtrx = { { 0, 0, 0, 0, 0 },
                     { 1, 0, 0, 0, 0 },
                     { 0, 0, 0, 0, 0 },
                     { 0, 0, 1, 0, 0 },
                     { 0, 0, 0, 1, 0 } };
                      
    // Print number of steps
    System.out.print(numberOfSteps(n, mtrx));
}
}
 
// This code is contributed by Amit Katiyar


Python3




# Python 3 program to calculate the number of steps
# in fill all entire matrix with '1'
 
# Function to return total number
# of steps required to fill
# entire matrix with '1'
def numberOfSteps(n,mtrx):
     
    # Queue to store indices with 1
    q = []
    for i in range(n):
        for j in range(n):
            if (mtrx[i][j] == 1):
                q.append([i,j])
     
    # Initialise step variable as zero
    step = 0
 
    # BFS approach
    while (len(q)):
        qsize = len(q)
         
        # Visit all indices with 1 and
        # fill its neighbouring cells by 1
        while(qsize):
            p = q[0]
            q.remove(q[0])
            i = p[0]
            j = p[1]
             
            # Convert the neighbour from '0' to '1'
            if((j > 0) and mtrx[i][j - 1] == 0):
                mtrx[i][j - 1] = 1
                q.append([i, j - 1])
                 
            # Convert the neighbour from '0' to '1'
            if((i < n-1) and mtrx[i + 1][j] == 0):
                mtrx[i + 1][j] = 1
                q.append([i + 1, j])
                 
            # Convert the neighbour from '0' to '1'
            if((j < n-1) and mtrx[i][j + 1] == 0):
                mtrx[i][j + 1] = 1
                q.append([i, j + 1])
                 
            # Convert the neighbour from '0' to '1'
            if((i > 0) and mtrx[i - 1][j] == 0):
                mtrx[i - 1][j] = 1
                q.append([i - 1, j])
                 
            # Convert the neighbour from '0' to '1'
            if((i > 0) and (j > 0) and
                                   mtrx[i - 1][j - 1] == 0):
                mtrx[i - 1][j - 1] = 1
                q.append([i - 1, j - 1])
                 
            # Convert the neighbour from '0' to '1'
            if((i > 0) and (j < (n-1)) and 
                                    mtrx[i - 1][j + 1] == 0):
                mtrx[i - 1][j + 1] = 1
                q.append([i - 1, j + 1])
                 
            # Convert the neighbour from '0' to '1'
            if((i < (n - 1)) and (j < (n - 1)) and
                                     mtrx[i + 1][j + 1] == 0):
                mtrx[i + 1][j + 1] = 1
                q.append([i + 1, j + 1])
                 
            # Convert the neighbour from '0' to '1'
            if((i < (n - 1)) and (j > 0) and
                                    mtrx[i + 1][j - 1] == 0):
                mtrx[i + 1][j - 1] = 1
                q.append([i + 1,j - 1])
             
            qsize -= 1
             
        #count steps
        step += 1
     
    return step-1
 
# Driver code
if __name__ == '__main__':
     
    #dimension of matrix NXN
    n = 5
    mtrx = [[ 0, 0, 0, 0, 0 ],
            [ 1, 0, 0, 0, 0 ],
            [ 0, 0, 0, 0, 0 ],
            [ 0, 0, 1, 0, 0 ],
            [ 0, 0, 0, 1, 0 ]]
             
    # Print number of steps
    print(numberOfSteps(n, mtrx))
     
# This code is contributed by Samarth


C#




// C# program to calculate the
// number of steps in fill all
// entire matrix with '1'
using System;
using System.Collections.Generic;
class GFG{
     
public class pair
{
  public int first, second;
  public pair(int first, int second) 
  {
    this.first = first;
    this.second = second;
  }   
}
 
// Function to return total number
// of steps required to fill
// entire matrix with '1'
static int numberOfSteps(int n,
                         int[,] mtrx)
{
  // Queue to store indices with 1
  Queue<pair> q = new Queue<pair>();
 
  for(int i = 0; i < n; i++)
  {
    for(int j = 0; j < n; j++)
    {
      if (mtrx[i, j] == 1)
      {
        q.Enqueue(new pair(i, j));
      }
    }
  }
 
  // Initialise step variable as zero
  int step = 0;
 
  // BFS approach
  while (q.Count != 0)
  {
    int qsize = q.Count;
 
    // Visit all indices
    // with 1 and fill
    // its neighbouring
    // cells by 1
    while (qsize-- > 0)
    {
      pair p  = q.Peek();
      q.Dequeue();
      int i = p.first;
      int j = p.second;
 
      // Convert the neighbour
      // from '0' to '1'
      if ((j > 0) &&
           mtrx[i, j - 1] == 0)
      {
        mtrx[i, j - 1] = 1;
        q.Enqueue(new pair(i, j - 1));
      }
 
      // Convert the neighbour
      // from '0' to '1'
      if ((i < n - 1) &&
           mtrx[i + 1, j] == 0)
      {
        mtrx[i + 1, j] = 1;
        q.Enqueue(new pair(i + 1, j));
      }
 
      // Convert the neighbour
      // from '0' to '1'
      if ((j < n - 1) &&
           mtrx[i, j + 1] == 0)
      {
        mtrx[i, j + 1] = 1;
        q.Enqueue(new pair(i, j + 1));
      }
 
      // Convert the neighbour
      // from '0' to '1'
      if ((i > 0) &&
           mtrx[i - 1, j] == 0)
      {
        mtrx[i - 1, j] = 1;
        q.Enqueue(new pair(i - 1, j));
      }
 
      // Convert the neighbour
      // from '0' to '1'
      if ((i > 0) && (j > 0) &&
           mtrx[i - 1, j - 1] == 0)
      {
        mtrx[i - 1, j - 1] = 1;
        q.Enqueue(new pair(i - 1, j - 1));
      }
 
      // Convert the neighbour
      // from '0' to '1'
      if ((i > 0) && (j < (n - 1)) &&
           mtrx[i - 1, j + 1] == 0)
      {
        mtrx[i - 1, j + 1] = 1;
        q.Enqueue(new pair(i - 1, j + 1));
      }
 
      // Convert the neighbour
      // from '0' to '1'
      if ((i < (n - 1)) && (j < (n - 1)) &&
           mtrx[i + 1, j + 1] == 0)
      {
        mtrx[i + 1, j + 1] = 1;
        q.Enqueue(new pair(i + 1, j + 1));
      }
 
      // Convert the neighbour
      // from '0' to '1'
      if ((i < (n - 1)) && (j > 0) &&
           mtrx[i + 1, j - 1] == 0)
      {
        mtrx[i + 1, j - 1] = 1;
        q.Enqueue(new pair(i + 1, j - 1));
      }
    }
 
    // Count steps
    step++;
  }
  return step - 1;
}
 
// Driver code
public static void Main(String[] args)
{
  // Dimension of matrix NXN
  int n = 5;
  int [,]mtrx = {{0, 0, 0, 0, 0},
                 {1, 0, 0, 0, 0},
                 {0, 0, 0, 0, 0},
                 {0, 0, 1, 0, 0},
                 {0, 0, 0, 1, 0}};
 
  // Print number of steps
  Console.Write(numberOfSteps(n, mtrx));
}
}
 
// This code is contributed by Rajput-Ji


Javascript




<script>
 
// JavaScript program to calculate the number of steps
// in fill all entire matrix with '1'
 
// Function to return total number
// of steps required to fill
// entire matrix with '1'
function numberOfSteps(n,mtrx){
     
    // Queue to store indices with 1
    let q = []
    for(let i = 0; i < n; i++)
    {
        for(let j = 0; j < n; j++)
        {
            if (mtrx[i][j] == 1)
                q.push([i, j])
        }
    }
     
    // Initialise step variable as zero
    let step = 0
 
    // BFS approach
    while (q.length){
        let qsize = q.length
         
        // Visit all indices with 1 and
        // fill its neighbouring cells by 1
        while(qsize){
            let p = q.shift()
            let i = p[0]
            let j = p[1]
             
            // Convert the neighbour from '0' to '1'
            if((j > 0) && mtrx[i][j - 1] == 0){
                mtrx[i][j - 1] = 1
                q.push([i, j - 1])  
            }
 
            // Convert the neighbour from '0' to '1'
            if((i < n-1) && mtrx[i + 1][j] == 0){
                mtrx[i + 1][j] = 1
                q.push([i + 1, j])  
            }
 
            // Convert the neighbour from '0' to '1'
            if((j < n-1) && mtrx[i][j + 1] == 0){
                mtrx[i][j + 1] = 1
                q.push([i, j + 1])  
            }
 
            // Convert the neighbour from '0' to '1'
            if((i > 0) && mtrx[i - 1][j] == 0){
                mtrx[i - 1][j] = 1
                q.push([i - 1, j])  
            }
 
            // Convert the neighbour from '0' to '1'
            if((i > 0) && (j > 0) &&
                                   mtrx[i - 1][j - 1] == 0){
                mtrx[i - 1][j - 1] = 1
                q.push([i - 1, j - 1])
            }
                 
            // Convert the neighbour from '0' to '1'
            if((i > 0) && (j < (n-1)) && 
                                    mtrx[i - 1][j + 1] == 0){
                mtrx[i - 1][j + 1] = 1
                q.push([i - 1, j + 1])
            }
                 
            // Convert the neighbour from '0' to '1'
            if((i < (n - 1)) && (j < (n - 1)) &&
                                     mtrx[i + 1][j + 1] == 0){
                mtrx[i + 1][j + 1] = 1
                q.push([i + 1, j + 1])
                }
                 
            // Convert the neighbour from '0' to '1'
            if((i < (n - 1)) && (j > 0) &&
                                    mtrx[i + 1][j - 1] == 0){
                mtrx[i + 1][j - 1] = 1
                q.push([i + 1,j - 1])
            }
             
            qsize -= 1
        }
             
        // count steps
        step += 1
    }
     
    return step-1
}
 
// Driver code
     
// dimension of matrix NXN
let n = 5
let mtrx = [[ 0, 0, 0, 0, 0 ],
        [ 1, 0, 0, 0, 0 ],
        [ 0, 0, 0, 0, 0 ],
        [ 0, 0, 1, 0, 0 ],
        [ 0, 0, 0, 1, 0 ]]
             
// Print number of steps
document.write(numberOfSteps(n, mtrx),"</br>")
     
// This code is contributed by shinjanpatra
 
</script>


Output: 

3

 

Time Complexity: O(n*n)
Auxiliary Space: O(n*n)



Last Updated : 26 Dec, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads