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

Suppose we have two N X M matrices called mat1 and mat2. In an operation, we can transpose any square sub-matrix in mat1. We have to check whether we can get mat2 from mat1 or not by performing the given operation.

The key insight is that transposing square sub-matrices preserves the elements along each diagonal. Elements that can be rearranged among themselves through transpositions must have the same sorted order in both matrices.

Example Matrices

Consider these input matrices ?

The output will be True, because if we transpose the top-right 2×2 sub-matrix of mat1, we will get mat2.

Algorithm

The solution works by checking all diagonals in the matrix. For each diagonal, we collect elements from both matrices and compare their sorted versions ?

• Extract elements along each diagonal from both matrices
• Sort the elements from each diagonal
• Compare if sorted diagonals match between the two matrices
• If all diagonals match, transformation is possible

Implementation

def solve(mat1, mat2):
    row = len(mat1)
    column = len(mat1[0])
    
    # Check diagonals starting from first column
    for i in range(row):
        temp1 = []
        temp2 = []
        r = i
        col = 0
        
        # Collect diagonal elements
        while r >= 0 and col < column:
            temp1.append(mat1[r][col])
            temp2.append(mat2[r][col])
            r -= 1
            col += 1
        
        # Compare sorted diagonals
        temp1.sort()
        temp2.sort()
        for j in range(len(temp1)):
            if temp1[j] != temp2[j]:
                return False
    
    # Check diagonals starting from first row (except first element)
    for j in range(1, column):
        temp1 = []
        temp2 = []
        r = row - 1
        col = j
        
        # Collect diagonal elements
        while r >= 0 and col < column:
            temp1.append(mat1[r][col])
            temp2.append(mat2[r][col])
            r -= 1
            col += 1
        
        # Compare sorted diagonals
        temp1.sort()
        temp2.sort()
        for k in range(len(temp1)):
            if temp1[k] != temp2[k]:
                return False
    
    return True

# Test the function
mat1 = [
    [5, 6, 7],
    [1, 2, 3],
    [6, 8, 9]
]

mat2 = [
    [5, 6, 2],
    [1, 7, 3],
    [6, 8, 9]
]

result = solve(mat1, mat2)
print("Can mat1 be converted to mat2?", result)

Can mat1 be converted to mat2? True

How It Works

The algorithm examines anti-diagonals (diagonals going from bottom-left to top-right). When we transpose square sub-matrices, elements can only move within their respective anti-diagonals. Therefore:

• Elements on the same anti-diagonal can be rearranged through transpositions
• Elements on different anti-diagonals cannot be swapped
• If corresponding anti-diagonals have the same elements (when sorted), transformation is possible

Time Complexity

The time complexity is O(N × M × log(min(N,M))) where N and M are the matrix dimensions. We visit each element once and sort diagonals of maximum length min(N,M).

Conclusion

This solution efficiently determines if one matrix can be transformed into another through square sub-matrix transpositions. The key insight is that only elements on the same anti-diagonal can be rearranged, making sorted diagonal comparison sufficient.