Skip to content
Related Articles

Related Articles

Improve Article

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

  • Last Updated : 25 Feb, 2021

Given a matrix startMatrix and another matrix finalMatrix, the task is to check if startMatrix can be converted to finalMatrix by column exchanges and a row exchanges.

Examples:  

Input: start[][] = {{1, 2, 3, 4}, 
{5, 6, 7, 8} 
{9, 10, 11, 12}, 
{13, 14, 15, 16}}
final[][] = {{1, 4, 3, 2}, 
{5, 8, 7, 6}, 
{13, 16, 15, 14}, 
{9, 12, 11, 10}} 
Output: Yes 
Explanation: Exchanging 2nd and 4th column followed by 4th and 3rd row gives the desired matrix

Input: start[][] = {{1, 2, 3, 4}, 
{5, 6, 7, 8} 
{9, 10, 11, 12}, 
{13, 14, 15, 16}}
final[][] = {{1, 4, 3, 2}, 
{5, 6, 7, 8}, 
{13, 16, 15, 14}, 
{9, 12, 11, 10}} 
Output: No 
 

Approach: 
In order to solve this problem we just need to check whether the elements in all rows and columns in startMatrix are preserved in the finalMatrix matrix irrespective of their order. Any violation of this condition will ensure that the finalMatrix matrix can’t be obtained. Traverse a loop through every row and check if all elements of that row in startMatrix is present in a single row in finalMatrix. Then transpose both startMatrix and finalMatrix and repeat the same verification.



Below code is the implementation of the above approach:  

C++




// CPP program to check if a
// given matrix can be converted
// to another given matrix by row
// and column exchanges
#include <bits/stdc++.h>
using namespace std;
 
// Function to get transpose of a matrix
vector<vector<int>> getTranspose(vector<vector<int>> matrix)
{
  int n = matrix.size();
  vector<vector<int>> transpose(n, vector<int>(n));
  for (int i = 0; i < n; i++)
  {
    for (int j = 0; j < n; j++)
    {
      transpose[j][i] = matrix[i][j];
    }
  }
  return transpose;
}
 
// Function to check for row preservation
bool rowEquality(vector<vector<int>> s,
                 vector<vector<int>> f)
{
  vector<set<int>> sets, setf;
  unordered_map<int, int> map;
 
  // Creating sets from the initial matrix
  for (int i = 0; i < s.size(); i++)
  {
 
    // Create set for corresponding row
    set<int> sett;
 
    // Add first element to the set
    sett.insert(s[i][0]);
    sets.push_back(sett);
 
    // Store the row number in map
    map[s[i][0]] = i;
 
    // Add remaining elements to the set
    for (int j = 1; j < s.size(); j++)
    {
      sett.insert(s[i][j]);
    }
  }
 
  // Create sets for final matrix
  // and check with the initial matrix
  int rowIndex = -1;
  for (int i = 0; i < f.size(); i++)
  {
    rowIndex = -1;
    set<int> sett;
 
    for (int j = 0; j < f.size(); j++)
    {
      sett.insert(f[i][j]);
      if (map.find(f[i][j]) != map.end())
      {
        rowIndex = map[f[i][j]];
      }
    }
 
    setf.push_back(sett);
    if (setf[i] != sets[rowIndex])
      return true;
  }
 
  return false;
}
 
// Driver code
int main()
{
  vector<vector<int>> startMatrix = {
      {1, 2, 3, 4},
      {5, 6, 7, 8},
      {9, 10, 11, 12},
      {13, 14, 15, 16}
  };
  vector<vector<int>> finalMatrix = {
      {3, 4, 1, 2},
      {15, 16, 13, 14},
      {7, 8, 5, 6},
      {11, 12, 9, 10}
  };
 
  vector<vector<int>> startTranspose = getTranspose(startMatrix);
  vector<vector<int>> finalTranspose = getTranspose(finalMatrix);
 
  if (rowEquality(startMatrix, finalMatrix) &&
      rowEquality(startTranspose, finalTranspose))
    cout << "Yes" << endl;
  else
    cout << "No" << endl;
}
 
// This code is contributed by sanjeev2552
Java



// Java program to check if a
// given matrix can be converted
// to another given matrix by row
// and column exchanges
 
import java.util.*;
public class Solution{
 
    // Function to get transpose of a matrix
    static int[][] getTranspose(int[][] matrix){
        int n = matrix.length;
        int[][] transpose = new int[n][n];
        for(int i=0; i<n; i++){
            for(int j=0; j<n; j++){
                transpose[j][i] = matrix[i][j];
            }
        }
        return transpose;
    }
     
    // Function to check for row preservation
    static boolean rowEquality(int[][] s, int[][] f){
        ArrayList<Set<Integer>> sets = new ArrayList<>();
        ArrayList<Set<Integer>> setf = new ArrayList<>();
        HashMap<Integer,Integer> map = new HashMap<>();
         
        // Creating sets from the initial matrix
        for(int i=0; i<s.length; i++){   
            // Create set for corresponding row
            Set<Integer> set = new HashSet<Integer>();
            // Add first element to the set
            set.add(s[i][0]);
            sets.add(set);
            // Store the row number in map
            map.put(s[i][0], i);
            // Add remaining elements to the set
            for(int j=1; j<s.length; j++){
                set.add(s[i][j]);
            }
        }
         
        // Create sets for final matrix
        // and check with the initial matrix
        int rowIndex = -1;
        for(int i=0; i<f.length; i++){
             
            rowIndex = -1;
            Set<Integer> set = new HashSet<Integer>();
             
            for(int j=0; j<f.length; j++){
                set.add(f[i][j]);
                if(map.containsKey(f[i][j])){
                    rowIndex = map.get(f[i][j]);
                }
                 
            }
             
            setf.add(set);
            if(rowIndex != -1 && !setf.get(i).equals(
                               sets.get(rowIndex)))
                return false;
        }
         
        return true;
         
    }
     
    // Driver code
    public static void main(String []args){
         
        int[][] startMatrix = {{ 1, 2, 3, 4 },
                               { 5, 6, 7, 8 },
                               { 9, 10, 11, 12 },
                               { 13, 14, 15, 16 }};
        int[][] finalMatrix = {{ 3, 4, 1, 2 },
                               { 15, 16, 13, 14 },
                               { 7, 8, 5, 6 },
                               { 11, 12, 9, 10 }};
         
        int[][] startTranspose = getTranspose(startMatrix);
        int[][] finalTranspose = getTranspose(finalMatrix);
 
        if(rowEquality(startMatrix,finalMatrix) &&
           rowEquality(startTranspose,finalTranspose))
            System.out.println("Yes");
        else
            System.out.println("No");
         
    }
}
Python3



# Python3 program to check if a
# given matrix can be converted
# to another given matrix by row
# and column exchanges
 
# Function to get transpose of a matrix
def getTranspose(matrix):
    n = len(matrix)
    transpose = [[0 for i in range(n)] for j in range(n)]
    for i in range(n):
        for j in range(n):
            transpose[j][i] = matrix[i][j]
    return transpose
 
# Function to check for row preservation
def rowEquality(s, f):
    sets = []
    setf = []
    mp = {i : 0 for i in range(100)}
     
    # Creating sets from the initial matrix
    for i in range(len(s)):
         
        # Create set for corresponding row
        st = set()
         
        # Add first element to the set
        st.add(s[i][0])
        sets.append(st)
         
        # Store the row number in mp
        mp[s[i][0]] = i
         
        # Add remaining elements to the set
        for j in range(1, len(s)):
            st.add(s[i][j])
     
    # Create sets for final matrix
    # and check with the initial matrix
    rowIndex = -1
    for i in range(len(f)):
        rowIndex = -1;
        st1 = set()
         
        for j in range(len(f)):
            st1.add(f[i][j])
            if(f[i][j] in mp):
                rowIndex = mp[f[i][j]]
         
        setf.append(st1)
        if(rowIndex != -1 and setf[i] !=
           sets[rowIndex]):
            return True
     
    return False
     
#Driver code
if __name__ == '__main__':
    startMatrix = [[ 1, 2, 3, 4 ],
                    [ 5, 6, 7, 8 ],
                    [ 9, 10, 11, 12 ],
                    [ 13, 14, 15, 16 ]]
    finalMatrix = [[ 3, 4, 1, 2],
                        [ 15, 16, 13, 14 ],
                        [ 7, 8, 5, 6 ],
                        [ 11, 12, 9, 10 ]]
     
    startTranspose = getTranspose(startMatrix)
    finalTranspose = getTranspose(finalMatrix)
 
    if(rowEquality(startMatrix, finalMatrix) and
       rowEquality(startTranspose, finalTranspose)):
        print("Yes")
    else:
        print("No")
 
# This code is contributed by Samarth
C#



// C# program to check if a
// given matrix can be converted
// to another given matrix by row
// and column exchanges
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to get transpose of a matrix
static int[,] getTranspose(int[,] matrix)
{
    int n = matrix.GetLength(0);
    int[,] transpose = new int[n, n];
     
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            transpose[j, i] = matrix[i, j];
        }
    }
    return transpose;
}
 
// Function to check for row preservation
static bool rowEquality(int[,] s, int[,] f)
{
    List<HashSet<int>> sets = new List<HashSet<int>>();
    List<HashSet<int>> setf = new List<HashSet<int>>();
     
    Dictionary<int,
               int> map = new Dictionary<int,
                                         int>();
     
    // Creating sets from the initial matrix
    for(int i = 0; i < s.GetLength(0); i++)
    {
         
        // Create set for corresponding row
        HashSet<int> set = new HashSet<int>();
         
        // Add first element to the set
        set.Add(s[i, 0]);
        sets.Add(set);
         
        // Store the row number in map
        map.Add(s[i, 0], i);
         
        // Add remaining elements to the set
        for(int j = 1; j < s.GetLength(1); j++)
        {
            set.Add(s[i, j]);
        }
    }
     
    // Create sets for readonly matrix
    // and check with the initial matrix
    int rowIndex = -1;
     
    for(int i = 0; i < f.GetLength(0); i++)
    {
        rowIndex = -1;
        HashSet<int> set = new HashSet<int>();
         
        for(int j = 0; j < f.GetLength(1); j++)
        {
            set.Add(f[i, j]);
            if (map.ContainsKey(f[i, j]))
            {
                rowIndex = map[f[i, j]];
            }
        }
         
        setf.Add(set);
        if (rowIndex != -1 &&
           !setf[i].Equals(sets[rowIndex]))
            return true;
    }
    return false;
     
}
 
// Driver code
public static void Main(String []args)
{
    int[,] startMatrix = { { 1, 2, 3, 4 },
                           { 5, 6, 7, 8 },
                           { 9, 10, 11, 12 },
                           { 13, 14, 15, 16 } };
    int[,] finalMatrix = { { 3, 4, 1, 2 },
                           { 15, 16, 13, 14 },
                           { 7, 8, 5, 6 },
                           { 11, 12, 9, 10 } };
     
    int[,] startTranspose = getTranspose(startMatrix);
    int[,] finalTranspose = getTranspose(finalMatrix);
 
    if (rowEquality(startMatrix,finalMatrix) &&
        rowEquality(startTranspose,finalTranspose))
        Console.WriteLine("Yes");
    else
        Console.WriteLine("No");
}
}
 
// This code is contributed by Princi Singh
Output: 
Yes
 



My Personal Notes
arrow_drop_up
Previous
typeid operator in C++ with Examples
Next

Different Ways to Hide ActionBar in Android with Examples
Recommended Articles
Page :
Check if a matrix can be converted to another by repeatedly adding any value to X consecutive elements in a row or column
22, Mar 21
Check if matrix can be converted to another matrix by transposing square sub-matrices
12, Mar 19
Generate a Matrix such that given Matrix elements are equal to Bitwise OR of all corresponding row and column elements of generated Matrix
15, Jan 21
Check if matrix A can be converted to B by changing parity of corner elements of any submatrix
12, Apr 19
Check if a grid can become row-wise and column-wise sorted after adjacent swaps
06, Sep 17
Check if N can be converted to the form K power K by the given operation
26, Apr 20
Check if the given matrix is increasing row and column wise
21, May 19
Check if sums of i-th row and i-th column are same in matrix
10, Sep 17
Check if it is possible to create a matrix such that every row has A 1s and every column has B 1s
15, Aug 20
Check if Bitwise AND of concatenation of diagonals exceeds that of middle row/column elements of a Binary Matrix
06, Apr 21
Find trace of matrix formed by adding Row-major and Column-major order of same matrix
04, Dec 17
Check whether row or column swaps produce maximum size binary sub-matrix with all 1s
03, Feb 17
Find the original matrix when largest element in a row and a column are given
18, Apr 19
Generate a matrix with each row and column of given sum
05, Feb 21
Given a Boolean Matrix, find k such that all elements in k'th row are 0 and k'th column are 1.
24, Sep 15
Find sum of all elements in a matrix except the elements in row and/or column of given cell?
28, Jul 15
Find if a binary matrix exists with given row and column sums
11, Jun 19
Search in a row wise and column wise sorted matrix
10, Mar 11
Print all elements in sorted order from row and column wise sorted matrix
22, Oct 14
Count zeros in a row wise and column wise sorted matrix
20, Jul 16
Sum of matrix in which each element is absolute difference of its row and column numbers
06, Feb 17
Sum of matrix element where each elements is integer division of row and column
20, Feb 17
heapq in Python to print all elements in sorted order from row and column wise sorted matrix
07, Nov 17
Minimum operations required to make each row and column of matrix equals
25, Dec 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
CharchitKapoor
@CharchitKapoor
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

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

Lightbox