Leetcode - 139双周赛

目录

一，3285. 找到稳定山的下标

二，3286. 穿越网格图的安全路径

三，3287. 求出数组中最大序列值

四，3288. 最长上升路径的长度

---

一，3285. 找到稳定山的下标

本题就是找[0， n-2]中，height[i] 小于 threshold 的所有下标，直接枚举，代码如下：

class Solution {
    public List<Integer> stableMountains(int[] height, int threshold) {
        List<Integer> ans = new ArrayList<>();
        for(int i=0; i<height.length-1; i++){
            if(height[i] > threshold)
                ans.add(i+1);
        }
        return ans;
    }
}

二，3286. 穿越网格图的安全路径

本题就是一道求从起点到终点的最短边权，是一道经典的djstra问题，只不过这里是使用（x，y）这样的坐标来表示当前位置，代码如下：

class Solution {
    int[][] dirct = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
    public boolean findSafeWalk(List<List<Integer>> grid, int health) {
        int m = grid.size(), n = grid.get(0).size();
        int[][] dis = new int[m][n];//(0,0)->(i,j)的安全路线
        for(int i=0; i<m; i++) Arrays.fill(dis[i], Integer.MAX_VALUE/2);
        PriorityQueue<int[]> que = new PriorityQueue<>((x,y)->x[0]-y[0]);
        que.add(new int[]{grid.get(0).get(0), 0, 0});
        dis[0][0] = grid.get(0).get(0);
        while(!que.isEmpty()){
            int[] t = que.poll();
            if(t[0] != dis[t[1]][t[2]]) continue;
            for(int[] d : dirct){
                int x = t[1] + d[0], y = t[2] + d[1];
                if(x>=0 && x<m && y>=0 && y<n){
                    if(dis[t[1]][t[2]] + grid.get(x).get(y) < dis[x][y]){
                        dis[x][y] = dis[t[1]][t[2]] + grid.get(x).get(y);
                        que.add(new int[]{dis[x][y], x, y});
                    }
                }
            }
        }
        return dis[m-1][n-1] < health;
    } 
}

但是题目中说，边权仅为0 / 1，所以我们可以使用双端队列来模拟最小堆，可以节约一些时间，代码如下：

class Solution {
    int[][] dirct = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
    public boolean findSafeWalk(List<List<Integer>> grid, int health) {
        ArrayDeque<int[]> que = new ArrayDeque<>();
        que.add(new int[]{0, 0});
        int m = grid.size(), n = grid.get(0).size();
        int[][] dis = new int[m][n];//(0,0)->(i,j)的安全路线
        for(int i=0; i<m; i++) Arrays.fill(dis[i], Integer.MAX_VALUE/2);
        dis[0][0] = grid.get(0).get(0);
        while(!que.isEmpty()){
            int[] t = que.poll();
            for(int[] d : dirct){
                int x = t[0] + d[0], y = t[1] + d[1];
                if(x>=0 && x<m && y>=0 && y<n){
                    if(dis[t[0]][t[1]] + grid.get(x).get(y) < dis[x][y]){
                        dis[x][y] = dis[t[0]][t[1]] + grid.get(x).get(y);
                        if(grid.get(x).get(y) == 0)
                            que.addFirst(new int[]{x, y});
                        else
                            que.addLast(new int[]{x, y});
                    }
                }
            }
        }
        return dis[m-1][n-1] < health;
    } 
}

三，3287. 求出数组中最大序列值

由于本题是数据范围较小，所以我们可以暴力求出左半边和右半边的所有子序列进行或运算得到的值，再通过枚举中间位置来求出 x ^ y 的最大值。

这里的主要问题就是如何计算出左半边和右半边能得到的所有或值，我们可以定义一个f[i][j][x]：表示能否从前 i 个数中选择 j 个数，且或值恰好为 x。

• 不选 v = nums[i]，f[i+1][j][x] = f[i][j-1][x]
• 选 v = nums[i]，f[i+1][j][x|v] = f[i+1][j][x|v] or f[i][j-1][x]

代码如下：

class Solution {
    public int maxValue(int[] nums, int k) {
        int n = nums.length;
        int MX = 1<<7;
        boolean[][][] pre = new boolean[n+1][k+1][1<<7];
        for(int i=0; i<=n; i++) pre[i][0][0] = true;
        for (int i=0; i<n; i++){
            int v = nums[i];
            for (int j=1; j<=k; j++){
                for (int x=0; x<MX; x++){   
                    pre[i+1][j][x] |= pre[i][j][x];
                    pre[i+1][j][x|v] |= pre[i][j-1][x];
                }
            }
        }
        boolean[][][] suf = new boolean[n+1][k+1][1<<7];
        for(int i=0; i<=n; i++) suf[i][0][0] = true;
        for (int i=n-1; i>=0; i--){
            int v = nums[i];
            for (int j=1; j<=k; j++){
                for (int x=0; x<MX; x++){
                    suf[i][j][x] |= suf[i+1][j][x];
                    suf[i][j][x|v] |= suf[i+1][j-1][x];
                }
            }
        }
        int ans = 0;
        for(int i = k - 1; i < n - k; i++){
            for(int x = 0; x < MX; x++){
                if(pre[i + 1][k][x]){
                    for(int y = 0; y < MX; y++){
                        if(suf[i + 1][k][y]){
                            ans = Math.max(ans, x ^ y);
                        }
                    }
                }
            }
        }
        return ans;
    }
}

四，3288. 最长上升路径的长度

本题就是求最长上升子序列的题，只不过这里改成了坐标的形式，我们需要先给坐标按横坐标排序，在使用二分，但是需要注意的点是，可能存在有多个点，它们的横坐标相同，如果在横坐标相同时，纵坐标从小到大来排序，那么在计算的时候会重复计算，但是题目要求每个横纵坐标都要大于前一个点才算是上升序列，所以我们在横坐标相同时，纵坐标从大到小来排序，这样一来每个横坐标就只会计算一个纵坐标的点。

代码如下：

class Solution {
    public int maxPathLength(int[][] c, int k) {
        int n = c.length;
        int a = c[k][0], b = c[k][1];
        Arrays.sort(c, (x, y)->x[0]==y[0]?y[1]-x[1]:x[0]-y[0]);
        int[] f = new int[n+1];
        int ret = 0;
        for(int[] t : c){
            if(t[0] < a && t[1] < b || t[0] > a && t[1] > b){
                if(ret == 0 || f[ret] < t[1]){
                    f[++ret] = t[1];
                }else{
                    int l = 1, r = ret;
                    while(l <= r){
                        int mid = (l + r) / 2;
                        if(f[mid] < t[1]) l = mid + 1;
                        else r = mid - 1;
                    }
                    f[l] = t[1]; 
                }
            }
        }
        return ret + 1;
    }
}