Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Hard
  • Last Updated : 28 May, 2021

Given two N X M matrices of integers. In an operation, we can transpose any square sub-matrix in matrix1. The task is to check if matrix1 can be converted to matrix2 with the given operation.
Examples: 
 

Input: matrix1[][] = { 
{1, 2, 3}, 
{4, 5, 6}, 
{7, 8, 9}}, 
matrix2[][] = { 
{1, 4, 7}, 
{2, 5, 6}, 
{3, 8, 9}} 
Output: Yes 
Transpose the whole matrix and then we transpose the 
sub-matrix with corners in cells (2, 2) and (3, 3).
Input: matrix1[][] = { 
{1, 2}, 
{3, 4}}, 
matrix2[][] = { 
{1, 4}, 
{3, 8}} 
Output: No 
 

 

Approach: Sort the diagonals of both the matrices and compare them. If both matrices are equal after sorting diagonals, then matrix1 can be converted to matrix2. The following method is correct because of the fact that while transposing the numbers can only be transposed to any of its diagonal.
Below is the implementation of the above approach. 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
#define n 3
#define m 3
 
// Function that returns true if matrix1
// can be converted to matrix2
// with the given operation
bool check(int a[n][m], int b[n][m])
{
 
    // Traverse all the diagonals
    // starting at first column
    for (int i = 0; i < n; i++) {
        vector<int> v1, v2;
        int r = i;
        int col = 0;
 
        // Traverse in diagonal
        while (r >= 0 && col < m) {
 
            // Store the diagonal elements
            v1.push_back(a[r][col]);
            v2.push_back(b[r][col]);
 
            // Move up
            r--;
            col++;
        }
 
        // Sort the elements
        sort(v1.begin(), v1.end());
        sort(v2.begin(), v2.end());
 
        // Check if they are same
        for (int i = 0; i < v1.size(); i++) {
            if (v1[i] != v2[i])
                return false;
        }
    }
 
    // Traverse all the diagonals
    // starting at last row
    for (int j = 1; j < m; j++) {
        vector<int> v1, v2;
        int r = n - 1;
        int col = j;
 
        // Traverse in the diagonal
        while (r >= 0 && col < m) {
 
            // Store diagonal elements
            v1.push_back(a[r][col]);
            v2.push_back(b[r][col]);
            r--;
            col++;
        }
 
        // Sort all elements
        sort(v1.begin(), v1.end());
        sort(v2.begin(), v2.end());
 
        // Check for same
        for (int i = 0; i < v1.size(); i++) {
            if (v1[i] != v2[i])
                return false;
        }
    }
 
    // If every element matches
    return true;
}
 
// Driver code
int main()
{
    int a[n][m] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
    int b[n][m] = { { 1, 4, 7 }, { 2, 5, 6 }, { 3, 8, 9 } };
 
    if (check(a, b))
        cout << "Yes";
    else
        cout << "No";
 
    return 0;
}
Java



// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
    static final int n = 3;
    static final int m = 3;
 
    // Function that returns true if matrix1
    // can be converted to matrix2
    // with the given operation
    static boolean check(int a[][], int b[][])
    {
 
        // Traverse all the diagonals
        // starting at first column
        for (int i = 0; i < n; i++)
        {
            Vector<Integer> v1 = new Vector<Integer>();
            Vector<Integer> v2 = new Vector<Integer>();
            int r = i;
            int col = 0;
 
            // Traverse in diagonal
            while (r >= 0 && col < m)
            {
 
                // Store the diagonal elements
                v1.add(a[r][col]);
                v2.add(b[r][col]);
 
                // Move up
                r--;
                col++;
            }
 
            // Sort the elements
            Collections.sort(v1);
            Collections.sort(v2);
 
            // Check if they are same
            for (int j = 0; j < v1.size(); j++)
            {
                if (v1.get(j) != v2.get(j))
                {
                    return false;
                }
            }
        }
 
        // Traverse all the diagonals
        // starting at last row
        for (int j = 1; j < m; j++)
        {
            Vector<Integer> v1 = new Vector<Integer>();
            Vector<Integer> v2 = new Vector<Integer>();
            int r = n - 1;
            int col = j;
 
            // Traverse in the diagonal
            while (r >= 0 && col < m)
            {
 
                // Store diagonal elements
                v1.add(a[r][col]);
                v2.add(b[r][col]);
                r--;
                col++;
            }
 
            // Sort all elements
            Collections.sort(v1);
            Collections.sort(v2);
 
            // Check for same
            for (int i = 0; i < v1.size(); i++)
            {
                if (v1.get(i) != v2.get(i))
                {
                    return false;
                }
            }
        }
 
        // If every element matches
        return true;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int a[][] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int b[][] = {{1, 4, 7}, {2, 5, 6}, {3, 8, 9}};
 
        if (check(a, b))
        {
            System.out.println("Yes");
        }
        else
        {
            System.out.println("No");
        }
    }
}
 
// This code contributed by Rajput-Ji
Python3



# Python 3 implementation of the approach
n = 3
m = 3
 
# Function that returns true if matrix1
# can be converted to matrix2
# with the given operation
def check(a, b):
     
    # Traverse all the diagonals
    # starting at first column
    for i in range(n):
        v1 = []
        v2 = []
        r = i
        col = 0
 
        # Traverse in diagonal
        while (r >= 0 and col < m):
             
            # Store the diagonal elements
            v1.append(a[r][col])
            v2.append(b[r][col])
 
            # Move up
            r -= 1
            col += 1
 
        # Sort the elements
        v1.sort(reverse = False)
        v2.sort(reverse = False)
 
        # Check if they are same
        for i in range(len(v1)):
            if (v1[i] != v2[i]):
                return False
 
    # Traverse all the diagonals
    # starting at last row
    for j in range(1, m):
        v1 = []
        v2 = []
        r = n - 1
        col = j
 
        # Traverse in the diagonal
        while (r >= 0 and col < m):
             
            # Store diagonal elements
            v1.append(a[r][col])
            v2.append(b[r][col])
            r -= 1
            col += 1
 
        # Sort all elements
        v1.sort(reverse = False)
        v2.sort(reverse = False)
 
        # Check for same
        for i in range(len(v1)):
            if (v1[i] != v2[i]):
                return False
                 
    # If every element matches
    return True
 
# Driver code
if __name__ == '__main__':
    a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    b = [[1, 4, 7], [2, 5, 6], [3, 8, 9]]
 
    if (check(a, b)):
        print("Yes")
    else:
        print("No")
 
# This code is contributed by
# Surendra_Gangwar
C#



// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG
{
 
    static readonly int n = 3;
    static readonly int m = 3;
 
    // Function that returns true if matrix1
    // can be converted to matrix2
    // with the given operation
    static bool check(int [,]a, int [,]b)
    {
 
        // Traverse all the diagonals
        // starting at first column
        for (int i = 0; i < n; i++)
        {
            List<int> v1 = new List<int>();
            List<int> v2 = new List<int>();
            int r = i;
            int col = 0;
 
            // Traverse in diagonal
            while (r >= 0 && col < m)
            {
 
                // Store the diagonal elements
                v1.Add(a[r, col]);
                v2.Add(b[r, col]);
 
                // Move up
                r--;
                col++;
            }
 
            // Sort the elements
            v1.Sort();
            v2.Sort();
 
            // Check if they are same
            for (int j = 0; j < v1.Count; j++)
            {
                if (v1[j] != v2[j])
                {
                    return false;
                }
            }
        }
 
        // Traverse all the diagonals
        // starting at last row
        for (int j = 1; j < m; j++)
        {
            List<int> v1 = new List<int>();
            List<int> v2 = new List<int>();
            int r = n - 1;
            int col = j;
 
            // Traverse in the diagonal
            while (r >= 0 && col < m)
            {
 
                // Store diagonal elements
                v1.Add(a[r, col]);
                v2.Add(b[r, col]);
                r--;
                col++;
            }
 
            // Sort all elements
            v1.Sort();
            v2.Sort();
 
            // Check for same
            for (int i = 0; i < v1.Count; i++)
            {
                if (v1[i] != v2[i])
                {
                    return false;
                }
            }
        }
 
        // If every element matches
        return true;
    }
 
    // Driver code
    public static void Main()
    {
        int [,]a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        int [,]b = {{1, 4, 7}, {2, 5, 6}, {3, 8, 9}};
 
        if (check(a, b))
        {
            Console.WriteLine("Yes");
        }
        else
        {
            Console.WriteLine("No");
        }
    }
}
 
/* This code contributed by PrinciRaj1992 */
PHP



<?php
// PHP implementation of the approach
$n = 3;
$m = 3;
 
// Function that returns true if matrix1
// can be converted to matrix2
// with the given operation
function check($a, $b)
{
    global $n, $m;
 
    // Traverse all the diagonals
    // starting at first column
    for ($i = 0; $i < $n; $i++)
    {
        $v1 = array();
        $v2 = array();
        $r = $i;
        $col = 0;
 
        // Traverse in diagonal
        while ($r >= 0 && $col < $m)
        {
 
            // Store the diagonal elements
            array_push($v1, $a[$r][$col]);
            array_push($v2, $b[$r][$col]);
 
            // Move up
            $r--;
            $col++;
        }
 
        // Sort the elements
        sort($v1);
        sort($v2);
 
        // Check if they are same
        for ($i = 0; $i < count($v1); $i++)
        {
            if ($v1[$i] != $v2[$i])
                return false;
        }
    }
 
    // Traverse all the diagonals
    // starting at last row
    for ($j = 1; $j < $m; $j++)
    {
        $v1 = array();
        $v2 = array();
        $r = $n - 1;
        $col = $j;
 
        // Traverse in the diagonal
        while ($r >= 0 && $col < $m)
        {
 
            // Store diagonal elements
            array_push($v1, $a[$r][$col]);
            array_push($v2, $b[$r][$col]);
            $r--;
            $col++;
        }
 
        // Sort all elements
        sort($v1);
        sort($v2);
 
        // Check for same
        for ($i = 0; $i < count($v1); $i++)
        {
            if ($v1[$i] != $v2[$i])
                return false;
        }
    }
 
    // If every element matches
    return true;
}
 
// Driver code
$a = array(array( 1, 2, 3 ),
           array( 4, 5, 6 ),
           array( 7, 8, 9 ));
$b = array(array( 1, 4, 7 ),
           array( 2, 5, 6 ),
           array( 3, 8, 9 ));
 
if (check($a, $b))
    echo "Yes";
else
    echo "No";
 
// This code is contributed by mits
?>
Javascript



<script>
 
// JavaScript implementation of the approach
var n = 3
var m = 3
 
// Function that returns true if matrix1
// can be converted to matrix2
// with the given operation
function check(a, b)
{
 
    // Traverse all the diagonals
    // starting at first column
    for (var i = 0; i < n; i++) {
        var v1 = [], v2 = [];
        var r = i;
        var col = 0;
 
        // Traverse in diagonal
        while (r >= 0 && col < m) {
 
            // Store the diagonal elements
            v1.push(a[r][col]);
            v2.push(b[r][col]);
 
            // Move up
            r--;
            col++;
        }
 
        // Sort the elements
        v1.sort();
        v2.sort();
 
        // Check if they are same
        for (var i = 0; i < v1.length; i++) {
            if (v1[i] != v2[i])
                return false;
        }
    }
 
    // Traverse all the diagonals
    // starting at last row
    for (var j = 1; j < m; j++) {
        var v1 = [], v2 = [];
        var r = n - 1;
        var col = j;
 
        // Traverse in the diagonal
        while (r >= 0 && col < m) {
 
            // Store diagonal elements
            v1.push(a[r][col]);
            v2.push(b[r][col]);
            r--;
            col++;
        }
 
        // Sort all elements
        v1.sort();
        v2.sort();
 
        // Check for same
        for (var i = 0; i < v1.length; i++) {
            if (v1[i] != v2[i])
                return false;
        }
    }
 
    // If every element matches
    return true;
}
 
// Driver code
var a = [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ];
var b = [ [ 1, 4, 7 ], [ 2, 5, 6 ], [ 3, 8, 9 ] ];
if (check(a, b))
    document.write( "Yes");
else
    document.write( "No");
 
 
</script>
Output: 
Yes
 
Time Complexity: O(N * M * log (max(N, M)))
 

My Personal Notes
arrow_drop_up
Previous
Generate array with minimum sum which can be deleted in P steps
Next

Minimal product subsequence where adjacent elements are separated by a maximum distance of K
Recommended Articles
Page :
Check if a given matrix can be converted to another given matrix by row and column exchanges
30, Apr 20
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 an array can be converted to another given array by swapping pairs of unequal elements
15, Feb 21
Smallest element from all square submatrices of size K from a given Matrix
05, Sep 20
Count of square submatrices with average at least K
07, Jul 21
Maximum size of square such that all submatrices of that size have sum less than K
08, Apr 20
Check if matrix A can be converted to B by changing parity of corner elements of any submatrix
12, Apr 19
Check if any row of the matrix can be converted to the elements present in the target row
19, Oct 21
Generate a matrix having each element equal to the sum of specified submatrices of a given matrix
03, Feb 21
Check if A can be converted to B by reducing with a Prime number
12, Jun 20
Check if quantities of 3 distinct colors can be converted to a single color by given merge-pair operations
07, Sep 20
Check if X can be converted to Y by converting to 3 * (X / 2) or X - 1 in each operation
16, Mar 21
Check if all array elements can be converted to pronic numbers by rotating digits
10, Feb 21
Check if N can be converted to the form K power K by the given operation
26, Apr 20
Sum of all Submatrices of a Given Matrix
14, Feb 19
Final Matrix after incrementing submatrices by K in range given by Q queries
27, Aug 20
Binary Matrix after flipping submatrices in given range for Q queries
27, Aug 20
Generate a matrix having even sum of all diagonals in each 2 x 2 submatrices
19, Jan 21
Number of submatrices with OR value 1
18, Feb 19
Sum of bitwise AND of all submatrices
20, Feb 19
Sum of Bitwise-OR of all Submatrices
20, Feb 19
Median of Bitwise XOR of all submatrices starting from the top left corner
03, Jan 21
Number of submatrices with all 1s
18, Feb 19
Check if a number is perfect square without finding square root
01, Jan 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Striver
@Striver
Vote for difficulty
Current difficulty :
Hard





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

Start Your Coding Journey Now!