Related Articles

# Minimum swaps needed to convert given Binary Matrix A to Binary Matrix B

• Last Updated : 09 Jul, 2021

Given two binary matrices, A[][] and B[][] of size N×M, the task is to find the minimum number of swaps of the elements of matrix A, needed to convert matrix A into matrix B. If it is impossible to do so then print “-1“.

Examples :

Input: A[][] = {{1, 1, 0}, {0, 0, 1}, {0, 1, 0}}, B[][] = {{0, 0, 1}, {0, 1, 0}, {1, 1, 0}}
Output: 3
Explanation:
One possible way to convert matrix A into B is:

1. Swap the element A with A. Thereafter the matrix A modifies to {{ 0, 1, 1}, {0, 0, 1}, {0, 1, 0}}.
2. Swap the element A with A. Thereafter the matrix A modifies to {{ 0, 0, 1}, {0, 1, 1}, {0, 1, 0}}.
3. Swap the element A with A. Thereafter the matrix A modifies to {{ 0, 0, 1}, {0, 1, 0}, {1, 1, 0}}.

Therefore, the total number of moves needed is 3 and also it is the minimum number of moves needed.

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

Naive Approach: This problem can be solved using Hashing. To convert matrix A to B by only swaps, the count of set bits and unset bits in both the matrices must be same. So first check if the set bits and unset bits in A is same as in B or not. If yes, then find the number of positions where element in A is not same as element in B. This will be the final count.

Efficient Approach: The above approach can be further space optimized, with the help of observation that count the number of elements such that A[i][j] = 0 and B[i][j] = 1 and number of elements such that A[i][j] = 1 and B[i][j] = 0 must be equal and the minimum number of moves needed is equal to the count obtained. Follow the steps below to solve the problem:

• Initialize two variable, say count10 and count01 which count the number of elements such that A[i][j] = 1 and B[i][j] = 0 and number of elements such that A{i][j] = 0 and B[i][j] = 1 respectively.
• Iterate over the range [0, N-1] using the variable i and perform the following steps:
• Iterate over the range [0, M-1] using the variable j and if A[i][j] = 1 and B[i][j] = 0 then increment the count10 by 1. Else, if A[i][j] = 0 and B[i][j] = 1 then increment the count01 by 1.
• If count01 is equal to count10, then print the value of count01 as the answer. Otherwise, print -1 as the answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count the minimum number``// of swaps required to convert matrix``// A to matrix B``int` `minSwaps(``int` `N, ``int` `M, vector >& A,``             ``vector >& B)``{``    ``// Stores number of cells such that``    ``// matrix A contains 0 and matrix B``    ``// contains 1``    ``int` `count01 = 0;` `    ``// Stores number of cells such that``    ``// matrix A contains 1 and matrix B``    ``// contains 0``    ``int` `count10 = 0;` `    ``// Iterate over the range [0, N-1]``    ``for` `(``int` `i = 0; i < N; i++) {``        ``// Iterate over the range [0, M-1]``        ``for` `(``int` `j = 0; j < M; j++) {``            ``if` `(A[i][j] != B[i][j]) {` `                ``// If A[i][j] = 1 and B[i][j] = 0``                ``if` `(A[i][j] == 1)``                    ``count10++;``                ``// If A[i][j] = 0 and B[i][j] = 1``                ``else``                    ``count01++;``            ``}``        ``}``    ``}` `    ``// If count01 is equal to count10``    ``if` `(count01 == count10)``        ``return` `count01;` `    ``// Otherwise,``    ``else``        ``return` `-1;``}` `// Driver Code``int` `main()``{` `    ``vector > A``        ``= { { 1, 1, 0 }, { 0, 0, 1 }, { 0, 1, 0 } };``    ``vector > B``        ``= { { 0, 0, 1 }, { 0, 1, 0 }, { 1, 1, 0 } };` `    ``int` `N = A.size();``    ``int` `M = B.size();` `    ``cout << minSwaps(N, M, A, B);``}`

## Java

 `// Java program for the above approach` `public` `class` `MyClass``{``  ` `// Function to count the minimum number``// of swaps required to convert matrix``// A to matrix B``public` `static` `int` `minSwaps(``int` `N, ``int` `M, ``int` `A[][], ``int` `B[][])``{``    ``// Stores number of cells such that``    ``// matrix A contains 0 and matrix B``    ``// contains 1``    ``int` `count01 = ``0``;` `    ``// Stores number of cells such that``    ``// matrix A contains 1 and matrix B``    ``// contains 0``    ``int` `count10 = ``0``;` `    ``// Iterate over the range [0, N-1]``    ``for` `(``int` `i = ``0``; i < N; i++) {``        ``// Iterate over the range [0, M-1]``        ``for` `(``int` `j = ``0``; j < M; j++) {``            ``if` `(A[i][j] != B[i][j]) {` `                ``// If A[i][j] = 1 and B[i][j] = 0``                ``if` `(A[i][j] == ``1``)``                    ``count10++;``                ``// If A[i][j] = 0 and B[i][j] = 1``                ``else``                    ``count01++;``            ``}``        ``}``    ``}` `    ``// If count01 is equal to count10``    ``if` `(count01 == count10)``        ``return` `count01;` `    ``// Otherwise,``    ``else``        ``return` `-``1``;``}` `// Driver Code``  ``public` `static` `void` `main(String args[])``{` `    ``int` `[][] A = { { ``1``, ``1``, ``0` `}, { ``0``, ``0``, ``1` `}, { ``0``, ``1``, ``0` `} };``    ``int` `[][] B = { { ``0``, ``0``, ``1` `}, { ``0``, ``1``, ``0` `}, { ``1``, ``1``, ``0` `} };` `    ``int` `N = A.length;``    ``int` `M = B[``0``].length;` `    ``System.out.println(minSwaps(N, M, A, B));``}}` `// This code is contributed by SoumikMondal`

## Python3

 `# Python3 program for the above approach` `# Function to count the minimum number``# of swaps required to convert matrix``# A to matrix B``def` `minSwaps(N, M, A, B):``    ` `    ``# Stores number of cells such that``    ``# matrix A contains 0 and matrix B``    ``# contains 1``    ``count01 ``=` `0` `    ``# Stores number of cells such that``    ``# matrix A contains 1 and matrix B``    ``# contains 0``    ``count10 ``=` `0``    ` `    ``# Iterate over the range[0, N-1]``    ``for` `i ``in` `range``(``0``, N):``        ` `        ``# Iterate over the range[0, M-1]``        ``for` `j ``in` `range``(``0``, M):``            ``if` `(A[i][j] !``=` `B[i][j]):``                ` `                ``# If A[i][j] = 1 and B[i][j] = 0``                ``if` `(A[i][j] ``=``=` `1``):``                    ``count10 ``+``=` `1``                    ` `                ``# If A[i][j] = 0 and B[i][j] = 1``                ``else``:``                    ``count01 ``+``=` `1` `    ``# If count01 is equal to count10``    ``if` `(count01 ``=``=` `count10):``        ``return` `count01``        ` `    ``# Otherwise,``    ``else``:``        ``return` `-``1` `# Driver Code``A ``=` `[ [ ``1``, ``1``, ``0` `], [ ``0``, ``0``, ``1` `], [ ``0``, ``1``, ``0` `] ]``B ``=` `[ [ ``0``, ``0``, ``1` `], [ ``0``, ``1``, ``0` `], [ ``1``, ``1``, ``0` `] ]``N ``=` `len``(A)``M ``=` `len``(B[``0``])` `print``(minSwaps(N, M, A, B))` `# This code is contributed by amreshkumar3`

## Javascript

 ``

## C#

 `// C# program for the above approach` `using` `System;` `class` `GFG {` `// Function to count the minimum number``// of swaps required to convert matrix``// A to matrix B``public` `static` `int` `minSwaps(``int` `N, ``int` `M, ``int``[,] A, ``int``[,] B)``{``    ``// Stores number of cells such that``    ``// matrix A contains 0 and matrix B``    ``// contains 1``    ``int` `count01 = 0;` `    ``// Stores number of cells such that``    ``// matrix A contains 1 and matrix B``    ``// contains 0``    ``int` `count10 = 0;` `    ``// Iterate over the range [0, N-1]``    ``for` `(``int` `i = 0; i < N; i++) {``        ``// Iterate over the range [0, M-1]``        ``for` `(``int` `j = 0; j < M; j++) {``            ``if` `(A[i,j] != B[i, j]) {` `                ``// If A[i][j] = 1 and B[i][j] = 0``                ``if` `(A[i, j] == 1)``                    ``count10++;``                ``// If A[i][j] = 0 and B[i][j] = 1``                ``else``                    ``count01++;``            ``}``        ``}``    ``}` `    ``// If count01 is equal to count10``    ``if` `(count01 == count10)``        ``return` `count01;` `    ``// Otherwise,``    ``else``        ``return` `-1;``}` `  ``// Driver code``  ``public` `static` `void` `Main (String[] args)``  ``{``    ``int` `[,] A = { { 1, 1, 0 }, { 0, 0, 1 }, { 0, 1, 0 } };``    ``int` `[,] B = { { 0, 0, 1 }, { 0, 1, 0 }, { 1, 1, 0 } };` `    ``int` `N = A.GetLength(0);``    ``int` `M = 3;` `    ``Console.Write(minSwaps(N, M, A, B));``  ``}``}`
Output
`3`

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

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up