Wednesday, July 3, 2024
HomeData ModellingData Structure & AlgorithmMinimum number of integers required to fill the NxM grid

Minimum number of integers required to fill the NxM grid

Given a grid of size (NxM) is to be filled with integers. Filling of cells in the grid should be done in the following manner:

  1. let A, B and C are three cell and, B and C shared a side with A.
  2. Value of cell B and C must be distinct.
  3. Let L be the number of distinct integers in a grid.
  4. Each cell should contain value from 1 to L.

The task is to find the minimum value of L and any resulting grid. Examples:

Input: N = 1, M = 2
Output:
L = 2
grid = {1, 2}

Input: 2 3
Output:
L = 3
grid = {{1, 2, 3},
        {1, 2, 3}}
Explanation: Integers in the neighbors 
of cell (2, 2) are 1, 2 and 3.
All numbers are pairwise distinct.

Approach: It is given that two cells shared a side with another cell must be distinct. For each such cell, there will be a possible maximum of 8 cells in a grid from whom its value must be different. It will follow the 4 colour problem: Maximum colour required to fill the regions will be 4.

  1. For N<4 or M<4 Number of integers required may vary from 1 to 4. Checking 8 cells and then fill the current cell. If number of distinct integers in 8 cells is less than L then fill the current cell with any remaining integer, otherwise fill the current cells with L+1 integer.
  2. For N>=4 and M>=4 Number of integers required must be 4 according to 4 colour problem. Use the 4×4 matrix to fill the NxM matrix.
1 2 3 4
1 2 3 4
3 4 1 2
3 4 1 2

Below is the implementation of the above approach: Implementation: 

C++




// C++ implementation of
/// above approach
#include<bits/stdc++.h>
using namespace std;
 
// Function to display the matrix
void display_matrix(vector<vector<int>> &A)
{
  for (auto x: A){
    for(auto y: x){
      cout << y << " ";
    }
    cout << endl;
  }
}
 
// Function for calculation
vector<vector<int>> cal_main(vector<vector<int>> &A,
                             int L,set<int>& x,int i,
                             int j, int N, int M)
{
  set<int> s;
 
  // Checking 8 cells and
  // then fill the current cell.
  if ((i - 2) >= 0)
    s.insert(A[i - 2][j]);
  if ((i + 2) < N)
    s.insert(A[i + 2][j]);
  if ((j - 2) >= 0)
    s.insert(A[i][j - 2]);
  if ((j + 2) < M)
    s.insert(A[i][j + 2]);
  if ((i - 1) >= 0 && (j - 1) >= 0)
    s.insert(A[i - 1][j - 1]);
  if ((i - 1) >= 0 && (j + 1) < M)
    s.insert(A[i - 1][j + 1]);
  if ((i + 1) < N && (j - 1) >= 0)
    s.insert(A[i + 1][j - 1]);
  if ((i + 1) < N && (j + 1) < M)
    s.insert(A[i + 1][j + 1]);
 
  // Set to contain distinct value
  // of integers in 8 cells.
  auto it = s.find(0);
  if (it != s.end())
    s.erase(it);
 
  if (s.size() < L)
  {
    set<int> w;
 
    // Set contain remaining integers
    for(auto i: x)
    {
      if (!s.count(i))
        w.insert(i);
    }
 
    // fill the current cell
    // with maximum remaining integer
    A[i][j] = *w.begin();
  }
  else
  {
    // fill the current cells with L + 1 integer.
    A[i][j] = L + 1;
    L += 1;
 
    // Increase the value of L
    x.insert(L);
  }
  return A;
}
 
 
// Function to find the number
// of distinct integers
void solve(int N,int M)
{
  // initialise the list (NxM) with 0.
  vector<vector<int>> A(N, vector<int> (M, 0));
 
  // Set to contain distinct
  // value of integers from 1-L
  set<int> x;
  int L = 0;
 
  // Number of integer required
  // may vary from 1 to 4.
  if (N < 4 || M < 4)
  {
    if (N > M) // if N is greater
      for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
          A = cal_main(A, L, x, i, j, N, M);
 
    else
    {
      // if M is greater
      for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
          A = cal_main(A, L, x, i, j, N, M);
    }
  }
  else
  {
    // Number of integer required
    // must be 4
    L = 4;
 
    // 4×4 matrix to fill the NxM matrix.
    vector<vector<int>> m4 = {{1, 2, 3, 4},
                              {1, 2, 3, 4},
                              {3, 4, 1, 2},
                              {3, 4, 1, 2}};
 
    for (int i = 0; i < 4; i++)
      for (int j = 0; j < 4; j++)
        A[i][j] = m4[i][j];
    for (int i = 4; i < N; i++)
      for (int j = 0; j < 4; j++)
        A[i][j] = m4[i % 4][j];
    for (int j = 4; j < M; j++) 
      for (int i = 0; i < N; i++)
        A[i][j] = A[i][j % 4];
  }
  cout << L << endl;
  display_matrix(A);
}
 
// Driver Code
 
// sample input
// Number of rows and columns
int main(){
 
  int N = 10;
  int M = 5;
  solve(N, M);
  return 0;
 
}
 
// This code is contributed by Nighi goel.


Java




// java implementation of
/// above approach
import java.io.*;
import java.util.HashSet;
import java.util.*;
// "static void main" must be defined in a public class.
public class Main {
     
 
    // Function to display the matrix
    static void display_matrix(int[][] A, int n, int m)
    {
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                System.out.print(A[i][j] + " ");
            }
            System.out.println();
        }
    }
 
     
    // Function for calculation
    static void cal_main(int[][] A, int L,HashSet<Integer> x,int i, int j, int N, int M)
    {
      HashSet<Integer> s = new HashSet<Integer> ();
 
      // Checking 8 cells and
      // then fill the current cell.
      if ((i - 2) >= 0)
        s.add(A[i - 2][j]);
      if ((i + 2) < N)
        s.add(A[i + 2][j]);
      if ((j - 2) >= 0)
        s.add(A[i][j - 2]);
      if ((j + 2) < M)
        s.add(A[i][j + 2]);
      if ((i - 1) >= 0 && (j - 1) >= 0)
        s.add(A[i - 1][j - 1]);
      if ((i - 1) >= 0 && (j + 1) < M)
        s.add(A[i - 1][j + 1]);
      if ((i + 1) < N && (j - 1) >= 0)
        s.add(A[i + 1][j - 1]);
      if ((i + 1) < N && (j + 1) < M)
        s.add(A[i + 1][j + 1]);
 
      // Set to contain distinct value
      // of integers in 8 cells.
      if (s.contains(0))
        s.remove(0);
 
      if (s.size() < L)
      {
        HashSet<Integer> w = new HashSet<Integer> ();
 
        // Set contain remaining integers
         
        for(Integer ele: x)
        {
          if (s.contains(ele) == false)
            w.add(ele);
        }
 
        // fill the current cell
        // with maximum remaining integer
        A[i][j] = Collections.max(w);
      }
      else
      {
        // fill the current cells with L + 1 integer.
        A[i][j] = L + 1;
        L += 1;
 
        // Increase the value of L
        x.add(L);
      }
    }
 
     
    // Function to find the number
    // of distinct integers
    static void solve(int N,int M)
    {
      // initialise the list (NxM) with 0.
      int[][] A = new int[N][M];
      for(int i = 0; i < N; i++){
          for(int j = 0; j < M; j++){
              A[i][j] = 0;
          }
      }
 
      // Set to contain distinct
      // value of integers from 1-L
      HashSet<Integer> x = new  HashSet<Integer>(); 
      int L = 0;
 
      // Number of integer required
      // may vary from 1 to 4.
      if (N < 4 || M < 4)
      {
        if (N > M) // if N is greater
          for (int i = 0; i < N; i++)
            for (int j = 0; j < N; j++)
              cal_main(A, L, x, i, j, N, M);
 
        else
        {
          // if M is greater
          for (int i = 0; i < N; i++)
            for (int j = 0; j < N; j++)
              cal_main(A, L, x, i, j, N, M);
        }
      }
      else
      {
        // Number of integer required
        // must be 4
        L = 4;
 
        // 4×4 matrix to fill the NxM matrix.
        int[][] m4 = {{1, 2, 3, 4},
                                  {1, 2, 3, 4},
                                  {3, 4, 1, 2},
                                  {3, 4, 1, 2}};
 
        for (int i = 0; i < 4; i++)
          for (int j = 0; j < 4; j++)
            A[i][j] = m4[i][j];
        for (int i = 4; i < N; i++)
          for (int j = 0; j < 4; j++)
            A[i][j] = m4[i % 4][j];
        for (int j = 4; j < M; j++) 
          for (int i = 0; i < N; i++)
            A[i][j] = A[i][j % 4];
      }
      System.out.println(L);
      display_matrix(A, N, M);
    }   
 
     
    // Driver Code
 
    // sample input
    // Number of rows and columns
    public static void main(String[] args) {
        int N = 10;
        int M = 5;
        solve(N, M);
    }
}
 
// The code is contributed by Nidhi goel.


Python3




# Python 3 implementation of
# above approach
 
# Function to display the matrix
def display_matrix(A):
    for i in A:
        print(*i)
 
# Function for calculation
def cal_main(A, L, x, i, j):
    s = set()
 
    # Checking 8 cells and
    # then fill the current cell.
    if (i - 2) >= 0:
        s.add(A[i - 2][j])
    if (i + 2) < N:
        s.add(A[i + 2][j])
    if (j - 2) >= 0:
        s.add(A[i][j - 2])
    if (j + 2) < M:
        s.add(A[i][j + 2])
    if (i - 1) >= 0 and (j - 1) >= 0:
        s.add(A[i - 1][j - 1])
    if (i - 1) >= 0 and (j + 1) < M:
        s.add(A[i - 1][j + 1])
    if (i + 1) < N and (j - 1) >= 0:
        s.add(A[i + 1][j - 1])
    if (i + 1) < N and (j + 1) < M:
        s.add(A[i + 1][j + 1])
     
    # Set to contain distinct value
    # of integers in 8 cells.
    s = s.difference({0})
 
    if len(s) < L:
 
        # Set contain remaining integers
        w = x.difference(s)
 
        # fill the current cell
        # with maximum remaining integer
        A[i][j] = max(w)
    else:
 
        # fill the current cells with L + 1 integer.
        A[i][j] = L + 1
        L += 1
 
        # Increase the value of L
        x.add(L)
    return A, L, x
 
 
# Function to find the number
# of distinct integers
def solve(N, M):
 
    # initialise the list (NxM) with 0.
    A = []
    for i in range(N):
        K = []
        for j in range(M):
            K.append(0)
        A.append(K)
     
    # Set to contain distinct
    # value of integers from 1-L
    x = set()
    L = 0
 
    # Number of integer required
    # may vary from 1 to 4.
    if N < 4 or M < 4:
        if N > M: # if N is greater
            for i in range(N):
                for j in range(M):
                    cal_main(A, L, x, i, j)
 
        else:
            # if M is greater
            for j in range(M):
                for i in range(N):
                    cal_main(A, L, x, i, j)
    else:
 
        # Number of integer required
        # must be 4
        L = 4
 
        # 4×4 matrix to fill the NxM matrix.
        m4 = [[1, 2, 3, 4],
            [1, 2, 3, 4],
            [3, 4, 1, 2],
            [3, 4, 1, 2]]
 
        for i in range(4):
            for j in range(4):
                A[i][j] = m4[i][j]
        for i in range(4, N):
            for j in range(4):
                A[i][j] = m4[i % 4][j]
        for j in range(4, M):
            for i in range(N):
                A[i][j] = A[i][j % 4]
    print(L)
    display_matrix(A)
 
 
# Driver Code
if __name__ == "__main__":
 
    # sample input
    # Number of rows and columns
    N, M = 10, 5
    solve(N, M)


C#




using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
 
// C# implementation of
// above approach
 
class GFG {
 
  // Function to display the matrix
  public static void display_matrix(int[,] A, int N, int M)
  {
    for(int i = 0; i < N; i++){
      for(int j = 0; j < M; j++){
        Console.Write(A[i, j] + " ");
      }
      Console.WriteLine();
    }
 
  }   
 
  // Function for calculation
  public static void cal_main(int[,] A, int L, HashSet<int> x,int i, int j, int N, int M)
  {
    HashSet<int> s = new HashSet<int>();
 
    // Checking 8 cells and
    // then fill the current cell.
    if ((i - 2) >= 0)
      s.Add(A[i - 2,j]);
    if ((i + 2) < N)
      s.Add(A[i + 2,j]);
    if ((j - 2) >= 0)
      s.Add(A[i,j - 2]);
    if ((j + 2) < M)
      s.Add(A[i,j + 2]);
    if ((i - 1) >= 0 && (j - 1) >= 0)
      s.Add(A[i - 1,j - 1]);
    if ((i - 1) >= 0 && (j + 1) < M)
      s.Add(A[i - 1,j + 1]);
    if ((i + 1) < N && (j - 1) >= 0)
      s.Add(A[i + 1,j - 1]);
    if ((i + 1) < N && (j + 1) < M)
      s.Add(A[i + 1,j + 1]);
 
    // Set to contain distinct value
    // of integers in 8 cells.
    if (s.Contains(0))
      s.Remove(0);
 
    if (s.Count < L)
    {
      HashSet<int> w = new HashSet<int>();
 
      // Set contain remaining integers
      foreach (var num in x) {
        if(!x.Contains(num)){
          w.Add(num);
        }
      }
 
      // fill the current cell
      // with maximum remaining integer
      A[i,j] = w.Max();
    }
    else
    {
      // fill the current cells with L + 1 integer.
      A[i,j] = L + 1;
      L += 1;
 
      // Increase the value of L
      x.Add(L);
    }
  }   
 
  // Function to find the number
  // of distinct integers
  public static void solve(int N,int M)
  {
    // initialise the list (NxM) with 0.
    int[,] A = new int[N, M];
    for(int i = 0; i < N; i++){
      for(int j = 0; j < M; j++){
        A[i,j] = 0;
      }
    }
 
    // Set to contain distinct
    // value of integers from 1-L
    HashSet<int> x = new HashSet<int>();
    int L = 0;
 
    // Number of integer required
    // may vary from 1 to 4.
    if (N < 4 || M < 4)
    {
      if (N > M) // if N is greater
        for (int i = 0; i < N; i++)
          for (int j = 0; j < N; j++)
            cal_main(A, L, x, i, j, N, M);
 
      else
      {
        // if M is greater
        for (int i = 0; i < N; i++)
          for (int j = 0; j < N; j++)
            cal_main(A, L, x, i, j, N, M);
      }
    }
    else
    {
      // Number of integer required
      // must be 4
      L = 4;
 
      // 4×4 matrix to fill the NxM matrix.
      int[,] m4 =  {{1, 2, 3, 4},
                    {1, 2, 3, 4},
                    {3, 4, 1, 2},
                    {3, 4, 1, 2}};
 
      for (int i = 0; i < 4; i++)
        for (int j = 0; j < 4; j++)
          A[i,j] = m4[i,j];
      for (int i = 4; i < N; i++)
        for (int j = 0; j < 4; j++)
          A[i,j] = m4[i % 4,j];
      for (int j = 4; j < M; j++) 
        for (int i = 0; i < N; i++)
          A[i,j] = A[i,j % 4];
    }
    Console.WriteLine(L);
    display_matrix(A, N, M);
  }
 
  static void Main() {
 
    int N = 10;
    int M = 5;
    solve(N, M);
  }
}
 
// The code is contributed by Nidhi goel.


Javascript




// JavaScript implementation of
/// above approach
 
// Function to display the matrix
function display_matrix(A)
{
    for (let i of A)
        console.log(i)
}
 
// Function for calculation
function cal_main(A, L, x, i, j)
{
    let s = new Set()
 
    // Checking 8 cells and
    // then fill the current cell.
    if ((i - 2) >= 0)
        s.add(A[i - 2][j])
    if ((i + 2) < N)
        s.add(A[i + 2][j])
    if ((j - 2) >= 0)
        s.add(A[i][j - 2])
    if ((j + 2) < M)
        s.add(A[i][j + 2])
    if ((i - 1) >= 0 && (j - 1) >= 0)
        s.add(A[i - 1][j - 1])
    if ((i - 1) >= 0 && (j + 1) < M)
        s.add(A[i - 1][j + 1])
    if ((i + 1) < N && (j - 1) >= 0)
        s.add(A[i + 1][j - 1])
    if ((i + 1) < N && (j + 1) < M)
        s.add(A[i + 1][j + 1])
     
    // Set to contain distinct value
    // of integers in 8 cells.
    if (s.has(0))
        s.remove(0)
 
    if (s.length < L)
    {
        let w =new Set()
        // Set contain remaining integers
        for (let i of x)
        {
            if (!s.has(i))
                w.add(i)
        }
 
        // fill the current cell
        // with maximum remaining integer
        A[i][j] = Math.max(w)
    }
    else
    {
        // fill the current cells with L + 1 integer.
        A[i][j] = L + 1
        L += 1
 
        // Increase the value of L
        x.add(L)
    }
    return A
}
 
 
// Function to find the number
// of distinct integers
function solve(N, M)
{
    // initialise the list (NxM) with 0.
    let A = []
    for (var i = 0; i < N; i++)
    {
        let K = []
        for (var j = 0; j < M; j++)
            K.push(0)
        A.push(K)
    }
 
    // Set to contain distinct
    // value of integers from 1-L
    let x = new Set()
    let L = 0
 
    // Number of integer required
    // may vary from 1 to 4.
    if (N < 4 || M < 4)
    {
        if (N > M) // if N is greater
            for (var i = 0; i < N; i++)
                for (var j = 0; j < N; j++)
                    A = cal_main(A, L, x, i, j)
 
        else
        {
            // if M is greater
            for (var i = 0; i < N; i++)
                for (var j = 0; j < N; j++)
                    A = cal_main(A, L, x, i, j)
        }
    }
    else
    {
        // Number of integer required
        // must be 4
        L = 4
 
        // 4×4 matrix to fill the NxM matrix.
        let m4 = [[1, 2, 3, 4],
            [1, 2, 3, 4],
            [3, 4, 1, 2],
            [3, 4, 1, 2]]
 
        for (var i = 0; i < 4; i++)
            for (var j = 0; j < 4; j++)
                A[i][j] = m4[i][j]
        for (var i = 4; i < N; i++)
            for (var j = 0; j < 4; j++)
                A[i][j] = m4[i % 4][j]
        for (var j = 4; j < M; j++) 
            for (var i = 0; i < N; i++)
                A[i][j] = A[i][j % 4]
    }
    console.log(L)
    display_matrix(A)
}
     
// Driver Code
 
// sample input
// Number of rows and columns
let N = 10
let M = 5
solve(N, M)
 
// This code is contributed by phasing17


Output

4
1 2 3 4 1 
1 2 3 4 1 
3 4 1 2 3 
3 4 1 2 3 
1 2 3 4 1 
1 2 3 4 1 
3 4 1 2 3 
3 4 1 2 3 
1 2 3 4 1 
1 2 3 4 1 

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

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Most Popular

Recent Comments