Given N rows and M columns of a matrix, the task is to fill the matrix cells using first K integers such that:
- Each group of cells is denoted by a single integer.
- The difference between the group containing the maximum and the minimum number of cells should be minimum.
- All the cells of the same group should be contiguous i.e., for any group, two adjacent cells should follow the rule |xi+1 – xi| + |yi+1 – yi| = 1.
Examples:
Input: N = 5, M = 5, K = 6
Output:
1 1 1 1 1
3 2 2 2 2
3 3 3 4 4
5 5 5 4 4
5 6 6 6 6
Explanation:
The above matrix follows all the conditions above and dividing the matrix into K different groups.Input: N = 2, M = 3, K = 3
Output:
1 1 2
3 3 2
Explanation:
For making three group of the matrix each should have the group of size two.
So, to reduce the difference between the group containing maximum and minimum no of cells and all the matrix cells are used to make the K different groups having all the adjacent elements of the same group follow the |xi + 1 – xi| + |yi + 1 – yi| = 1 as well.
Approach: Below are the steps:
- Create the matrix of size N * M.
- To reduce the difference between group containing max and min no of cells, fill all the part with at least (N*M)/ K cells.
- The remaining part will contain (N * M)/ K + 1 no of cells.
- To follow the given rules, traverse the matrix and fill the matrix with the different parts accordingly.
- Print the matrix after the above steps.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to fill the matrix with // the given conditions void fillMatrix( int ** mat, int & row,
int & col, int sizeOfpart,
int noOfPart, int & start,
int m, int & flag)
{ // Count of parts with size sizeOfPart
for ( int i = 0; i < noOfPart; ++i) {
int count = 0;
while (count < sizeOfpart) {
// Assigning the cell
// with no of groups
mat[row][col] = start;
// Update row
if (col == m - 1
&& flag == 1) {
row++;
col = m;
flag = 0;
}
else if (col == 0
&& flag == 0) {
row++;
col = -1;
flag = 1;
}
// Update col
if (flag == 1) {
col++;
}
else {
col--;
}
// Increment count
count++;
}
// For new group increment start
start++;
}
} // Function to return the reference of // the matrix to be filled int ** findMatrix( int N, int M, int k)
{ // Create matrix of size N*M
int ** mat = ( int **) malloc (
N * sizeof ( int *));
for ( int i = 0; i < N; ++i) {
mat[i] = ( int *) malloc (
M * sizeof ( int ));
}
// Starting index of the matrix
int row = 0, col = 0;
// Size of one group
int size = (N * M) / k;
int rem = (N * M) % k;
// Element to assigned to matrix
int start = 1, flag = 1;
// Fill the matrix that have rem
// no of parts with size size + 1
fillMatrix(mat, row, col, size + 1,
rem, start, M, flag);
// Fill the remaining number of parts
// with each part size is 'size'
fillMatrix(mat, row, col, size,
k - rem, start, M, flag);
// Return the matrix
return mat;
} // Function to print the matrix void printMatrix( int ** mat, int N,
int M)
{ // Traverse the rows
for ( int i = 0; i < N; ++i) {
// Traverse the columns
for ( int j = 0; j < M; ++j) {
cout << mat[i][j] << " " ;
}
cout << endl;
}
} // Driver Code int main()
{ // Given N, M, K
int N = 5, M = 5, K = 6;
// Function Call
int ** mat = findMatrix(N, M, K);
// Function Call to print matrix
printMatrix(mat, N, M);
return 0;
} |
// Java program for the above approach import java.util.*;
class GFG{
static int N, M;
static int [][]mat;
static int row, col, start, flag;
// Function to fill the matrix with // the given conditions static void fillMatrix( int sizeOfpart,
int noOfPart,
int m)
{ // Count of parts with size sizeOfPart
for ( int i = 0 ; i < noOfPart; ++i)
{
int count = 0 ;
while (count < sizeOfpart)
{
// Assigning the cell
// with no of groups
mat[row][col] = start;
// Update row
if (col == m - 1 && flag == 1 )
{
row++;
col = m;
flag = 0 ;
}
else if (col == 0 && flag == 0 )
{
row++;
col = - 1 ;
flag = 1 ;
}
// Update col
if (flag == 1 )
{
col++;
}
else
{
col--;
}
// Increment count
count++;
}
// For new group increment start
start++;
}
} // Function to return the reference of // the matrix to be filled static void findMatrix( int k)
{ // Create matrix of size N*M
mat = new int [M][N];
// Starting index of the matrix
row = 0 ;
col = 0 ;
// Size of one group
int size = (N * M) / k;
int rem = (N * M) % k;
// Element to assigned to matrix
start = 1 ;
flag = 1 ;
// Fill the matrix that have rem
// no of parts with size size + 1
fillMatrix(size + 1 , rem, M);
// Fill the remaining number of parts
// with each part size is 'size'
fillMatrix(size, k - rem, M);
} // Function to print the matrix static void printMatrix()
{ // Traverse the rows
for ( int i = 0 ; i < N; ++i)
{
// Traverse the columns
for ( int j = 0 ; j < M; ++j)
{
System.out.print(mat[i][j] + " " );
}
System.out.println();
}
} // Driver Code public static void main(String[] args)
{ // Given N, M, K
N = 5 ;
M = 5 ;
int K = 6 ;
// Function Call
findMatrix(K);
// Function Call to print matrix
printMatrix();
} } // This code is contributed by Amit Katiyar |
# Python3 program for the above approach # Function to fill the matrix with # the given conditions def fillMatrix( sizeOfpart,noOfPart, m):
global start, flag, size, rem, row, col, mat
# Count of parts with size sizeOfPart
for i in range (noOfPart):
count = 0 ;
while (count < sizeOfpart):
# Assigning the cell
# with no of groups
mat[row][col] = start;
# Update row
if (col = = m - 1 and flag = = 1 ) :
row + = 1 ;
col = m;
flag = 0 ;
elif (col = = 0 and flag = = 0 ):
row + = 1 ;
col = - 1 ;
flag = 1 ;
# Update col
if (flag = = 1 ):
col + = 1 ;
else :
col - = 1 ;
# Increment count
count + = 1 ;
# For new group increment start
start + = 1 ;
# Function to return the reference of # the matrix to be filled def findMatrix(k):
global start, flag, size, rem, row, col, mat
# Create matrix of size N*M
mat = [ [ 0 ] * N for _ in range (M) ]
# Starting index of the matrix
row = 0 ;
col = 0 ;
# Size of one group
size = int ((N * M) / k);
rem = (N * M) % k;
# Element to assigned to matrix
start = 1 ;
flag = 1 ;
# Fill the matrix that have rem
# no of parts with size size + 1
fillMatrix(size + 1 , rem, M);
# Fill the remaining number of parts
# with each part size is 'size'
fillMatrix(size, k - rem, M);
# Function to print matrix def printMatrix():
for row in mat:
print ( * row)
# Driver Code # Given N, M, K N = 5 ;
M = 5 ;
K = 6 ;
# Function Call findMatrix(K); # Function Call to prmatrix printMatrix(); # This code is contributed by phasing17 |
// C# program for the // above approach using System;
class GFG{
static int N, M;
static int [,]mat;
static int row, col,
start, flag;
// Function to fill the // matrix with the given // conditions static void fillMatrix( int sizeOfpart,
int noOfPart,
int m)
{ // Count of parts with size
// sizeOfPart
for ( int i = 0;
i < noOfPart; ++i)
{
int count = 0;
while (count < sizeOfpart)
{
// Assigning the cell
// with no of groups
mat[row, col] = start;
// Update row
if (col == m - 1 &&
flag == 1)
{
row++;
col = m;
flag = 0;
}
else if (col == 0 &&
flag == 0)
{
row++;
col = -1;
flag = 1;
}
// Update col
if (flag == 1)
{
col++;
}
else
{
col--;
}
// Increment count
count++;
}
// For new group increment
// start
start++;
}
} // Function to return the // reference of the matrix // to be filled static void findMatrix( int k)
{ // Create matrix of
// size N*M
mat = new int [M, N];
// Starting index of the
// matrix
row = 0;
col = 0;
// Size of one group
int size = (N * M) / k;
int rem = (N * M) % k;
// Element to assigned to
// matrix
start = 1;
flag = 1;
// Fill the matrix that have
// rem no of parts with size
// size + 1
fillMatrix(size + 1,
rem, M);
// Fill the remaining number
// of parts with each part
// size is 'size'
fillMatrix(size, k - rem, M);
} // Function to print the // matrix static void printMatrix()
{ // Traverse the rows
for ( int i = 0; i < N; ++i)
{
// Traverse the columns
for ( int j = 0; j < M; ++j)
{
Console.Write(mat[i, j] +
" " );
}
Console.WriteLine();
}
} // Driver Code public static void Main(String[] args)
{ // Given N, M, K
N = 5;
M = 5;
int K = 6;
// Function Call
findMatrix(K);
// Function Call to
// print matrix
printMatrix();
} } // This code is contributed by 29AjayKumar |
// JS program for the above approach let N, M; let mat; let row, col, start, flag; // Function to fill the matrix with // the given conditions function fillMatrix( sizeOfpart,
noOfPart,
m)
{ // Count of parts with size sizeOfPart
for (let i = 0; i < noOfPart; ++i)
{
let count = 0;
while (count < sizeOfpart)
{
// Assigning the cell
// with no of groups
mat[row][col] = start;
// Update row
if (col == m - 1 && flag == 1)
{
row++;
col = m;
flag = 0;
}
else if (col == 0 && flag == 0)
{
row++;
col = -1;
flag = 1;
}
// Update col
if (flag == 1)
{
col++;
}
else
{
col--;
}
// Increment count
count++;
}
// For new group increment start
start++;
}
} // Function to return the reference of // the matrix to be filled function findMatrix(k)
{ // Create matrix of size N*M
mat = new Array(M);
for ( var i = 0; i < M; i++)
mat[i] = new Array(N).fill(0);
// Starting index of the matrix
row = 0;
col = 0;
// Size of one group
let size = Math.floor((N * M) / k);
let rem = (N * M) % k;
// Element to assigned to matrix
start = 1;
flag = 1;
// Fill the matrix that have rem
// no of parts with size size + 1
fillMatrix(size + 1, rem, M);
// Fill the remaining number of parts
// with each part size is 'size'
fillMatrix(size, k - rem, M);
} // Function to print the matrix function printMatrix()
{ // Traverse the rows
for (let i = 0; i < N; ++i)
{
// Traverse the columns
for (let j = 0; j < M; ++j)
{
process.stdout.write(mat[i][j] + " " );
}
console.log();
}
} // Driver Code // Given N, M, K
N = 5;
M = 5;
let K = 6;
// Function Call
findMatrix(K);
// Function Call to print matrix
printMatrix();
// This code is contributed by phasing17 |
1 1 1 1 1 3 2 2 2 2 3 3 3 4 4 5 5 5 4 4 5 6 6 6 6
Time Complexity: O(N * M)
Auxiliary Space: O(N * M)