LeetCode第220场周赛_给你一个整数数组 arr ,你一开始在数组的第一个元素处(下标为 0)。每一步,你可以-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_41967623/article/details/111661048

LeetCode第220场周赛

题目：1694. 重新格式化电话号码

给你一个字符串形式的电话号码 number 。number 由数字、空格 ’ '、和破折号 ‘-’ 组成。

请你按下述方式重新格式化电话号码。

首先，删除所有的空格和破折号。
其次，将数组从左到右每 3 个一组分块，直到剩下 4 个或更少数字。剩下的数字将按下述规定再分块：
2 个数字：单个含 2 个数字的块。
3 个数字：单个含 3 个数字的块。
4 个数字：两个分别含 2 个数字的块。
最后用破折号将这些块连接起来。注意，重新格式化过程中不应该生成仅含 1 个数字的块，并且最多生成两个含 2 个数字的块。

返回格式化后的电话号码。

示例 1：

输入：number = “1-23-45 6”
输出：“123-456”
解释：数字是 “123456”
步骤 1：共有超过 4 个数字，所以先取 3 个数字分为一组。第 1 个块是 “123” 。
步骤 2：剩下 3 个数字，将它们放入单个含 3 个数字的块。第 2 个块是 “456” 。
连接这些块后得到 “123-456” 。
示例 2：

输入：number = “123 4-567”
输出：“123-45-67”
解释：数字是 “1234567”.
步骤 1：共有超过 4 个数字，所以先取 3 个数字分为一组。第 1 个块是 “123” 。
步骤 2：剩下 4 个数字，所以将它们分成两个含 2 个数字的块。这 2 块分别是 “45” 和 “67” 。
连接这些块后得到 “123-45-67” 。
示例 3：

输入：number = “123 4-5678”
输出：“123-456-78”
解释：数字是 “12345678” 。
步骤 1：第 1 个块 “123” 。
步骤 2：第 2 个块 “456” 。
步骤 3：剩下 2 个数字，将它们放入单个含 2 个数字的块。第 3 个块是 “78” 。
连接这些块后得到 “123-456-78” 。
示例 4：

输入：number = “12”
输出：“12”
示例 5：

输入：number = "–17-5 229 35-39475 "
输出：“175-229-353-94-75”

提示：

2 <= number.length <= 100
number 由数字和字符 ‘-’ 及 ’ ’ 组成。
number 中至少含 2 个数字。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reformat-phone-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：

数据给范围很宽裕，所以直接模拟就行。

把所有空格和‘-’去掉后，按照题目思路模拟一边。

class Solution {
    public String reformatNumber(String number) {
        number = number.replaceAll("-", "");
        number = number.replaceAll(" ", "");
        StringBuffer sb = new StringBuffer();
        int cnt = 0;
        boolean flag = true;
        for(int i = 0; i < number.length(); i++) {
            if(flag && cnt == 3) {
                cnt = 0;
                sb.append("-");

                if(number.length() - i == 4) {
                    flag = false;
                }
            }
            if(i == 0 && number.length() - i == 4) {
                flag = false;
            }
            if(!flag && number.length() - i == 2) {
                sb.append("-");
            }
            sb.append(number.charAt(i));
            cnt++;
        }
        return sb.toString();
    }
}

题目：1695. 删除子数组的最大得分

给你一个正整数数组 nums ，请你从中删除一个含有若干不同元素的子数组。删除子数组的得分就是子数组各元素之和。

返回只删除一个子数组可获得的最大得分。

如果数组 b 是数组 a 的一个连续子序列，即如果它等于 a[l],a[l+1],…,a[r] ，那么它就是 a 的一个子数组。

示例 1：

输入：nums = [4,2,4,5,6]
输出：17
解释：最优子数组是 [2,4,5,6]
示例 2：

输入：nums = [5,2,1,2,5,2,1,2,5]
输出：8
解释：最优子数组是 [5,2,1] 或 [1,2,5]

提示：

1 <= nums.length <= 105
1 <= nums[i] <= 104

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-erasure-value
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：滑动窗口

使用一个map记录窗口中已出现的数字，当有新加进窗口的数已存在就从窗口的开始一直删到窗口中每个数只出现一次；然后当有新的数加入窗口时记录一次结果。

class Solution {
    public int maximumUniqueSubarray(int[] nums) {
        int ans = 0;
        int sum = 0;
        int n = nums.length;
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int i = 0, j = 0; i < n; i++){
            int t = map.getOrDefault(nums[i], -1);
            sum += nums[i];
            if(t == -1) {
                ans = Math.max(ans, sum);
            }else {
                while(j <= t){
                    sum -= nums[j];
                    map.put(nums[j], -1);
                    j++;
                }
            }
            map.put(nums[i], i);
        }
        return ans;
    }
}

题目：1696. 跳跃游戏 VI

给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。

一开始你在下标 0 处。每一步，你最多可以往前跳 k 步，但你不能跳出数组的边界。也就是说，你可以从下标 i 跳到 [i + 1， min(n - 1, i + k)] 包含两个端点的任意位置。

你的目标是到达数组最后一个位置（下标为 n - 1 ），你的得分为经过的所有数字之和。

请你返回你能得到的最大得分。

示例 1：

输入：nums = [1,-1,-2,4,-7,3], k = 2
输出：7
解释：你可以选择子序列 [1,-1,4,3] （上面加粗的数字），和为 7 。
示例 2：

输入：nums = [10,-5,-2,4,0,3], k = 3
输出：17
解释：你可以选择子序列 [10,4,3] （上面加粗数字），和为 17 。
示例 3：

输入：nums = [1,-5,-20,4,-1,3,-6,-3], k = 2
输出：0

提示：

1 <= nums.length, k <= 105
-104 <= nums[i] <= 104

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/jump-game-vi
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：动态规划+单调队列

使用普通的动态规划，定义一个a， a[i]表示到i位置的最大得分，对于i位置，我们可以在i位置前k个数的范围内找最大值。但这样会超时。

对于在一个k个数的范围内找最大值可以使用单调队列来优化成o（1）的时间。

class Solution {
    public int maxResult(int[] nums, int k) {
        int n = nums.length;
        int[] ans = new int[n];

        LinkedList<Integer> q = new LinkedList<>();
        ans[0] = nums[0];
        q.offer(0);
        for(int i = 1; i < n; i++) {
            if(i - q.peekFirst() > k) q.pollFirst();
            ans[i] = ans[q.peekFirst()] + nums[i];

            while(!q.isEmpty() && ans[q.peekLast()] <= ans[i]) q.pollLast();
            q.offer(i);
        }

        return ans[n - 1];
    }
}

题目：1697. 检查边长度限制的路径是否存在

给你一个 n 个点组成的无向图边集 edgeList ，其中 edgeList[i] = [ui, vi, disi] 表示点 ui 和点 vi 之间有一条长度为 disi 的边。请注意，两个点之间可能有超过一条边。

给你一个查询数组queries ，其中 queries[j] = [pj, qj, limitj] ，你的任务是对于每个查询 queries[j] ，判断是否存在从 pj 到 qj 的路径，且这条路径上的每一条边都严格小于 limitj 。

请你返回一个布尔数组 answer ，其中 answer.length == queries.length ，当 queries[j] 的查询结果为 true 时， answer 第 j 个值为 true ，否则为 false 。

示例 1：

输入：n = 3, edgeList = [[0,1,2],[1,2,4],[2,0,8],[1,0,16]], queries = [[0,1,2],[0,2,5]]
输出：[false,true]
解释：上图为给定的输入数据。注意到 0 和 1 之间有两条重边，分别为 2 和 16 。
对于第一个查询，0 和 1 之间没有小于 2 的边，所以我们返回 false 。
对于第二个查询，有一条路径（0 -> 1 -> 2）两条边都小于 5 ，所以这个查询我们返回 true 。
示例 2：

输入：n = 5, edgeList = [[0,1,10],[1,2,5],[2,3,9],[3,4,13]], queries = [[0,4,14],[1,4,13]]
输出：[true,false]
解释：上图为给定数据。

提示：

2 <= n <= 105
1 <= edgeList.length, queries.length <= 105
edgeList[i].length == 3
queries[j].length == 3
0 <= ui, vi, pj, qj <= n - 1
ui != vi
pj != qj
1 <= disi, limitj <= 109
两个点之间可能有多条边。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/checking-existence-of-edge-length-limited-paths
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：并查集

我们将edgeList和queries，按照权值从小到大排序，然后使用并查集来维护图的连通性。

class Solution {
    int[] UN;
    public void un(int x, int y) {
        int xf = find(x);
        int yf = find(y);
        if(xf == yf) {
            return;
        }
        UN[xf] = yf;
    }

    public int find(int x){
        return UN[x] == x ? x : (UN[x] = find(UN[x]));
    }

    public boolean[] distanceLimitedPathsExist(int n, int[][] edgeList, int[][] queries) {
        int k = edgeList.length;
        int m = queries.length;
        boolean[] ans = new boolean[m];
        UN = new int[n];
        for(int i = 0; i < n; i++) {
            UN[i] = i;
        }

        int[][] f = new int[m][4];
        for(int i = 0; i < m; i++) {
            f[i][0] = queries[i][0];
            f[i][1] = queries[i][1];
            f[i][2] = queries[i][2];
            f[i][3] = i;
        }

        Arrays.sort(edgeList, Comparator.comparingInt(o -> o[2]));
        Arrays.sort(f, Comparator.comparingInt(o -> o[2]));

        for(int i = 0, j = 0; i <  m; i++) {
            while(j < k && edgeList[j][2] < f[i][2]) {
                un(edgeList[j][0], edgeList[j][1]);
                j++;
            }
            ans[f[i][3]] = find(f[i][0]) == find(f[i][1]);
        }

        return ans;
    }
}