Skip to content
Related Articles
Check if it is possible to create a matrix such that every row has A 1s and every column has B 1s
• Last Updated : 08 Jun, 2021

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 print 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`

## Javascript

 ``
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up