Leetcode - 128双周赛

[一，3110. 字符串的分数](#一，3110. 字符串的分数)

[二，3111. 覆盖所有点的最少矩形数目](#二，3111. 覆盖所有点的最少矩形数目)

[三，3112. 访问消失节点的最少时间编辑](#三，3112. 访问消失节点的最少时间编辑)

[写法一：朴素 Dijkstra（适用于稠密图，即边比较多的图）](#写法一：朴素 Dijkstra（适用于稠密图，即边比较多的图）)

[写法二：堆优化 Dijkstra（适用于稀疏图，即边比较少的图）](#写法二：堆优化 Dijkstra（适用于稀疏图，即边比较少的图）)

[四，3113. 边界元素是最大值的子数组数目](#四，3113. 边界元素是最大值的子数组数目)

一，3110. 字符串的分数

本题就是求相邻字符差值绝对值的和，从下标1开始遍历，计算 i 和 i-1 的差值绝对值，将其加起来就是答案。

代码如下：

class Solution {
    public int scoreOfString(String s) {
        int ans = 0;
        for(int i=1; i<s.length(); i++){
            ans += Math.abs(s.charAt(i)-s.charAt(i-1));
        }
        return ans;
    }
}

二，3111. 覆盖所有点的最少矩形数目

仔细读题可以发现，其实这题与纵坐标没有关系，只需要关注横坐标就行了，所以题目就变成了在 x2 - x1 <= w 的情况下，最少需要几个线段才能覆盖所有横坐标。

该题需要对横坐标进行排序，再遍历横坐标，用一个变量 r 来统计在以 x 为左端点时最大的右端点，即 r = x + w，当有 xi > r 时，就说明需要添加一个线段ans++，跟新 r = xi + w，直到跳出循环，返回ans

代码如下：

class Solution {
    public int minRectanglesToCoverPoints(int[][] points, int w) {
        Arrays.sort(points, (x,y)->x[0]-y[0]);//排序
        int ans = 0;
        int r = -1;
        for(int i=0; i<points.length; i++){
            if(r < points[i][0]){//跟新右端点和ans
                r = points[i][0] + w;
                ans++;
            }
        }
        return ans;
    }
}

三，3112. 访问消失节点的最少时间

本题求点到点最短路径，一道标准的 djstra算法题（注：该算法不适用于有负权重的图），简单说一下djstra算法的思路：从初始点出发，选出与初始点相邻且距离最近的点，再从初始点和选出的点出发，选出相邻且距离最近的点。（注：每次选出一个点，且该点不是之前选过的点）

这么说有点抽象，画个图理解一下：

可以发现，每次都会找到一个A -> ? 的最短路径，也就是说只要循环 n-1 次，就可以找到A点到其他所有点的最短路径。而在代码实现过程中需要两个数组，一个数组来统计该点是否被访问过，一个数组统计 A->? 的最短路径。

这里先介绍两种写法：

模板一：朴素 Dijkstra（适用于稠密图，即边比较多的图）

class Solution {
    public int moban(int n, int[][] edges) {
        //稠密图建图推荐使用数组建图
        //注：根据题目建图，这里建的是无向图
        int[][] g = new int[n][n];
        for(int i=0; i<n; i++)
            Arrays.fill(g[i], Integer.MAX_VALUE/2);
        for(int[] e : edges){
            int x = e[0], y = e[1], w = e[2];
            g[x][y] = w;
            g[y][x] = w;
        }

        int[] dis = new int[n];//存储从0->i节点的最短路径
        Arrays.fill(dis, Integer.MAX_VALUE/2);//防溢出
        dis[0] = 0;//0->0路径为0
        boolean[] vis = new boolean[n];//统计i点是否已经选择过
        for(int i=0; i<n-1; i++){
            int x = -1;
            for(int j=0; j<n; j++){//找出未访问过的距离A点最近的点
                if(!vis[j]&&(x==-1 || dis[j]<dis[x])){
                    x = j;
                }
            }
            vis[x] = true;//该路径即为0->x的最短路径
            for(int y=0; y<n; y++){//更新0->y的最短路径
                dis[y] = Math.min(dis[y], dis[x]+g[x][y]);
                //注：虽然会遍历到已经访问过的点，但是不会对结果造成影响
            }
        }
        return dis;
    }
}

模板二：堆优化 Dijkstra（适用于稀疏图，即边比较少的图）

class Solution {
    public int[] moban(int n, int[][] edges) {
        //稀疏图建议使用链表建图
        //注：根据题目建图，这里是无向图
        List<int[]>[] g = new ArrayList[n];
        Arrays.setAll(g, e->new ArrayList<>());
        for(int[] e : edges){
            int x = e[0], y = e[1], w = e[2];
            g[x].add(new int[]{y, w});
            g[y].add(new int[]{x, w});
        }
        int[] dis = new int[n];//0->i的最短路径
        Arrays.fill(dis, -1);
        dis[0] = 0;
        PriorityQueue<int[]> que = new PriorityQueue<>((x,y)->x[0]-y[0]);//小根堆
        que.offer(new int[]{0, 0});//(t,j)->t:路径，j:节点
        while(!que.isEmpty()){
            int[] poll = que.poll();
            int dx = poll[0];
            int x = poll[1];
            if(dx > dis[x])//堆的懒删除
                continue;
            for(int[] y : g[x]){
                int newDis = dis[x] + y[1];
                if(dis[y[0]]==-1 || newDis < dis[y[0]]){//更新与x点相邻的点的最短路径
                    dis[y[0]] = newDis;
                    que.offer(new int[]{newDis, y[0]});
                }
            }
        }
        return dis;
    } 
}

本题代码如下：

class Solution {
    public int[] minimumTime(int n, int[][] edges, int[] disappear) {
        List<int[]>[] g = new ArrayList[n];
        Arrays.setAll(g, e->new ArrayList<>());
        for(int[] e : edges){
            int x = e[0], y = e[1], w = e[2];
            g[x].add(new int[]{y, w});
            g[y].add(new int[]{x, w});
        }
        int[] dis = new int[n];
        Arrays.fill(dis, -1);
        dis[0] = 0;
        PriorityQueue<int[]> que = new PriorityQueue<>((x,y)->x[0]-y[0]);
        que.offer(new int[]{0, 0});//(t,j)->t:时间，j:节点
        while(!que.isEmpty()){
            int[] poll = que.poll();
            int dx = poll[0];
            int x = poll[1];
            if(dx > dis[x])
                continue;
            for(int[] y : g[x]){
                int newDis = dis[x] + y[1];
                //本题多了一个条件，所以这里多了个判断
                if(newDis < disappear[y[0]] && (dis[y[0]]==-1 || newDis < dis[y[0]])){
                    dis[y[0]] = newDis;
                    que.offer(new int[]{newDis, y[0]});
                }
            }
        }
        return dis;
    } 
}

四，3113. 边界元素是最大值的子数组数目

本题本质上还是一道单调栈的题，画个图理解一下：

从左往右依次遍历：

[1]时，有[1]成立

[1,4]时，多出[4]成立，这时候1就成了垃圾数据，因为如果包含1，那么这个数组不可能满足题意。删去1

[4,3]时，多出[3]成立，这时4不能删去，因为右端可能出现一个4，使其满足题意

[4,3,2]时，多出[2]成立，这时2不能删去，因为右端可能出现一个2，使其满足题意

[4,3,2,3]时，多出[3][3,2,3]成立，这时2就成了垃圾数据，因为如果包含2，那么这个数组不可能满足题意。删去2

[4,3,3,1]时，多出[1]

可以发现[4,3,3,1]是单调减的，所以可以使用单调栈来解决该问题。

代码如下：

class Solution {
    public long numberOfSubarrays(int[] nums) {
        long ans = 0;
        Deque<int[]> que = new ArrayDeque<>();
        que.add(new int[]{Integer.MAX_VALUE, 0});//防止que为空
        for(int num : nums){
            while(que.getLast()[0]<num){
                que.removeLast();
            }
            if(que.getLast()[0] == num)
                que.addLast(new int[]{num, que.getLast()[1]+1});
            else
                que.addLast(new int[]{num, 1});
            ans += que.getLast()[1];
        }
        return ans;
    }
}