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:

- let A, B and C are three cell and, B and C shared a side with A.
- Value of cell B and C must be distinct.
- Let L be the number of distinct integers in a grid.
- 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 = 2Output:L = 2 grid = {1, 2}Input:2 3Output: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.

- 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. - 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:**

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

*chevron_right*

*filter_none*

**Output:**

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.