Given a binary matrix B[][] of size N*M, the task is to find a matrix A[][] of the same size such that B[i][j] is the bitwise AND of all the elements in ith row and jth column of A[][].
Examples:
Input: B[][] = { {1, 0, 1}, {0, 0, 0} }
Output: { {1, 1, 1}, {1, 0, 1} }
Explanation:
1 1 1 ? 1 0 1
1 0 1 0 0 0Input: B[][] = { {0, 0}, {1, 1} }
Output: -1
Approach: Follow the below idea to solve the problem:
If any cell contains 1 means that in every cell of that row and column there should not be any 0 because if it is it will dominate 1.
Follow the steps to solve this problem:
- Calculate the number of rows and columns of a given matrix.
- Store the matrix in a temporary matrix say original.
- Find out the rows and columns containing 1 and insert them into two sets (say row and col).
- Traverse the set and then update the row and column with 1.
- Create a variable result and store the matrix in a temporary matrix say result.
- Clear the set row and col.
- Find out the rows and columns containing 0 and insert them into set.
- Traverse the set and update 0 to every row and every column.
- Check if the changed matrix is not equal to the original matrix then print -1.
- Else print matrix result i.e., originally the matrix A which is obtained from matrix B.
Below is the implementation of the above approach.
// C++ code to implement the approach #include <bits/stdc++.h> using namespace std;
// Function to find the matrix A from B void solve(vector<vector< bool > >& arr)
{ int n = arr.size();
int m = arr[0].size();
set< int > row;
set< int > col;
vector<vector< bool > > original(arr);
// first find rows and columns containing 1
// and insert into set
for ( int i = 0; i < n; i++) {
for ( int j = 0; j < m; j++) {
if (arr[i][j]) {
row.insert(i);
col.insert(j);
}
}
}
// Set 1 to every row
for ( auto it : row) {
for ( int i = 0; i < m; i++) {
arr[it][i] = 1;
}
}
// Set 1 to every column
for ( auto it : col) {
for ( int i = 0; i < n; i++) {
arr[i][it] = 1;
}
}
vector<vector< bool > > result(arr);
row.clear();
col.clear();
// first find rows and columns containing 0
// and insert into set
for ( int i = 0; i < n; i++) {
for ( int j = 0; j < m; j++) {
if (!arr[i][j]) {
row.insert(i);
col.insert(j);
}
}
}
// Set 0 to every row
for ( auto it : row) {
for ( int i = 0; i < m; i++) {
arr[it][i] = 0;
}
}
// Set 0 to every column
for ( auto it : col) {
for ( int i = 0; i < n; i++) {
arr[i][it] = 0;
}
}
// If the modified matrix and original matrix
// is not equal then print -1
if (arr != original) {
cout << -1 << endl;
}
// Else print the matrix res
else {
for ( int i = 0; i < n; i++) {
for ( int j = 0; j < m; j++) {
cout << result[i][j] << " " ;
}
cout << endl;
}
}
} // Driver Code int main()
{ vector<vector< bool > > v = { { 1, 0, 1 }, { 0, 0, 0 } };
solve(v);
return 0;
} |
// Java code to implement the approach import java.io.*;
import java.util.*;
class GFG {
static void solve( boolean [][] arr)
{
int n = arr.length;
int m = arr[ 0 ].length;
Set<Integer> row = new HashSet<>();
Set<Integer> col = new HashSet<>();
boolean [][] original = new boolean [n][m];
for ( int i = 0 ; i < n; i++) {
for ( int j = 0 ; j < m; j++) {
original[i][j] = arr[i][j];
}
}
// first find rows and columns containing 1
// and insert into set
for ( int i = 0 ; i < n; i++) {
for ( int j = 0 ; j < m; j++) {
if (arr[i][j]) {
row.add(i);
col.add(j);
}
}
}
for (var it : row) {
for ( int i = 0 ; i < m; i++) {
arr[it][i] = true ;
}
}
for (var it : col) {
for ( int i = 0 ; i < n; i++) {
arr[i][it] = true ;
}
}
boolean [][] result = new boolean [n][m];
for ( int i = 0 ; i < n; i++) {
for ( int j = 0 ; j < m; j++) {
result[i][j] = arr[i][j];
}
}
row.clear();
col.clear();
// first find rows and columns containing 0
// and insert into set
for ( int i = 0 ; i < n; i++) {
for ( int j = 0 ; j < m; j++) {
if (!arr[i][j]) {
row.add(i);
col.add(j);
}
}
}
// Set 0 to every row
for (var it : row) {
for ( int i = 0 ; i < m; i++) {
arr[it][i] = false ;
}
}
// Set 0 to every column
for (var it : col) {
for ( int i = 0 ; i < n; i++) {
arr[i][it] = false ;
}
}
// If the modified matrix and original matrix
// is not equal then print -1
if (arr == original) {
System.out.println(- 1 );
}
// Else print the matrix res
else {
for ( int i = 0 ; i < n; i++) {
for ( int j = 0 ; j < m; j++) {
if (result[i][j]) {
System.out.print( 1 + " " );
}
else {
System.out.print( 0 + " " );
}
}
System.out.println();
}
}
}
public static void main(String[] args)
{
boolean [][] v = { { true , false , true },
{ false , false , false } };
solve(v);
}
} // This code is contributed by lokeshmvs21. |
# Python code to implement the approach import copy
# Function to find the matrix A from B def solve(arr):
n = len (arr)
m = len (arr[ 0 ])
row = set ()
col = set ()
original = copy.deepcopy(arr)
# first find rows and columns containing 1
# and insert into set
for i in range (n):
for j in range (m):
if (arr[i][j]):
row.add(i)
col.add(j)
# Set 1 to every row
for it in row:
for i in range (m):
arr[it][i] = 1
# Set 1 to every column
for it in col:
for i in range (n):
arr[i][it] = 1
result = copy.deepcopy(arr)
row.clear()
col.clear()
# first find rows and columns containing 0
# and insert into set
for i in range (n):
for j in range (m):
if ( not (arr[i][j])):
row.add(i)
col.add(j)
# Set 0 to every row
for it in row:
for i in range (m):
arr[it][i] = 0
# Set 0 to every column
for it in col:
for i in range (n):
arr[i][it] = 0
# If the modified matrix and original matrix
# is not equal then print -1
if (arr ! = original):
print ( "-1" )
# Else print the matrix res
else :
for i in range (n):
for j in range (m):
print (result[i][j], end = " " )
print ()
# Driver Code v = [[ 1 , 0 , 1 ],[ 0 , 0 , 0 ]]
solve(v) # This code is contributed by Pushpesh Raj. |
// C# code to implement the approach using System;
using System.Collections.Generic;
class GFG {
static void solve( bool [, ] arr)
{
int n = arr.GetLength(0);
int m = arr.GetLength(1);
HashSet< int > row = new HashSet< int >();
HashSet< int > col = new HashSet< int >();
bool [, ] original = new bool [n, m];
for ( int i = 0; i < n; i++) {
for ( int j = 0; j < m; j++) {
original[i, j] = arr[i, j];
}
}
// first find rows and columns containing 1
// and insert into set
for ( int i = 0; i < n; i++) {
for ( int j = 0; j < m; j++) {
if (arr[i, j]) {
row.Add(i);
col.Add(j);
}
}
}
foreach ( var it in row)
{
for ( int i = 0; i < m; i++) {
arr[it, i] = true ;
}
}
foreach ( var it in col)
{
for ( int i = 0; i < n; i++) {
arr[i, it] = true ;
}
}
bool [, ] result = new bool [n, m];
for ( int i = 0; i < n; i++) {
for ( int j = 0; j < m; j++) {
result[i, j] = arr[i, j];
}
}
row.Clear();
col.Clear();
// first find rows and columns containing 0
// and insert into set
for ( int i = 0; i < n; i++) {
for ( int j = 0; j < m; j++) {
if (!arr[i, j]) {
row.Add(i);
col.Add(j);
}
}
}
// Set 0 to every row
foreach ( var it in row)
{
for ( int i = 0; i < m; i++) {
arr[it, i] = false ;
}
}
// Set 0 to every column
foreach ( var it in col)
{
for ( int i = 0; i < n; i++) {
arr[i, it] = false ;
}
}
// If the modified matrix and original matrix
// is not equal then print -1
if (arr == original) {
Console.WriteLine(-1);
}
// Else print the matrix res
else {
for ( int i = 0; i < n; i++) {
for ( int j = 0; j < m; j++) {
if (result[i, j]) {
Console.Write(1 + " " );
}
else {
Console.Write(0 + " " );
}
}
Console.WriteLine();
}
}
}
public static void Main( string [] args)
{
bool [, ] v
= new bool [2, 3] { { true , false , true },
{ false , false , false } };
solve(v);
}
} // This code is contributed by Tapesh(tapeshdua420) |
// Javascript code to implement the approach // Function to find the matrix A from B function solve(arr) {
let n = arr.length;
let m = arr[0].length;
// Set to store rows and columns
let row = new Set();
let col = new Set();
let original = arr;
// first find rows and columns containing 1
// and insert into set
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
if (arr[i][j]) {
row.add(i);
col.add(j);
}
}
}
// Set 1 to every row
for (let it of row) {
for (let i = 0; i < m; i++) {
arr[it][i] = 1;
}
}
// Set 1 to every column
for (let it of col) {
for (let i = 0; i < n; i++) {
arr[i][it] = 1;
}
}
var result = JSON.parse(JSON.stringify(arr));
row.clear();
col.clear();
// first find rows and columns containing 0
// and insert into set
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
if (!arr[i][j]) {
row.add(i);
col.add(j);
}
}
}
// Set 0 to every row
for (let it of row) {
for (let i = 0; i < m; i++) {
arr[it][i] = 0;
}
}
// Set 0 to every column
for (let it of col) {
for (let i = 0; i < n; i++) {
arr[i][it] = 0;
}
}
// If the modified matrix and original matrix is not equal then print -1
if (JSON.stringify(arr) != JSON.stringify(original))
console.log( "-1" );
// else print the matrix res
else {
for ( var i = 0; i < n; i++) {
for ( var j = 0; j < m; j++) {
process.stdout.write(result[i][j] + " " );
}
console.log();
}
}
} // Driver Code let v = [ [1, 0, 1],
[0, 0, 0]
]; solve(v); // This code is contributed by Tapesh(tapeshdua420) |
1 1 1 1 0 1
Time Complexity: O(N*M)
Auxiliary Space: O(N*M)