Leetcode 第128场双周赛 问题和解法

问题

字符串的分数

给你一个字符串s。一个字符串的分数定义为相邻字符ASCII码差值绝对值的和。

请你返回s的分数。

示例 1：

输入：s = "hello"

输出：13

解释：

s 中字符的 ASCII 码分别为：'h' = 104 ，'e' = 101 ，'l' = 108 ，'o' = 111 。所以 s 的分数为 |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13 。

解题思路

遍历所有相邻字母，累加 ASCII 差的绝对值。

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

覆盖所有点的最少矩形数目

给你一个二维整数数组point，其中points[i]=[xi,yi]表示二维平面内的一个点。同时给你一个整数w。你需要用矩形覆盖所有点。

每个矩形的左下角在某个点(x1,0)处，且右上角在某个点(x2,y2)处，其中x1<=x2且y2>=0，同时对于每个矩形都必须满足x2-x1<=w。

如果一个点在矩形内或者在边上，我们说这个点被矩形覆盖了。

请你在确保每个点都至少被一个矩形覆盖的前提下，最少需要多少个矩形。

注意：一个点可以被多个矩形覆盖。

示例 1：

输入：points = [[2,1],[1,0],[1,4],[1,8],[3,5],[4,6]], w = 1

输出：2

解释：

上图展示了一种可行的矩形放置方案：

一个矩形的左下角在 (1, 0) ，右上角在 (2, 8) 。
一个矩形的左下角在 (3, 0) ，右上角在 (4, 8) 。

解题思路

1.把横坐标按照从小到大的顺序排序。
2.为方便计算，假设第一个矩形左边还有一个矩形，初始化 2= -1，因为所有横坐标都是非负数。
3.遍历横坐标 x= points[i][0]，如果 x>2，我们需要一个新的 ri=x 的矩形，答案加一，然后把 “2更新为 x+w。
4.最后，返回答案

class Solution {
    public int minRectanglesToCoverPoints(int[][] points, int w) {
        Arrays.sort(points, (p, q) -> p[0] - q[0]);
        int ans = 0;
        int x2 = -1;
        for (int[] p : points) {
            if (p[0] > x2) {
                ans++;
                x2 = p[0] + w;
            }
        }
        return ans;
    }
}

访问消失节点的最少时间

给你一个二维数组edges表示一个n个点的无向图，其中edges[i]=[ui,vi,lengthi]表示节点ui和节点vi之间有一条需要lengthi单位时间通过的无向边。

同时给你一个数组disappear，其中disappear[i]表示节点i从图中消失的时间点，在那一刻及以后，你无法再访问这个节点。

注意，图有可能一开始是不连通的，两个节点之间也可能有多条边。

请你返回数组answer，answer[i]表示从节点0到节点i需要的最少单位时间。如果从节点0出发无法到达节点i，那么answer[i]为-1。

示例 1：

输入：n = 3, edges = [[0,1,2],[1,2,1],[0,2,4]], disappear = [1,1,5]

输出：[0,-1,4]

解释：

我们从节点 0 出发，目的是用最少的时间在其他节点消失之前到达它们。

对于节点 0 ，我们不需要任何时间，因为它就是我们的起点。
对于节点 1 ，我们需要至少 2 单位时间，通过 edges[0] 到达。但当我们到达的时候，它已经消失了，所以我们无法到达它。
对于节点 2 ，我们需要至少 4 单位时间，通过 edges[2] 到达。

解题思路

对于本题，answer 几乎就是 dis 数组。只需要在 Dijkstra 算法的基础上，添加一处判断逻辑，在更新最短路之前，如果最短路长度 > disappeari]则不更新。

class Solution {
    public int[] minimumTime(int n, int[][] edges, int[] disappear) {
        List<int[]>[] g = new ArrayList[n]; // 稀疏图用邻接表
        Arrays.setAll(g, i -> new ArrayList<>());
        for (int[] e : edges) {
            int x = e[0];
            int y = e[1];
            int wt = e[2];
            g[x].add(new int[]{y, wt});
            g[y].add(new int[]{x, wt});
        }

        int[] dis = new int[n];
        Arrays.fill(dis, -1);
        dis[0] = 0;
        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> (a[0] - b[0]));
        pq.offer(new int[]{0, 0});
        while (!pq.isEmpty()) {
            int[] p = pq.poll();
            int dx = p[0];
            int x = p[1];
            if (dx > dis[x]) { // x 之前出堆过
                continue;
            }
            for (int[] e : g[x]) {
                int y = e[0];
                int newDis = dx + e[1];
                if (newDis < disappear[y] && (dis[y] < 0 || newDis < dis[y])) {
                    dis[y] = newDis; // 更新 x 的邻居的最短路
                    pq.offer(new int[]{newDis, y});
                }
            }
        }
        return dis;
    }
}

边界元素是最大值的子数组数目

给你一个正整数数组nums。

请你求出nums中有多少个子数组，满足子数组中第一个和最后一个元素都是这个子数组中的最大值。

示例 1：

输入：nums = [1,4,3,3,2]

输出：6

解释：

总共有 6 个子数组满足第一个元素和最后一个元素都是子数组中的最大值：

子数组 [1,4,3,3,2] ，最大元素为 1 ，第一个和最后一个元素都是 1 。
子数组 [1,4,3,3,2] ，最大元素为 4 ，第一个和最后一个元素都是 4 。
子数组 [1,4,3,3,2] ，最大元素为 3 ，第一个和最后一个元素都是 3 。
子数组 [1,4,3,3,2] ，最大元素为 3 ，第一个和最后一个元素都是 3 。
子数组 [1,4,3,3,2] ，最大元素为 2 ，第一个和最后一个元素都是 2 。
子数组 [1,4,3,3,2] ，最大元素为 3 ，第一个和最后一个元素都是 3 。
所以我们返回 6 。

解题思路

1.初始化答案等于n，因为每个元素可以单独组成一个长为1的子数组，满足题目要求。
2.维护一个底大顶小的单调栈，记录元素及其出现次数。
3.从左到右遍历 nums。
4.只要 x=numsi] 大于栈顶，就把栈顶出栈。
5.如果 : 小于栈顶，把 “ 及其出现次数 1 入栈。
6.如果 :等于栈顶，设栈顶记录的出现次数为 cnt，那么 :可以和左边 cnt 个x 组成 cnt 个满足要求的子数组，把答案增加 cnt，然后把 cnt 加一。

class Solution {
    public long numberOfSubarrays(int[] nums) {
        long ans = nums.length;
        Deque<int[]> st = new ArrayDeque<>();
        st.push(new int[]{Integer.MAX_VALUE, 0}); // 无穷大哨兵
        for (int x : nums) {
            while (x > st.peek()[0]) {
                st.pop();
            }
            if (x == st.peek()[0]) {
                ans += st.peek()[1]++;
            } else {
                st.push(new int[]{x, 1});
            }
        }
        return ans;
    }
}

来源

LeetCode周赛