LeetCode Weekly Contest 168

最新推荐文章于 2023-04-21 15:58:13 发布

da_kao_la

最新推荐文章于 2023-04-21 15:58:13 发布

阅读量214

点赞数

分类专栏： LeetCode 文章标签： LeetCode 周赛 Java

本文链接：https://blog.csdn.net/da_kao_la/article/details/103652005

版权

LeetCode 专栏收录该内容

371 篇文章 0 订阅

订阅专栏

本周周赛没有涉及比较复杂的算法，只要理解题意，基本都能做出来

5291. 统计位数为偶数的数字显示英文描述

题目难度Easy
给你一个整数数组 nums，请你返回其中位数为偶数的数字的个数。

示例 1：

输入：nums = [12,345,2,6,7896]
输出：2
解释：
12 是 2 位数字（位数为偶数）
345 是 3 位数字（位数为奇数）
2 是 1 位数字（位数为奇数）
6 是 1 位数字位数为奇数）
7896 是 4 位数字（位数为偶数）
因此只有 12 和 7896 是位数为偶数的数字
示例 2：

输入：nums = [555,901,482,1771]
输出：1
解释：
只有 1771 是位数为偶数的数字。

提示：

1 <= nums.length <= 500
1 <= nums[i] <= 10^5

代码

class Solution {
    public int findNumbers(int[] nums) {
        int digits = 0, evens = 0;
        for (int num: nums) {
            digits = 0;
            while (num > 0) {
                ++digits;
                num /= 10;
            }
            if (digits % 2 == 0) {
                ++evens;
            }
        }
        return evens;
    }
}

5292. 划分数组为连续数字的集合显示英文描述

题目难度Medium
给你一个整数数组 nums 和一个正整数 k，请你判断是否可以把这个数组划分成一些由 k 个连续数字组成的集合。
如果可以，请返回 True；否则，返回 False。

示例 1：

输入：nums = [1,2,3,3,4,4,5,6], k = 4
输出：true
解释：数组可以分成 [1,2,3,4] 和 [3,4,5,6]。
示例 2：

输入：nums = [3,2,1,2,3,4,3,4,5,9,10,11], k = 3
输出：true
解释：数组可以分成 [1,2,3] , [2,3,4] , [3,4,5] 和 [9,10,11]。
示例 3：

输入：nums = [3,3,2,2,1,1], k = 3
输出：true
示例 4：

输入：nums = [1,2,3,4], k = 3
输出：false
解释：数组不能分成几个大小为 3 的子数组。

提示：

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
1 <= k <= nums.length

思路

维护两个数据结构：有序数组和哈希表，每次摘取有序数组在哈希表中最小的元素，从该元素开始遍历连续的k个正整数从哈希表里删除

代码

class Solution {
    public boolean isPossibleDivide(int[] nums, int k) {
        if (k == 1) {
            return true;
        }
        if (nums.length % k != 0) {
            return false;
        }
        Arrays.sort(nums);
        HashMap<Integer, Integer> cnts = new HashMap<>();
        for (int num: nums) {
            if (!cnts.containsKey(num)) {
                cnts.put(num, 1);
            } else {
                cnts.put(num, cnts.get(num) + 1);
            }
        }
        for (int num: nums) {
            if (cnts.get(num) > 0) {
                for (int i=0; i<k; ++i) {
                    if (cnts.containsKey(num + i) && cnts.get(num + i) > 0) {
                        cnts.put(num + i, cnts.get(num + i) - 1);
                    } else {
                        return false;
                    }
                }
            }
        }
        return true;
    }
}

5293. 子串的最大出现次数显示英文描述

题目难度Medium
给你一个字符串 s ，请你返回满足以下条件且出现次数最大的任意子串的出现次数：

子串中不同字母的数目必须小于等于 maxLetters 。
子串的长度必须大于等于 minSize 且小于等于 maxSize 。

示例 1：

输入：s = “aababcaab”, maxLetters = 2, minSize = 3, maxSize = 4
输出：2
解释：子串 “aab” 在原字符串中出现了 2 次。
它满足所有的要求：2 个不同的字母，长度为 3 （在 minSize 和 maxSize 范围内）。
示例 2：

输入：s = “aaaa”, maxLetters = 1, minSize = 3, maxSize = 3
输出：2
解释：子串 “aaa” 在原字符串中出现了 2 次，且它们有重叠部分。
示例 3：

输入：s = “aabcabcab”, maxLetters = 2, minSize = 2, maxSize = 3
输出：3
示例 4：

输入：s = “abcde”, maxLetters = 2, minSize = 3, maxSize = 3
输出：0

提示：

1 <= s.length <= 10^5
1 <= maxLetters <= 26
1 <= minSize <= maxSize <= min(26, s.length)
s 只包含小写英文字母。

思路

遍历一下滑窗长度[minSize, maxSize]，对于每个长度的滑窗遍历一下所有可能的位置，判断滑窗内的子串是否满足要求即可。用26位数组记录滑窗内各个字符出现次数，用哈希表记录固定长度的滑窗在所有可能的位置取到的子串的重复出现次数。记字符串总长度为n, 该算法的时间复杂度为O(n).

代码

class Solution {
    private int getCharNum(int[] cntChar) {
        int cnt = 0;
        for (int num: cntChar) {
            if (num > 0) {
                ++cnt;
            }
        }
        return cnt;
    }
    
    public int maxFreq(String s, int maxLetters, int minSize, int maxSize) {
        int siz = minSize, maxAccur = 0, i = 0, n = s.length();
        HashMap<String, Integer> cntStr = new HashMap<>();
        int[] cntChar = new int[26];
        for (siz=minSize; siz<=maxSize; ++siz) {
            Arrays.fill(cntChar, 0);
            cntStr.clear();
            for (i=0; i<siz; ++i) {
                ++cntChar[s.charAt(i) - 'a'];
            }
            if (getCharNum(cntChar) <= maxLetters) {
                cntStr.put(s.substring(0, siz), 1);
            }
            for (i=1; i<=n-siz; ++i) {
                --cntChar[s.charAt(i-1) - 'a'];
                ++cntChar[s.charAt(i+siz-1) - 'a'];
                if (getCharNum(cntChar) <= maxLetters) {
                    String tmp = s.substring(i, i+siz);
                    if (cntStr.containsKey(tmp)) {
                        cntStr.put(tmp, cntStr.get(tmp) + 1);
                    } else {
                        cntStr.put(tmp, 1);
                    }
                }
            }
            if (!cntStr.isEmpty()) {
                maxAccur = Math.max(maxAccur, Collections.max(cntStr.values()));
            }
        }
        return maxAccur;
    }
}

5294. 你能从盒子里获得的最大糖果数显示英文描述

题目难度Hard
给你 n 个盒子，每个盒子的格式为 [status, candies, keys, containedBoxes] ，其中：

状态字 status[i]：整数，如果 box[i] 是开的，那么是 1 ，否则是 0 。
糖果数 candies[i]: 整数，表示 box[i] 中糖果的数目。
钥匙 keys[i]：数组，表示你打开 box[i] 后，可以得到一些盒子的钥匙，每个元素分别为该钥匙对应盒子的下标。
内含的盒子 containedBoxes[i]：整数，表示放在 box[i] 里的盒子所对应的下标。
给你一个 initialBoxes 数组，表示你现在得到的盒子，你可以获得里面的糖果，也可以用盒子里的钥匙打开新的盒子，还可以继续探索从这个盒子里找到的其他盒子。

请你按照上述规则，返回可以获得糖果的最大数目。

示例 1：

输入：status = [1,0,1,0], candies = [7,5,4,100], keys = [[],[],[1],[]], containedBoxes = [[1,2],[3],[],[]], initialBoxes = [0]
输出：16
解释：
一开始你有盒子 0 。你将获得它里面的 7 个糖果和盒子 1 和 2。
盒子 1 目前状态是关闭的，而且你还没有对应它的钥匙。所以你将会打开盒子 2 ，并得到里面的 4 个糖果和盒子 1 的钥匙。
在盒子 1 中，你会获得 5 个糖果和盒子 3 ，但是你没法获得盒子 3 的钥匙所以盒子 3 会保持关闭状态。
你总共可以获得的糖果数目 = 7 + 4 + 5 = 16 个。
示例 2：

输入：status = [1,0,0,0,0,0], candies = [1,1,1,1,1,1], keys = [[1,2,3,4,5],[],[],[],[],[]], containedBoxes = [[1,2,3,4,5],[],[],[],[],[]], initialBoxes = [0]
输出：6
解释：
你一开始拥有盒子 0 。打开它你可以找到盒子 1,2,3,4,5 和它们对应的钥匙。
打开这些盒子，你将获得所有盒子的糖果，所以总糖果数为 6 个。
示例 3：

输入：status = [1,1,1], candies = [100,1,100], keys = [[],[0,2],[]], containedBoxes = [[],[],[]], initialBoxes = [1]
输出：1
示例 4：

输入：status = [1], candies = [100], keys = [[]], containedBoxes = [[]], initialBoxes = []
输出：0
示例 5：

输入：status = [1,1,1], candies = [2,3,2], keys = [[],[],[]], containedBoxes = [[],[],[]], initialBoxes = [2,1,0]
输出：7

提示：

1 <= status.length <= 1000
status.length == candies.length == keys.length == containedBoxes.length == n
status[i] 要么是 0 要么是 1 。
1 <= candies[i] <= 1000
0 <= keys[i].length <= status.length
0 <= keys[i][j] < status.length
keys[i] 中的值都是互不相同的。
0 <= containedBoxes[i].length <= status.length
0 <= containedBoxes[i][j] < status.length
containedBoxes[i] 中的值都是互不相同的。
每个盒子最多被一个盒子包含。
0 <= initialBoxes.length <= status.length
0 <= initialBoxes[i] < status.length

思路

深搜。注意用三个数组vis, getKeys, getBoxes记录当前哪些盒子中的糖果被取走了，当前有哪些盒子的钥匙，当前有哪些盒子。

代码

class Solution {
    private int dfs(int i, int[] status, int[] candies, int[][] keys, int[][] containedBoxes, boolean[] vis, boolean[] getKeys, boolean[] getBoxes) {
        int ans = 0, j = 0, n = status.length;
        if (status[i] == 1 || getKeys[i]) {
            vis[i] = true;
            ans += candies[i];
            for (int key: keys[i]) {
                getKeys[key] = true;
            }
            for (int box: containedBoxes[i]) {
                getBoxes[box] = true;
            }
            for (j=0; j<n; ++j) {
                if (!vis[j] && getBoxes[j]) {
                    ans += dfs(j, status, candies, keys, containedBoxes, vis, getKeys, getBoxes);
                }
            }
        }
        return ans;
    }
    
    public int maxCandies(int[] status, int[] candies, int[][] keys, int[][] containedBoxes, int[] initialBoxes) {
        int n = status.length, ans = 0;
        boolean[] vis = new boolean[n], getKeys = new boolean[n], getBoxes = new boolean[n]; 
        for (int box: initialBoxes) {
            getBoxes[box] = true;
        }
        for (int boxNum: initialBoxes) {
            if (!vis[boxNum]) {
                ans += dfs(boxNum, status, candies, keys, containedBoxes, vis, getKeys, getBoxes);
            }
        }
        return ans;
    }
}