# Check if it is possible to create a matrix such that every row has A 1s and every column has B 1s

Given four integers N, M, A, B where N is the number of rows and M is the number of columns, the task is to check if is possible to create a binary matrix of dimensions N x M such that every row has A number of 1s and every column has a B number of 1s. If any such matrix is possible then print it else print “-1”.

Examples:

Input: N = 3, M = 6, A = 2, B = 1
Output:
1 1 0 0 0 0
0 0 1 1 0 0
0 0 0 0 1 1
Explanation:
Every row has A ones i.e. 2 and every column has B ones i.e., 1.

Input: N = 2, M = 2, A = 2, B = 1
Output: No
Explanation:
It is not possible to create such a 2 x 2 matrix in which every row has 2 ones and every column has 1 ones because of the following two observations:
1. For every row place two ones because of which we will never be able to have one 1 in every column.
1 1
1 1

2. For every column place one 1 because of which we can never have 2 ones in every row.
1 0
0 1

Approach: The idea is to observe that since each row should have exactly A 1s, and each column should have exactly B 1s, hence the number of ones in all rows A * N should be equal to the number of 1s in all columns B * M. Thus, the desired matrix exists if and only if A*N = B*M. Below is the illustration: 1. Find any number 0 < d < M such that (d * N)%M == 0, where A % B is the remainder of dividing A by B.
2. In the first row of the desired matrix, insert the ones at the positions [1, A].
3. In the ith row, put the ones, as in the i – 1 row, but cyclically shifted by d to the right.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Number of rows ` `const` `int` `n = 3; ` ` `  `// Number of columns ` `const` `int` `m = 6; ` ` `  `// Function that prints the matrix ` `// if it exists ` `void` `printMatrix(``int` `arr[][m], ` `                 ``string ans) ` `{ ` `    ``if` `(ans == ``"No"``) ` `        ``cout << ``"No\n"``; ` `    ``else` `{ ` `        ``// Print if matrix exists ` `        ``for` `(``int` `i = 0; i < n; i++) { ` `            ``for` `(``int` `j = 0; j < m; j++) ` `                ``cout << arr[i][j] << ``" "``; ` `            ``cout << ``'\n'``; ` `        ``} ` `    ``} ` `} ` ` `  `// Function to check if it is possible ` `// to create a matrix such that every ` `// row has A 1s & every column has B 1s ` `void` `createMatrix(``int` `a, ``int` `b) ` `{ ` `    ``int` `matrix[n][m], row[n], col[m]; ` ` `  `    ``// Initialize all matrix ` `    ``// entries equal to 0 ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``for` `(``int` `j = 0; j < m; j++) { ` `            ``matrix[i][j] = 0; ` `        ``} ` `    ``} ` ` `  `    ``// Initialize the number of ` `    ``// ones required in every row ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``row[i] = a; ` ` `  `    ``// Initialize the number of ` `    ``// ones required in each column ` `    ``for` `(``int` `i = 0; i < m; i++) ` `        ``col[i] = b; ` ` `  `    ``int` `l = 0, d = 0; ` ` `  `    ``// Check if the total number of ` `    ``// ones required in every row is ` `    ``// not equal to total number of ` `    ``// ones required in every column ` `    ``// then print No ` `    ``if` `(n * a != m * b) ` `        ``printMatrix(matrix, ``"No"``); ` ` `  `    ``else` `{ ` ` `  `        ``for` `(``int` `i = 0; i < n; i++) { ` `            ``int` `j; ` `            ``if` `(l == m) ` `                ``l = 0; ` ` `  `            ``for` `(j = l; j < m; j++) { ` ` `  `                ``if` `(row[i] > 0 && col[j] > 0) { ` ` `  `                    ``// Fill a one if there is a ` `                    ``// place to be filled ` `                    ``matrix[i][j] = 1; ` ` `  `                    ``// Decrease the number of ` `                    ``// ones required in ith row ` `                    ``row[i]--; ` ` `  `                    ``// Decrease the number of ` `                    ``// ones required in jth column ` `                    ``col[j]--; ` `                    ``d = j; ` `                ``} ` `            ``} ` `            ``l = d + 1; ` `            ``if` `(row[i] != 0) { ` ` `  `                ``for` `(j = 0; j < m; j++) { ` ` `  `                    ``if` `(row[i] > 0 && col[j] > 0) { ` ` `  `                        ``// Fill a one if there is ` `                        ``// a place to be filled ` `                        ``matrix[i][j] = 1; ` ` `  `                        ``// Decrease the number of 1s ` `                        ``// required in ith row ` `                        ``row[i]--; ` `                        ``// Decrease the number of 1s ` `                        ``// required in jth column ` `                        ``col[j]--; ` `                        ``l = j + 1; ` `                    ``} ` `                    ``// Break the loop if no place ` `                    ``// is left for ones to filled ` `                    ``if` `(row[i] == 0) ` `                        ``break``; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// Function call to print the matrix ` `        ``printMatrix(matrix, ``"Yes"``); ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` ` `  `    ``// Number of ones required ` `    ``// in every row ` `    ``int` `a = 2; ` ` `  `    ``// Number of ones required ` `    ``// in every column ` `    ``int` `b = 1; ` ` `  `    ``// Function call ` `    ``createMatrix(a, b); ` `    ``return` `0; ` `} `

## Java

 `// Java program for the above approach ` `import` `java.util.*; ` ` `  `class` `GFG{ ` ` `  `// Number of rows ` `static` `int` `n = ``3``; ` ` `  `// Number of columns ` `static` `int` `m = ``6``; ` ` `  `// Function that prints the matrix ` `// if it exists ` `static` `void` `printMatrix(``int` `arr[][], ` `                        ``String ans) ` `{ ` `    ``if` `(ans == ``"No"``) ` `        ``System.out.print(``"No\n"``); ` `    ``else`  `    ``{ ` `         `  `        ``// Print if matrix exists ` `        ``for``(``int` `i = ``0``; i < n; i++) ` `        ``{ ` `            ``for``(``int` `j = ``0``; j < m; j++) ` `                ``System.out.print(arr[i][j] + ``" "``); ` `            ``System.out.println(); ` `        ``} ` `    ``} ` `} ` ` `  `// Function to check if it is possible ` `// to create a matrix such that every ` `// row has A 1s & every column has B 1s ` `static` `void` `createMatrix(``int` `a, ``int` `b) ` `{ ` `    ``int` `[][]matrix = ``new` `int``[n][m]; ` `    ``int` `[]row = ``new` `int``[n];  ` `    ``int` `[]col = ``new` `int``[m]; ` ` `  `    ``// Initialize all matrix ` `    ``// entries equal to 0 ` `    ``for``(``int` `i = ``0``; i < n; i++) ` `    ``{ ` `        ``for``(``int` `j = ``0``; j < m; j++) ` `        ``{ ` `            ``matrix[i][j] = ``0``; ` `        ``} ` `    ``} ` ` `  `    ``// Initialize the number of ` `    ``// ones required in every row ` `    ``for``(``int` `i = ``0``; i < n; i++) ` `        ``row[i] = a; ` ` `  `    ``// Initialize the number of ` `    ``// ones required in each column ` `    ``for``(``int` `i = ``0``; i < m; i++) ` `        ``col[i] = b; ` ` `  `    ``int` `l = ``0``, d = ``0``; ` ` `  `    ``// Check if the total number of ` `    ``// ones required in every row is ` `    ``// not equal to total number of ` `    ``// ones required in every column ` `    ``// then print No ` `    ``if` `(n * a != m * b) ` `        ``printMatrix(matrix, ``"No"``); ` ` `  `    ``else`  `    ``{ ` `        ``for``(``int` `i = ``0``; i < n; i++) ` `        ``{ ` `            ``int` `j; ` `            ``if` `(l == m) ` `                ``l = ``0``; ` ` `  `            ``for``(j = l; j < m; j++) ` `            ``{ ` `                ``if` `(row[i] > ``0` `&& col[j] > ``0``) ` `                ``{ ` `                     `  `                    ``// Fill a one if there is a ` `                    ``// place to be filled ` `                    ``matrix[i][j] = ``1``; ` ` `  `                    ``// Decrease the number of ` `                    ``// ones required in ith row ` `                    ``row[i]--; ` ` `  `                    ``// Decrease the number of ` `                    ``// ones required in jth column ` `                    ``col[j]--; ` `                    ``d = j; ` `                ``} ` `            ``} ` `            ``l = d + ``1``; ` `            ``if` `(row[i] != ``0``) ` `            ``{ ` `                ``for``(j = ``0``; j < m; j++) ` `                ``{ ` `                    ``if` `(row[i] > ``0` `&& col[j] > ``0``)  ` `                    ``{ ` `                         `  `                        ``// Fill a one if there is ` `                        ``// a place to be filled ` `                        ``matrix[i][j] = ``1``; ` ` `  `                        ``// Decrease the number of 1s ` `                        ``// required in ith row ` `                        ``row[i]--; ` `                        ``// Decrease the number of 1s ` `                        ``// required in jth column ` `                        ``col[j]--; ` `                        ``l = j + ``1``; ` `                    ``} ` `                     `  `                    ``// Break the loop if no place ` `                    ``// is left for ones to filled ` `                    ``if` `(row[i] == ``0``) ` `                        ``break``; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// Function call to print the matrix ` `        ``printMatrix(matrix, ``"Yes"``); ` `    ``} ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` ` `  `    ``// Number of ones required ` `    ``// in every row ` `    ``int` `a = ``2``; ` ` `  `    ``// Number of ones required ` `    ``// in every column ` `    ``int` `b = ``1``; ` ` `  `    ``// Function call ` `    ``createMatrix(a, b); ` `} ` `} ` ` `  `// This code is contributed by amal kumar choubey`

## Python3

 `# Python3 program for the above approach ` ` `  `# Number of rows ` `n ``=` `3` ` `  `# Number of columns ` `m ``=` `6` ` `  `# Function that prints the matrix ` `# if it exists ` `def` `printMatrix(arr, ans): ` `     `  `    ``if` `(ans ``=``=` `"No"``): ` `        ``print``(``"No"``) ` `     `  `    ``else``: ` `         `  `        ``# Print if matrix exists ` `        ``for` `i ``in` `range``(n): ` `            ``for` `j ``in` `range``(m): ` `                ``print``(arr[i][j], end ``=` `" "``) ` `                 `  `            ``print``() ` ` `  `# Function to check if it is possible ` `# to create a matrix such that every ` `# row has A 1s & every column has B 1s ` `def` `createMatrix(a, b): ` `     `  `    ``matrix ``=` `[[``0` `for` `i ``in` `range``(m)] ` `                 ``for` `i ``in` `range``(n)] ` `    ``row ``=` `[a ``for` `i ``in` `range``(n)] ` `    ``col ``=` `[b ``for` `i ``in` `range``(m)] ` ` `  `    ``l ``=` `0` `    ``d ``=` `0` ` `  `    ``# Check if the total number of ` `    ``# ones required in every row is ` `    ``# not equal to total number of ` `    ``# ones required in every column ` `    ``# then prNo ` `    ``if` `(n ``*` `a !``=` `m ``*` `b): ` `        ``printMatrix(matrix, ``"No"``) ` ` `  `    ``else``: ` `        ``for` `i ``in` `range``(n): ` `            ``j ``=` `0` `             `  `            ``if` `(l ``=``=` `m): ` `                ``l ``=` `0` ` `  `            ``for` `j ``in` `range``(l, m): ` `                ``if` `(row[i] > ``0` `and` `col[j] > ``0``): ` ` `  `                    ``# Fill a one if there is a ` `                    ``# place to be filled ` `                    ``matrix[i][j] ``=` `1` ` `  `                    ``# Decrease the number of ` `                    ``# ones required in ith row ` `                    ``row[i] ``-``=` `1` ` `  `                    ``# Decrease the number of ` `                    ``# ones required in jth column ` `                    ``col[j] ``-``=` `1` `                    ``d ``=` `j ` ` `  `            ``l ``=` `d ``+` `1` `            ``if` `(row[i] !``=` `0``): ` `                ``for` `j ``in` `range``(m): ` `                    ``if` `(row[i] > ``0` `and` `col[j] > ``0``): ` ` `  `                        ``# Fill a one if there is ` `                        ``# a place to be filled ` `                        ``matrix[i][j] ``=` `1` ` `  `                        ``# Decrease the number of 1s ` `                        ``# required in ith row ` `                        ``row[i] ``-``=` `1` `                         `  `                        ``# Decrease the number of 1s ` `                        ``# required in jth column ` `                        ``col[j] ``-``=` `1` `                        ``l ``=` `j ``+` `1` ` `  `                    ``# Break the loop if no place ` `                    ``# is left for ones to filled ` `                    ``if` `(row[i] ``=``=` `0``): ` `                        ``break` ` `  `        ``# Function call to prthe matrix ` `        ``printMatrix(matrix, ``"Yes"``) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``# Number of ones required ` `    ``# in every row ` `    ``a ``=` `2` ` `  `    ``# Number of ones required ` `    ``# in every column ` `    ``b ``=` `1` ` `  `    ``# Function call ` `    ``createMatrix(a, b) ` ` `  `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach ` `using` `System; ` `class` `GFG{ ` ` `  `// Number of rows ` `static` `int` `n = 3; ` ` `  `// Number of columns ` `static` `int` `m = 6; ` ` `  `// Function that prints the matrix ` `// if it exists ` `static` `void` `printMatrix(``int` `[,]arr, ` `                        ``String ans) ` `{ ` `    ``if` `(ans == ``"No"``) ` `        ``Console.Write(``"No\n"``); ` `    ``else`  `    ``{ ` `         `  `        ``// Print if matrix exists ` `        ``for``(``int` `i = 0; i < n; i++) ` `        ``{ ` `            ``for``(``int` `j = 0; j < m; j++) ` `                ``Console.Write(arr[i, j] + ``" "``); ` `            ``Console.WriteLine(); ` `        ``} ` `    ``} ` `} ` ` `  `// Function to check if it is possible ` `// to create a matrix such that every ` `// row has A 1s & every column has B 1s ` `static` `void` `createMatrix(``int` `a, ``int` `b) ` `{ ` `    ``int` `[,]matrix = ``new` `int``[n, m]; ` `    ``int` `[]row = ``new` `int``[n];  ` `    ``int` `[]col = ``new` `int``[m]; ` ` `  `    ``// Initialize all matrix ` `    ``// entries equal to 0 ` `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{ ` `        ``for``(``int` `j = 0; j < m; j++) ` `        ``{ ` `            ``matrix[i, j] = 0; ` `        ``} ` `    ``} ` ` `  `    ``// Initialize the number of ` `    ``// ones required in every row ` `    ``for``(``int` `i = 0; i < n; i++) ` `        ``row[i] = a; ` ` `  `    ``// Initialize the number of ` `    ``// ones required in each column ` `    ``for``(``int` `i = 0; i < m; i++) ` `        ``col[i] = b; ` ` `  `    ``int` `l = 0, d = 0; ` ` `  `    ``// Check if the total number of ` `    ``// ones required in every row is ` `    ``// not equal to total number of ` `    ``// ones required in every column ` `    ``// then print No ` `    ``if` `(n * a != m * b) ` `        ``printMatrix(matrix, ``"No"``); ` ` `  `    ``else`  `    ``{ ` `        ``for``(``int` `i = 0; i < n; i++) ` `        ``{ ` `            ``int` `j; ` `            ``if` `(l == m) ` `                ``l = 0; ` ` `  `            ``for``(j = l; j < m; j++) ` `            ``{ ` `                ``if` `(row[i] > 0 && col[j] > 0) ` `                ``{ ` `                     `  `                    ``// Fill a one if there is a ` `                    ``// place to be filled ` `                    ``matrix[i,j] = 1; ` ` `  `                    ``// Decrease the number of ` `                    ``// ones required in ith row ` `                    ``row[i]--; ` ` `  `                    ``// Decrease the number of ` `                    ``// ones required in jth column ` `                    ``col[j]--; ` `                    ``d = j; ` `                ``} ` `            ``} ` `            ``l = d + 1; ` `            ``if` `(row[i] != 0) ` `            ``{ ` `                ``for``(j = 0; j < m; j++) ` `                ``{ ` `                    ``if` `(row[i] > 0 && col[j] > 0)  ` `                    ``{ ` `                         `  `                        ``// Fill a one if there is ` `                        ``// a place to be filled ` `                        ``matrix[i,j] = 1; ` ` `  `                        ``// Decrease the number of 1s ` `                        ``// required in ith row ` `                        ``row[i]--; ` `                        ``// Decrease the number of 1s ` `                        ``// required in jth column ` `                        ``col[j]--; ` `                        ``l = j + 1; ` `                    ``} ` `                     `  `                    ``// Break the loop if no place ` `                    ``// is left for ones to filled ` `                    ``if` `(row[i] == 0) ` `                        ``break``; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// Function call to print the matrix ` `        ``printMatrix(matrix, ``"Yes"``); ` `    ``} ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` ` `  `    ``// Number of ones required ` `    ``// in every row ` `    ``int` `a = 2; ` ` `  `    ``// Number of ones required ` `    ``// in every column ` `    ``int` `b = 1; ` ` `  `    ``// Function call ` `    ``createMatrix(a, b); ` `} ` `} ` ` `  `// This code is contributed by gauravrajput1`

Output:

```1 1 0 0 0 0
0 0 1 1 0 0
0 0 0 0 1 1
```

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

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.