2022-6-4 真题练习

MT2 棋子翻转

 中等  通过率：69.45%  时间限制：1秒  空间限制：256M

知识点数组模拟

描述

在 4x4 的棋盘上摆满了黑白棋子，黑白两色棋子的位置和数目随机，其中0代表白色，1代表黑色；左上角坐标为 (1,1) ，右下角坐标为 (4,4) 。

现在依次有一些翻转操作，要对以给定翻转坐标(x,y)（也即第x行第y列）为中心的上下左右四个棋子的颜色进行翻转。

给定两个数组 A 和 f ，分别代表 初始棋盘 和 哪些要进行翻转的位置(x,y) ，请返回经过所有翻转操作后的棋盘。

 

例如输入[[0,0,1,1],[1,0,1,0],[0,1,1,0],[0,0,1,0]],[[2,2],[3,3],[4,4]]时，初始键盘如下图所示：

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param A int整型二维数组 
     * @param f int整型二维数组 
     * @return int整型二维数组
     */
    int[][] dir={{0,1},{0,-1},{1,0},{-1,0}};
    public int[][] flipChess (int[][] A, int[][] f) {
        // write code here
        for(int i=0;i<f.length;i++){
            int x=f[i][0]-1;
            int y=f[i][1]-1;
            change(A,x,y);
        }
        return A;
    }
    
    public void change(int[][] nums,int x,int y){
        int m=nums.length,n=nums[0].length;
        for (int i=0;i<dir.length;i++){
            int dx=x+dir[i][0];
            int dy=y+dir[i][1];
            if (dx>=0&&dy>=0&&dx<m&&dy<n){
                nums[dx][dy]=Math.abs(1-nums[dx][dy]);
            }
        }
    }
}

思路：根据题目要求直接模拟即可。

 

MT3 拜访

中等  通过率：50.34%  时间限制：1秒  空间限制：256M

知识点动态规划广度优先搜索(BFS)

描述

现在有一个城市销售经理，需要从公司出发，去拜访市内的某位商家，已知他的位置以及商家的位置，但是由于城市道路交通的原因，他每次移动只能在左右中选择一个方向 或 在上下中选择一个方向，现在问他有多少种最短方案到达商家地址。

给定一个地图 CityMap 及它的 行长度 n 和 列长度 m ，其中1代表经理位置， 2 代表商家位置， -1 代表不能经过的地区， 0 代表可以经过的地区，请返回方案数，保证一定存在合法路径。保证矩阵的长宽都小于等于 10。

注意：需保证所有方案的距离都是最短的方案

 

数据范围：2 \leq n,m \leq 102≤n,m≤10

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param CityMap int整型二维数组 
     * @param n int整型 
     * @param m int整型 
     * @return int整型
     */
    int[][] dir={{-1,0},{1,0},{0,1},{0,-1}};
    public int countPath (int[][] CityMap, int n, int m) {
        // write code here
        int sx=0,sy=0,ex=0,ey=0;
        for (int i=0;i<n;i++){
            for (int j=0;j<m;j++){
                if (CityMap[i][j]==2){
                    sx=i;
                    sy=j;
                }
                if (CityMap[i][j]==1){
                    ex=i;
                    ey=j;
                }
            }
        }
        Queue<int[]> queue=new LinkedList<>();
        int ans=0;
        queue.offer(new int[]{sx,sy});
        while (!queue.isEmpty()){
            int size=queue.size();
            if (ans!=0) break;
            for (int i=0;i<size;i++){
                int[] temp=queue.poll();
                if (temp[0]==ex&&temp[1]==ey) ans++;
                for (int j=0;j<dir.length;j++){
                    int dx=temp[0]+dir[j][0];
                    int dy=temp[1]+dir[j][1];
                    if (dx>=0&&dy>=0&&dx<n&&dy<m&&CityMap[dx][dy]!=-1){
                        queue.offer(new int[]{dx,dy});
                    }
                }
            }
        }
        return ans;
    }
}

思路：BFS,每次进队的都是相同步数的可能位置，当出现终点时，说明出现了最短步数，统计这一层所有的方案。