Matrix Similarity After Cyclic Shifts

This approach directly simulates the process described in the problem. It performs the cyclic shifts one by one for k steps and then compares the final matrix with the original one.

• Create a copy of the input matrix, mat, called currentMat.
• Get the number of columns, n.
• Loop k times. In each iteration, representing one step of the shift:
  • Create a new m x n matrix called nextMat.
  • Iterate through each row i and column j of currentMat.
  • If i is an even index, perform a single left shift: nextMat[i][j] = currentMat[i][(j + 1) % n].
  • If i is an odd index, perform a single right shift: nextMat[i][j] = currentMat[i][(j - 1 + n) % n].
  • After filling nextMat, update currentMat to be nextMat.
• After the k iterations are complete, compare the final currentMat with the original mat element by element.
• If all elements match, return true. Otherwise, return false.

We start by creating a copy of the original matrix to modify, let's call it currentMat. We then loop k times. In each iteration, we simulate one step of the cyclic shift process. For each step, we create a new temporary matrix, nextMat, to store the result of the shift. We iterate through each row of currentMat. If the row index is even, we perform a single left cyclic shift. If the row index is odd, we perform a single right cyclic shift. After processing all rows, we update currentMat with the contents of nextMat. After k iterations, we compare the final currentMat with the original mat. If they are identical, we return true; otherwise, false.

class Solution {
    public boolean areSimilar(int[][] mat, int k) {
        int m = mat.length;
        int n = mat[0].length;
        int[][] currentMat = new int[m][n];
        for (int i = 0; i < m; i++) {
            System.arraycopy(mat[i], 0, currentMat[i], 0, n);
        }

        for (int step = 0; step < k; step++) {
            int[][] nextMat = new int[m][n];
            for (int i = 0; i < m; i++) {
                if (i % 2 == 0) { // Even row: left shift
                    for (int j = 0; j < n; j++) {
                        nextMat[i][j] = currentMat[i][(j + 1) % n];
                    }
                } else { // Odd row: right shift
                    for (int j = 0; j < n; j++) {
                        nextMat[i][j] = currentMat[i][(j - 1 + n) % n];
                    }
                }
            }
            currentMat = nextMat;
        }

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (mat[i][j] != currentMat[i][j]) {
                    return false;
                }
            }
        }
        return true;
    }
}