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 : 10 Sep, 2020

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 mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up