Leetcode - 周赛413

目录

一，3274. 检查棋盘方格颜色是否相同

二，3275. 第 K 近障碍物查询

三，3276. 选择矩阵中单元格的最大得分

四，3277. 查询子数组最大异或值

---

一，3274. 检查棋盘方格颜色是否相同

本题就是找规律，假设白色是true，黑色是false，可以发现 a - 2 4 6 8，b - 1 3 5 7 是白色，也就是说可以通过 （x - 'a'）% 2 == (y - '0')%2 来判断该点是什么颜色，再返回两个点颜色是否相同。

代码如下：

class Solution {
    //a - 2 4 6 8
    //b - 1 3 5 7
    //c - 2 4 6 8
    //白
    public boolean checkTwoChessboards(String c1, String c2) {
        boolean a = (c1.charAt(0)-'a')%2 == (c1.charAt(1)-'0')%2;
        boolean b = (c2.charAt(0)-'a')%2 == (c2.charAt(1)-'0')%2;
        return a == b;
    }
}

二，3275. 第 K 近障碍物查询

本题是一种常见的堆应用问题（Top k 问题），维护第 k 小使用最大堆，维护第 k 大使用最小堆。本题求第 k 小的距离，所以使用最大堆。通过维护堆的大小来达到目的。

代码如下：

class Solution {
    public int[] resultsArray(int[][] queries, int k) {
        int n = queries.length;
        int[] ans = new int[n];
        PriorityQueue<Integer> que = new PriorityQueue<>((x,y)->y-x);
        for(int i=0; i<n; i++){
            que.offer(Math.abs(queries[i][0]) + Math.abs(queries[i][1]));
            if(que.size() > k)
                que.poll();
            ans[i] = que.size() == k ? que.peek() : -1;
        }
        return ans;
    }
}

三，3276. 选择矩阵中单元格的最大得分

本题可以使用枚举选哪个来做，枚举每一行可以选取的数字，求出所有组合中的最大得分，可以这样定义 dfs(i，j)：前 i 行可以获得的最大得分，j表示已经选举过的数字。代码如下：

//超时写法
//Java无法支持长度为100的整形，所以这里用py写的
class Solution:
    def maxScore(self, grid: List[List[int]]) -> int:
        @cache
        def dfs(i: int, x: int) -> int:
            if i < 0: return 0
            res = dfs(i-1, x)
            for j in range(len(grid[0])):
                y = grid[i][j]
                if x >> y & 1: continue
                res = max(res, dfs(i-1, x|1<<y) + y)
            return res
        dfs.cache_clear()
        ans = dfs(len(grid)-1, 0)
        return ans 

但是该算法的时间复杂是O(n^2*2^100)，这个做法明显超时了，那么我们要如何来降低时间复杂度？

之前有场周赛可以提供一点思路，就是如果枚举下标超时，那么我们是否可以尝试枚举值呢？对于本题来说，矩阵的数据范围是1~100，此时它的时间复杂度就变成了O(mn * 2 ^ n)，我们可以使用选或不选的思路，定义dfs(i，j)：在 [1，i] 区间选择数字，且该数字不会出现在 j 集合中，此时所选元素的最大值之和。

• 对于 i，如果不选，那么接下来就变成从 [1，i-1] 区间选择数字，且该数字不会出现在 j 集合中，此时所选元素的最大值之和，状态表示为 dfs(i-1，j)
• 对于 i，如果选，假设该值在 k 行（在dfs之前要预处理每个值所在的行），那么接下来就变成从 [1，i-1] 区间选择数字，且该数字不会出现在 j U k 集合中，此时所选元素的最大值之和，状态表示为 dfs(i-1，j|1<<k)

代码如下：

class Solution {
    public int maxScore(List<List<Integer>> grid) {
        List<Integer>[] pos = new ArrayList[101];
        Arrays.setAll(pos, e -> new ArrayList<>());
        for(int i=0; i<grid.size(); i++){
            Set<Integer> set = new HashSet<>();
            for(int x : grid.get(i))
                set.add(x);
            for(int x : set)
                pos[x].add(i);
        }
        memo = new int[101][1<<grid.size()];
        for(int i=0; i<101; i++)
            Arrays.fill(memo[i], -1);
        return dfs(100, 0, pos);
    }
    int[][] memo;
    int dfs(int i, int j, List<Integer>[] pos){
        if(i == 0) return 0;
        if(memo[i][j] != -1) return memo[i][j];
        int res = dfs(i-1, j, pos);
        for(int x : pos[i]){
            if((j>>x&1) == 1) continue;
            res = Math.max(res, dfs(i-1, j|1<<x, pos) + i);
        }
        return memo[i][j] = res;
    }
}

递推版本：

class Solution {
    public int maxScore(List<List<Integer>> grid) {
        List<Integer>[] pos = new ArrayList[101];
        Arrays.setAll(pos, e -> new ArrayList<>());
        for(int i=0; i<grid.size(); i++){
            Set<Integer> set = new HashSet<>();
            for(int x : grid.get(i))
                set.add(x);
            for(int x : set)
                pos[x].add(i);
        }
        int[][] f = new int[101][1<<grid.size()];
        for(int i=1; i<101; i++){
            for(int j=0; j<1<<grid.size(); j++){
                f[i][j] = f[i-1][j];
                for(int x : pos[i]){
                    if((j>>x&1) == 1) continue;
                    f[i][j] = Math.max(f[i][j], f[i-1][j|1<<x] + i);
                }
            }
        }
        return f[100][0];
    }
}

四，3277. 查询子数组最大异或值

本题可以通过模拟每一步的过程来得到一个递推公式，如图所示：

根据该公式我们可以得到任意一个区间的异或值，那么要如何计算 [L，R] 区间子数组的最大异或值呢？这里也可以使用区间dp，mx[i][j]：[i，j] 区间的子数组的最大异或值，mx[i][j] = max(f[i][j]，mx[i][j-1]，mx[i+1][j])，画个图理解一下：

代码如下：

class Solution {
    public int[] maximumSubarrayXor(int[] nums, int[][] queries) {
        int n = nums.length;
        int[][] f = new int[n][n];
        //f[i][j] = f[i+1][j]^f[i][j-1];
        int[][] mx = new int[n][n];
        //mx[i][j] = max(f[i][j], max(mx[i+1][j], mx[i][j-1]))
        for(int i=n-1; i>=0; i--){
            f[i][i] = mx[i][i] = nums[i];
            for(int j=i+1; j<n; j++){
                f[i][j] = f[i+1][j]^f[i][j-1];
                mx[i][j] = Math.max(f[i][j], Math.max(mx[i+1][j], mx[i][j-1]));
            }
        }
        int[] ans = new int[queries.length];
        for(int i=0; i<queries.length; i++){
            ans[i] = mx[queries[i][0]][queries[i][1]];
        }
        return ans;
    }
}