2946.循环移位后的矩阵相似检查：模拟（左即是右）

【LetMeFly】2946.循环移位后的矩阵相似检查：模拟（左即是右）

力扣题目链接：https://leetcode.cn/problems/matrix-similarity-after-cyclic-shifts/

给你一个下标从 0 开始且大小为 m x n 的整数矩阵 mat 和一个整数 k 。请你将矩阵中的 奇数 行循环 右 移 k 次，偶数 行循环 左 移 k 次。

如果初始矩阵和最终矩阵完全相同，则返回 true ，否则返回 false 。

 

示例 1：

输入：mat = [[1,2,1,2],[5,5,5,5],[6,3,6,3]], k = 2
输出：true
解释：


初始矩阵如图一所示。
图二表示对奇数行右移一次且对偶数行左移一次后的矩阵状态。
图三是经过两次循环移位后的最终矩阵状态，与初始矩阵相同。
因此，返回 true 。

示例 2：

输入：mat = [[2,2],[2,2]], k = 3
输出：true
解释：由于矩阵中的所有值都相等，即使进行循环移位，矩阵仍然保持不变。因此，返回 true 。

示例 3：

输入：mat = [[1,2]], k = 1
输出：false
解释：循环移位一次后，mat = [[2,1]]，与初始矩阵不相等。因此，返回 false 。

 

提示：

• 1 <= mat.length <= 25
• 1 <= mat[i].length <= 25
• 1 <= mat[i][j] <= 25
• 1 <= k <= 50

解题方法：模拟

如果一行左移$k$次和原来相同，那么它右移$k$次肯定也和原来相同。

所以我们不用管第几行，统一判断每个元素右移$k$后是否等值就好了（$row[j] == row[(j + k)\mod len(row)]$）

• 时间复杂度$O(size(mat))$
• 空间复杂度$O(1)$

AC代码

C++

/*
 * @LastEditTime: 2026-03-27 08:49:37
 */
class Solution {
public:
    bool areSimilar(vector<vector<int>>& mat, int k) {
        int m = mat[0].size();
        for (vector<int>& row : mat) {
            for (int j = 0; j < m; j++) {
                if (row[j] != row[(j + k) % m]) {
                    return false;
                }
            }
        }
        return true;
    }
};

Python

'''
LastEditTime: 2026-03-27 08:58:55
'''
from typing import List

class Solution:
    def areSimilar(self, mat: List[List[int]], k: int) -> bool:
        m = len(mat[0])
        return all(row[j] == row[(j + k) % m] for j in range(m) for row in mat)

Java

/*
 * @LastEditTime: 2026-03-27 08:57:58
 */
class Solution {
    public boolean areSimilar(int[][] mat, int k) {
        int m = mat[0].length;
        for (int[] row : mat) {
            for (int j = 0; j < m; j++) {
                if (row[j] != row[(j + k) % m]) {
                    return false;
                }
            }
        }
        return true;
    }
}

Go

/*
 * @LastEditTime: 2026-03-27 08:53:34
 */
package main

func areSimilar(mat [][]int, k int) bool {
	m := len(mat[0])
    for _, row := range mat {
		for j := range row {
			if row[j] != row[(j + k) % m] {
				return false
			}
		}
	}
	return true
}

Rust

/*
 * @LastEditTime: 2026-03-27 09:08:38
 */
impl Solution {
    pub fn are_similar(mat: Vec<Vec<i32>>, k: i32) -> bool {
        let m = mat[0].len();
        for row in mat.iter() {
            for j in 0..row.len() {
                if (row[j] != row[(j + k as usize) % m]) {
                    return false;
                }
            }
        }
        true
    }
}

同步发文于CSDN和我的个人博客，原创不易，转载经作者同意后请附上原文链接哦~

千篇源码题解已开源