Matrix Similarity After Cyclic Shifts - Practice Coding Problems

Matrix Similarity After Cyclic Shifts - Problem

You are given an m x n integer matrix mat and an integer k. Your task is to determine if the matrix returns to its original state after performing k cyclic shift operations.

Here's how the shifting works:

Even-indexed rows (0, 2, 4, ...) are cyclically shifted to the left
Odd-indexed rows (1, 3, 5, ...) are cyclically shifted to the right

A cyclic shift means elements wrap around - when shifting left, the leftmost element moves to the rightmost position, and vice versa for right shifts.

Return true if the matrix is identical to the original after exactly k operations, false otherwise.

Example: If we have matrix [[1,2,3],[4,5,6]] with k=1:

Row 0 (even): [1,2,3] → [2,3,1] (left shift)
Row 1 (odd): [4,5,6] → [6,4,5] (right shift)
Result: [[2,3,1],[6,4,5]] ≠ original, so return false

Input & Output

example_1.py — Basic Example

$ Input: mat = [[1,2,1,2],[5,5,5,5],[6,3,6,3]], k = 2

› Output: true

💡 Note: Each row has width 4. After k=2 shifts: Row 0 (even): [1,2,1,2] → [1,2,1,2] (2 left shifts), Row 1 (odd): [5,5,5,5] → [5,5,5,5] (identical elements), Row 2 (even): [6,3,6,3] → [6,3,6,3] (2 left shifts). Since k % 4 ≠ 0, but the pattern repeats due to identical elements, we get the original matrix.

example_2.py — Simple False Case

$ Input: mat = [[2,2],[2,2]], k = 3

› Output: true

💡 Note: All elements are identical, so no matter how many shifts we perform, the matrix remains the same. k % 2 = 1, but since all elements are equal, the matrix still returns to original state.

example_3.py — Different Widths

$ Input: mat = [[1,2,3],[4,5,6]], k = 1

› Output: false

💡 Note: Row 0 has width 3, after 1 left shift: [1,2,3] → [2,3,1]. Row 1 has width 3, after 1 right shift: [4,5,6] → [6,4,5]. Since k % 3 = 1 ≠ 0, the matrix doesn't return to original state.

Constraints

1 ≤ m, n ≤ 25
1 ≤ mat[i][j] ≤ 99
1 ≤ k ≤ 10⁹
All rows in the matrix have the same width

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

All items are in their starting positions on the belts

Start Rotation

Even belts rotate left, odd belts rotate right

Track Cycles

Each belt completes a full cycle after 'width' rotations

Check Alignment

All items return to start if k is multiple of each belt's width

Key Takeaway

🎯 Key Insight: Instead of simulating k shifts, we use the mathematical property that each row cycles back to its original state every n shifts (where n is the row width). We only need to check if k % n == 0 for all rows!

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses modular arithmetic to determine if the matrix returns to its original state. Since each row of width n returns to its original configuration after exactly n shifts, we only need to check if k % n == 0 for all rows. This achieves O(m) time complexity instead of the brute force O(m*n*k) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(m * n * k)	O(m * n)	Simulate all k shifts step by step and compare with original matrix
Mathematical Optimization (Optimal)	O(m)	O(1)	Use modular arithmetic to determine if k shifts return matrix to original state

Brute Force Simulation — Algorithm Steps

Create a deep copy of the original matrix to preserve it
Perform k iterations of the shifting process
In each iteration, shift even rows left and odd rows right
After k iterations, compare the modified matrix with the original
Return true if they match, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Original matrix before any shifts

First Shift

Even rows shift left, odd rows shift right

Continue Shifts

Repeat the shifting process k times

Compare Result

Check if final matrix equals original

Code -

solution.c — C

bool areSimilar(int** mat, int matSize, int* matColSize, int k) {
    int m = matSize;
    int n = matColSize[0];
    
    // Create copy of original matrix
    int** original = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        original[i] = (int*)malloc(n * sizeof(int));
        memcpy(original[i], mat[i], n * sizeof(int));
    }
    
    // Perform k shifts
    for (int step = 0; step < k; step++) {
        for (int i = 0; i < m; i++) {
            if (n == 0) continue;
            
            if (i % 2 == 0) { // Even row - shift left
                int first = mat[i][0];
                memmove(mat[i], mat[i] + 1, (n - 1) * sizeof(int));
                mat[i][n - 1] = first;
            } else { // Odd row - shift right
                int last = mat[i][n - 1];
                memmove(mat[i] + 1, mat[i], (n - 1) * sizeof(int));
                mat[i][0] = last;
            }
        }
    }
    
    // Compare matrices
    bool result = true;
    for (int i = 0; i < m && result; i++) {
        for (int j = 0; j < n && result; j++) {
            if (mat[i][j] != original[i][j]) {
                result = false;
            }
        }
    }
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(original[i]);
    }
    free(original);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * n * k)

We perform k iterations, and in each iteration we process all m*n elements of the matrix

✓ Linear Growth

Space Complexity

O(m * n)

We need space to store a copy of the original matrix for comparison

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler