题解 | #棋子翻转#

#include <iostream>
#include <vector>
using namespace std;

class Solution {
private:
    // 方向数组：右、左、下、上
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    
    // 翻转指定位置周围的棋子
    void flip(vector<vector<int>>& board, int row, int col) {
        for (int i = 0; i < 4; i++) {
            int newRow = row + dx[i];
            int newCol = col + dy[i];
            // 检查边界条件
            if (newRow >= 0 && newRow < 4 && newCol >= 0 && newCol < 4) {
                // 使用异或操作翻转棋子
                board[newRow][newCol] ^= 1;
            }
        }
    }
    
public:
    vector<vector<int>> flipChess(vector<vector<int>>& A, vector<vector<int>>& f) {
        // 执行每个翻转操作
        for (const auto& pos : f) {
            // 坐标从1开始，需要减1
            int row = pos[0] - 1;
            int col = pos[1] - 1;
            flip(A, row, col);
        }
        return A;
    }
};

import java.util.*;

public class Solution {
    // 方向数组：右、左、下、上
    private static final int[] dx = {0, 0, 1, -1};
    private static final int[] dy = {1, -1, 0, 0};
    
    // 翻转指定位置周围的棋子
    private static void flip(int[][] board, int row, int col) {
        for (int i = 0; i < 4; i++) {
            int newRow = row + dx[i];
            int newCol = col + dy[i];
            // 检查边界条件
            if (newRow >= 0 && newRow < 4 && newCol >= 0 && newCol < 4) {
                // 使用异或操作翻转棋子
                board[newRow][newCol] ^= 1;
            }
        }
    }
    
    public static int[][] flipChess(int[][] board, int[][] operations) {
        // 执行每个翻转操作
        for (int[] pos : operations) {
            // 坐标从1开始，需要减1
            int row = pos[0] - 1;
            int col = pos[1] - 1;
            flip(board, row, col);
        }
        return board;
    }
}

class Solution:
    def flipChess(self , A: List[List[int]], f: List[List[int]]) -> List[List[int]]:
        def flip(board, row, col):
            # 方向数组：右、左、下、上
            dx = [0, 0, 1, -1]
            dy = [1, -1, 0, 0]
            
            # 翻转指定位置周围的棋子
            for i in range(4):
                new_row = row + dx[i]
                new_col = col + dy[i]
                # 检查边界条件
                if 0 <= new_row < 4 and 0 <= new_col < 4:
                    # 使用异或操作翻转棋子
                    board[new_row][new_col] ^= 1

        # 执行每个翻转操作
        for row, col in f:
            # 坐标从1开始，需要减1
            flip(A, row-1, col-1)
        return A