Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

Check if matrix A can be converted to B by changing parity of corner elements of any submatrix

Given two binary matrices, A[][] and B[][] of N×M. In a single operation, one can choose a sub-matrix (min of 2 rows and 2c columns) and change the parity of the corner elements i.e. 1 can be changed to a 0, and 0 can be changed to a 1. The task is to check if matrix A can be converted to B using any number of operations.

Examples:  



Input: A[][] = {{0, 1, 0}, {0, 1, 0}, {1, 0, 0}}, 
B[][] = {{1, 0, 0}, {1, 0, 0}, {1, 0, 0}} 
Output: Yes 
Choose the sub-matrix whose top-left corner is (0, 0) 
and bottom-right corner is (1, 1). 
Changing the parity of the corner elements 
of this sub-matrix will convert A[][] to B[][]

Input: A[][] = {{0, 1, 0, 1}, {1, 0, 1, 0}, {0, 1, 0, 1}}, 
B[][] = {{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}} 
Output: No 



Approach: The first thing to notice is that despite the conversions the total parity of both the matrix will remain the same. Hence, check if a[i][j] is not same as b[i][j] then change the parity of the corner elements of the sub-matrix whose left top corner is (0, 0) and right bottom corner is (i, j) for 1 ? i, j. After performing parity change for every a[i][j] which is not equal to b[i][j], check if both the matrix are the same or not. If they are the same, we can change A to B. 

Below is the implementation of the above approach: 




// C++ implementation of the
// above approach
 
#include <bits/stdc++.h>
using namespace std;
#define N 3
#define M 3
 
// Boolean function that returns
// true or false
bool check(int a[N][M], int b[N][M])
{
    // Traverse for all elements
    for (int i = 1; i < N; i++) {
        for (int j = 1; j < M; j++) {
 
            // If both are not equal
            if (a[i][j] != b[i][j]) {
 
                // Change the parity of
                // all corner elements
                a[i][j] ^= 1;
                a[0][0] ^= 1;
                a[0][j] ^= 1;
                a[i][0] ^= 1;
            }
        }
    }
 
    // Check if A is equal to B
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
 
            // Not equal
            if (a[i][j] != b[i][j])
                return false;
        }
    }
    return true;
}
 
// Driver Code
int main()
{
    // First binary matrix
    int a[N][N] = { { 0, 1, 0 },
                    { 0, 1, 0 },
                    { 1, 0, 0 } };
 
    // Second binary matrix
    int b[N][N] = { { 1, 0, 0 },
                    { 1, 0, 0 },
                    { 1, 0, 0 } };
 
    if (check(a, b))
        cout << "Yes";
    else
        cout << "No";
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java implementation of the


// above approach



import java.io.*;



 



public class GFG {



 



    static final int N = 3, M = 3;



 



    // Boolean function that returns




    // true or false




    static boolean check(int a[][], int b[][])




    {




        // Traverse for all elements




        for (int i = 1; i < N; i++) {




            for (int j = 1; j < M; j++) {



 



                // If both are not equal




                if (a[i][j] != b[i][j]) {



 



                    // Change the parity of




                    // all corner elements




                    a[i][j] ^= 1;




                    a[0][0] ^= 1;




                    a[0][j] ^= 1;




                    a[i][0] ^= 1;




                }




            }




        }



 



        // Check if A is equal to B




        for (int i = 0; i < N; i++) {




            for (int j = 0; j < M; j++) {



 



                // Not equal




                if (a[i][j] != b[i][j])




                    return false;




            }




        }




        return true;




    }



 



    // Driver Code




    public static void main(String args[])




    {




        // First binary matrix




        int a[][]




            = { { 0, 1, 0 }, { 0, 1, 0 }, { 1, 0, 0 } };



 



        // Second binary matrix




        int b[][]




            = { { 1, 0, 0 }, { 1, 0, 0 }, { 1, 0, 0 } };



 



        if (check(a, b))




            System.out.print("Yes");




        else




            System.out.print("No");




    }



}


 


// This code is contributed by Arnab Kundu


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python 3 implementation of the


# above approach



N = 3




M = 3



 


# Boolean function that returns


# true or false



def check(a, b):




     



    # Traverse for all elements




    for i in range(1, N, 1):




        for j in range(1, M, 1):




             



            # If both are not equal




            if (a[i][j] != b[i][j]):




                 



                # Change the parity of




                # all corner elements




                a[i][j] ^= 1




                a[0][0] ^= 1




                a[0][j] ^= 1




                a[i][0] ^= 1



 



    # Check if A is equal to B




    for i in range(N):




        for j in range(M):




             



            # Not equal




            if (a[i][j] != b[i][j]):




                return False




     



    return True



 


# Driver Code



if __name__ == '__main__':




     



    # First binary matrix




    a = [[0, 1, 0],




         [0, 1, 0],




         [1, 0, 0]]



 



    # Second binary matrix




    b = [[1, 0, 0],




         [1, 0, 0],




         [1, 0, 0]]



 



    if (check(a, b)):




        print("Yes")




    else:




        print("No")



 


# This code is contributed by


# Surendra_Gangwar


















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# implementation of the 


// above approach 



using System; 



 



class GFG



{



     



static readonly int N = 3,M =3; 



 


// Boolean function that returns 


// true or false 



static bool check(int [,]a, int [,]b) 



{ 



    // Traverse for all elements 




    for (int i = 1; i < N; i++) 




    { 




        for (int j = 1; j < M; j++) 




        { 



 



            // If both are not equal 




            if (a[i,j] != b[i,j]) 




            { 



 



                // Change the parity of 




                // all corner elements 




                a[i,j] ^= 1; 




                a[0,0] ^= 1; 




                a[0,j] ^= 1; 




                a[i,0] ^= 1; 




            } 




        } 




    } 



 



    // Check if A is equal to B 




    for (int i = 0; i < N; i++)




    { 




        for (int j = 0; j < M; j++)




        { 



 



            // Not equal 




            if (a[i,j] != b[i,j]) 




                return false; 




        } 




    } 




    return true; 



} 


 


// Driver Code 



public static void Main(String []args)



{ 



    // First binary matrix 




    int [,]a = { { 0, 1, 0 }, 




                    { 0, 1, 0 }, 




                    { 1, 0, 0 } }; 



 



    // Second binary matrix 




    int [,]b = { { 1, 0, 0 }, 




                    { 1, 0, 0 }, 




                    { 1, 0, 0 } }; 



 



    if (check(a, b)) 




        Console.Write( "Yes"); 




    else




        Console.Write( "No"); 



} 


}


 


// This code has been contributed by 29AjayKumar


















                        






                        























                                    



                                    




                                    




                                    


                                



















<?php


// PHP implementation of the above approach 


 



$N = 3; 




$M = 3 ;



 


// Boolean function that returns 


// true or false 



function check($a, $b) 



{ 



    // Traverse for all elements 




    for ($i = 1; $i < $GLOBALS['N']; $i++) 




    { 




        for ($j = 1; $j < $GLOBALS['M']; $j++) 




        { 



 



            // If both are not equal 




            if ($a[$i][$j] != $b[$i][$j]) 




            { 



 



                // Change the parity of 




                // all corner elements 




                $a[$i][$j] ^= 1; 




                $a[0][0] ^= 1; 




                $a[0][$j] ^= 1; 




                $a[$i][0] ^= 1; 




            } 




        } 




    } 



 



    // Check if A is equal to B 




    for ($i = 0; $i < $GLOBALS['N']; $i++) 




    { 




        for ($j = 0; $j < $GLOBALS['M']; $j++) 




        { 



 



            // Not equal 




            if ($a[$i][$j] != $b[$i][$j]) 




                return false; 




        } 




    } 




    return true; 



} 


 



    // Driver Code 




    // First binary matrix 




    $a = array(array( 0, 1, 0 ), 




                array( 0, 1, 0 ), 




                array( 1, 0, 0 ) ); 



 



    // Second binary matrix 




    $b = array( array( 1, 0, 0 ), 




                array(1, 0, 0 ), 




                array( 1, 0, 0 ) ); 



 



    if (check($a, $b)) 




        echo "Yes"; 




    else




        echo "No"; 



 


// This code is contributed by Ryuga


?>


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script>


// javascript implementation of the 


// above approach     



var N = 3, M = 3;



 



    // Boolean function that returns




    // true or false




    function check(a , b) {




        // Traverse for all elements




        for (i = 1; i < N; i++) {




            for (j = 1; j < M; j++) {



 



                // If both are not equal




                if (a[i][j] != b[i][j]) {



 



                    // Change the parity of




                    // all corner elements




                    a[i][j] ^= 1;




                    a[0][0] ^= 1;




                    a[0][j] ^= 1;




                    a[i][0] ^= 1;




                }




            }




        }



 



        // Check if A is equal to B




        for (i = 0; i < N; i++) {




            for (j = 0; j < M; j++) {



 



                // Not equal




                if (a[i][j] != b[i][j])




                    return false;




            }




        }




        return true;




    }



 



    // Driver Code




     



        // First binary matrix




        var a = [ [ 0, 1, 0 ], 




                [ 0, 1, 0 ], 




                [ 1, 0, 0 ] ];



 



        // Second binary matrix




        var b = [ [ 1, 0, 0 ], 




                [ 1, 0, 0 ], 




                [ 1, 0, 0 ] ];



 



        if (check(a, b))




            document.write("Yes");




        else




            document.write("No");



 


// This code contributed by aashish1995


</script>


















                        






                        








Output

Yes


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

	

        Article Tags : 
        

            Bit Magic
DSA
Matrix        


		
	

	


      

      

          
Recommended Articles

      

      

          
          
1. Check if any row of the matrix can be converted to the elements present in the target row

          
2. Check if a matrix can be converted to another by repeatedly adding any value to X consecutive elements in a row or column

          
3. Check if string A can be converted to string B by changing A[i] to A[i+1] or A[i]..A[i+K-1] to A[i]+1 each

          
4. Check if matrix can be converted to another matrix by transposing square sub-matrices

          
5. Check if a given matrix can be converted to another given matrix by row and column exchanges

          
6. Parity of count of letters whose position and frequency have same parity

          
7. Check if all the elements can be made of same parity by inverting adjacent elements

          
8. Maximum sum of any submatrix of a Matrix which is sorted row-wise and column-wise

          
9. Check if a path exists for a cell valued 1 to reach the bottom right corner of a Matrix before any cell valued 2

          
10. Find the maximum cost path from the bottom-left corner to the top-right corner

          
11. Check if all array elements can be converted to K using given operations

          
12. Check if an array can be converted to another given array by swapping pairs of unequal elements

          
13. Check if all array elements can be converted to pronic numbers by rotating digits

          
14. C++ Program to Check if all array elements can be converted to pronic numbers by rotating digits

          
15. Java Program to Check if all array elements can be converted to pronic numbers by rotating digits

          
16. Python3 Program to Check if all array elements can be converted to pronic numbers by rotating digits

          
17. Javascript Program to Check if all array elements can be converted to pronic numbers by rotating digits

          
18. Check if a Zero Array can be converted to a given Array by incrementing some elements with X^i

          
19. Check if array can be sorted by swapping adjacent elements of opposite parity

          
20. Check if a matrix contains a square submatrix with 0 as boundary element

          
21. Check if an Array can be Sorted by picking only the corner Array elements

          
22. Maximize array product by changing any array element arr[i] to (-1)*arr[i] - 1 any number of times

          
23. Remove any corner X rows and columns from a matrix

          
24. Check if a given string can be converted to a Balanced Bracket Sequence

          
25. Check if a string can be converted  to another string by replacing vowels and consonants