【leetcode学习笔记】周赛339

最长平衡子字符串

https://leetcode.cn/problems/find-the-longest-balanced-substring-of-a-binary-string/

解析：遍历数组的所有位置，实时记录当前连续相同字符个数cur和上一段连续相同字符个数pre。如果当前字符为1，那么当前这个01串的最大长度就是。记录最大长度即可。

cur和pre的更新原则为：如果i = 0 或者 s[i] == s[i-1]，cur++；否则令pre=cur，cur=1。

代码：

class Solution {
    public int findTheLongestBalancedSubstring(String s) {
        int pre = 0;
        int cur = 0;
        int res = 0;
        for(int i = 0; i < s.length(); i++){
            if(i == 0 || s.charAt(i) == s.charAt(i-1)){
                cur++;
            }
            else{
                pre = cur;
                cur = 1;
            }
            if(s.charAt(i) == '1'){
                res = Math.max(res, Math.min(pre, cur) * 2);
            }
        }
        return res;
    }
}

转换二维数组

https://leetcode.cn/problems/convert-an-array-into-a-2d-array-with-conditions/

解析：如果k在nums中出现了m次，那么只需要在res[0], ..., res[m-1]中插入k即可。

代码：

class Solution {
    public List<List<Integer>> findMatrix(int[] nums) {
        Map<Integer, Integer> h = new HashMap<>();
        List<List<Integer>> res = new ArrayList<>();
        
        for(int num: nums){
            int ind = h.getOrDefault(num, 0);
            if(res.size() == ind){
                res.add(new ArrayList<>());
            }
            res.get(ind).add(num);
            h.put(num, ind+1);
        }
        return res;
    }
}

老鼠和奶酪

https://leetcode.cn/problems/mice-and-cheese/

解析：对于任意分配方案，都有

因此，由于第一只老鼠所吃数量固定为k，因此我们只需要找到最大的k个reward1[i] - reward2[i]即可。

代码：

class Solution {
    public int miceAndCheese(int[] reward1, int[] reward2, int k) {
        int res = 0;
        for(int i = 0; i < reward1.length; i++){
            res += reward2[i];
            reward1[i] -= reward2[i];
        }
        Arrays.sort(reward1);
        for(int i = reward1.length - 1; i >= reward1.length - k; i--){
            res += reward1[i];
        }
        return res;
    }
}

最少翻转操作数

https://leetcode.cn/problems/minimum-reverse-operations/

解析：

第一，对于i处的元素，它可能翻转到的区间是[max(i-k+1, k-i+1), min(ind+k-1, 2n-k-ind-1)]，且跳跃间隔为2。

第二，为了求翻转的最小距离，需要用到BFS。先把p一次翻转可达的所有有效位置标为1，再把1中位置能遍历到的所有有效位置标为2，直至BFS的队列为空。

第三，为了减少判断“是否遍历”的时间复杂度，我们设立两个平衡二叉树（用HashSet会超时），分别存储没有被ban且未被翻转到的奇数下标和偶数下标。然后在BFS的过程中，不断剔除即可。

代码：

class Solution {
    public int[] minReverseOperations(int n, int p, int[] banned, int k) {
        TreeSet<Integer>[] visit = new TreeSet[2];
        visit[0] = new TreeSet<>();
        visit[1] = new TreeSet<>();
        visit[0].add(n);
        visit[1].add(n);
        for(int i = 0; i < n; i++){
            if(i != p){
                visit[i % 2].add(i);
            }
        }
        for(int ban: banned){
            visit[ban % 2].remove(ban);
        }
        int[] res = new int[n];
        Arrays.fill(res, -1);

        Queue<int[]> q = new LinkedList<>();
        q.offer(new int[]{p, 0});
        while(!q.isEmpty()){
            int ind = q.element()[0];
            int cnt = q.element()[1];
            res[ind] = cnt;
            q.poll();
            int left = Math.max(ind - k + 1, k - ind - 1);
            int right = Math.min(ind + k - 1, n * 2 - k - ind - 1);
            for(int mid = visit[left % 2].ceiling(left); mid <= right; mid = visit[left % 2].ceiling(left)){
                q.offer(new int[]{mid, cnt+1});
                visit[mid % 2].remove(mid);
            }
        }
        return res;
    }
}

注：加入哨兵n是为了TreeSet.ceiling()命令不会触发空指针异常。