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

Suppose we have two N X M binary matrices A and B. In a single operation, we can select a sub-matrix (at least 2x2) and flip the parity of its four corner elements (toggle bits 0?1). We need to check whether matrix A can be converted to B by performing any number of such operations.

Understanding the Problem

When we select a 2x2 submatrix and flip its corners, we're essentially performing an XOR operation on four specific positions. The key insight is that we can systematically work through the matrix from bottom-right to top-left, fixing mismatches using operations that involve the corner (0,0).

Visual Example

Algorithm Approach

The solution works in two phases:

1. Fix interior elements: For positions (i,j) where i?1 and j?1, if there's a mismatch, perform an operation using the submatrix with corners at (0,0), (0,j), (i,0), and (i,j).
2. Check final state: After fixing all interior elements, verify that the entire matrix matches the target.

Implementation

def solve(mat1, mat2):
    row = len(mat1)
    column = len(mat1[0])
    
    # Phase 1: Fix all elements except first row and first column
    for i in range(1, row):
        for j in range(1, column):
            if mat1[i][j] != mat2[i][j]:
                # Flip corners of submatrix from (0,0) to (i,j)
                mat1[i][j] ^= 1
                mat1[0][0] ^= 1
                mat1[0][j] ^= 1
                mat1[i][0] ^= 1
    
    # Phase 2: Check if matrices are now identical
    for i in range(row):
        for j in range(column):
            if mat1[i][j] != mat2[i][j]:
                return False
    
    return True

# Test with the given example
mat1 = [
    [1, 0, 0],
    [1, 0, 1],
    [1, 0, 0]
]

mat2 = [
    [0, 1, 0],
    [0, 1, 1],
    [1, 0, 0]
]

print(solve(mat1, mat2))

True

How It Works

The algorithm leverages the mathematical property that any valid transformation sequence can be reduced to a canonical form. By systematically fixing mismatches from bottom-right to top-left, we ensure that:

• Each operation affects exactly four corners of a submatrix
• The first row and column act as "adjustment space" for operations
• If conversion is possible, this approach will find it
• If impossible, mismatches will remain after phase 1

Time and Space Complexity

Conclusion

This algorithm efficiently determines matrix convertibility by systematically fixing mismatches using corner-flip operations. The key insight is that any valid transformation can be achieved through this canonical approach.