目录
一，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;
}
}
