Leetcode 244 场周赛

t1：5776. 判断矩阵经轮转后是否一致

思路：枚举旋转90度，180度，270度，然后对比目标数组。

代码：

class Solution {
    public boolean findRotation(int[][] mat, int[][] target) {
        boolean r = checkAgreement(mat, target);
        if (r){
            return true;
        }
        int[][] t1 = goRotation90(mat);
        boolean r1 = checkAgreement(t1, target);
        if (r1){
            return true;
        }
        int[][] t2 = goRotation90(t1);
        boolean r2 = checkAgreement(t2, target);
        if (r2){
            return true;
        }
        int[][] t3 = goRotation90(t2);
        boolean r3 = checkAgreement(t3, target);
        if (r3){
            return true;
        }
        return false;
    }
    public int[][] goRotation90(int[][] mat){
        int n = mat.length;
        int t1[][] = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                t1[j][i] = mat[n-1-i][j];
            }
        }
        return t1;
    }
    public boolean checkAgreement(int[][] mat, int[][] target){
        int n = mat.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (mat[i][j]!=target[i][j]){
                    return false;
                }
            }
        }
        return true;
    }
}

t2：5777. 使数组元素相等的减少操作次数

思路：利用一个set来存储按大小排序的所有值，然后用一个map计数，然后模拟整个操作。

class Solution {
    public int reductionOperations(int[] nums) {
        Arrays.sort(nums);
        Set<Integer> set = new LinkedHashSet<>();
        Map<Integer,Integer> map = new HashMap<>();
        for (int i = nums.length-1; i >=0 ; i--) {
            set.add(nums[i]);
            if (map.containsKey(nums[i])){
                map.put(nums[i],map.get(nums[i])+1);
            }else {
                map.put(nums[i],1);
            }
        }
        List<Integer> collect = new ArrayList<>(set);
        int res = 0;
        while (collect.size()>1){
            Integer t1 = collect.get(0);
            Integer t2 = collect.get(1);
            Integer c = map.get(t1);
            res+=c;
            map.put(t2,map.get(t2)+c);
            collect.remove(0);
        }

        return res;
    }
}

t3：5778. 使二进制字符串字符交替的最少反转次数

思路：可以使用滑动窗口的思路，先将这个字符串按照规则计算一下需要翻转多少次，按照10开始计算次数，那么01开始的结果就是，字符串长度减去10规则的差值。然后复制一份s。利用滑动窗口来计算出答案。

class Solution {
    public int minFlips(String s) {
        if (s.length()<=1){
            return 0;
        }
        if (s.length()==2){
            return s.charAt(0)==s.charAt(1)?1:0;
        }
        int n = s.length();
        int res = 0;
        String c = "01";
        for (int i = 0; i < n; i++) {
            res += c.charAt(i&1)==s.charAt(i)?0:1;
        }
        s+=s;
        // 按照01 排列  反之按照10排列的答案就是 长度减去 01排列的值
        int ans = Math.min(res,n-res);
        for (int i = 0; i < n; i++) {
            // 由于头部拼接到了尾部 还原之前消耗的数据
            res -= c.charAt(i&1)==s.charAt(i)?0:1;
            // 加上新增的尾部
            res += c.charAt((n+i)&1)==s.charAt(n+i)?0:1;
            ans = Math.min(ans,Math.min(res,n-res));
        }
        return ans;
    }
}