LeetCode2019第 168 场周赛

发表于 更新于 分类于 阅读次数： Disqus：

5291. 统计位数为偶数的数字

题目描述

给你一个整数数组 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

题解1

我用to_string将数字先转成字符串，然后判断字符串的长度是否为偶数。

代码1

1
2
3
4
5
6
7
8
9
10
11
12
13
//to_string
class Solution {
public:
    int findNumbers(vector<int>& nums) {
        int cnt = 0;
        for(auto num:nums){
            if(to_string(num).size()% 2 == 0){//判断num对应的字符串的长度是否为偶数
                ++cnt;
            }
        }
        return cnt;
    }
};

5292. 划分数组为连续数字的集合

题目描述

给你一个整数数组 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

题解1

先用map统计每个数字出现的次数。然而遍历map(key已自动从小到大排列)，当发现某个数的个数cnt不为0，则连续k个数字(含当前数)都减去cnt，如果出现负数，则表示不能划分。 最后再遍历一次map,检查是否每一个数的个数都为0。（这步其实不需要）

代码1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
class Solution {
public:
    bool isPossibleDivide(vector<int>& nums, int k) {
        int len = nums.size();
        map<int, int>myMap;
        if(len % k != 0){//数字的个数不能将每组都划分成k个
            return false;
        }
        for(auto num:nums){//统计每个数字出现的次数
            if(myMap.find(num) == myMap.end()){
                myMap[num] = 1;
            }
            else{
                ++myMap[num];
            }
        }
        bool flag = true;
        for(auto iter = myMap.begin(); iter != myMap.end(); ++iter){//遍历map
            if(iter->second != 0){
                int num = iter->first;
                int cnt = myMap[num];
                myMap[num] = 0;
                for(int i = num + 1; i < num + k; ++i){//分组，一个数不为0，连续k个数字一组，个数不足表示不能划分
                    if(myMap[i] < cnt){
                        flag = false;
                        break;
                    }
                    else{
                        myMap[i] = myMap[i] - cnt;
                    }
                }
            }
        }
        /*这步其实不需要
        for(auto iter = myMap.begin(); iter != myMap.end(); ++iter){
            if(iter->second != 0){//表示有多余数字
                flag = false;
                break;
            }
        }
        */
        return flag;
    }
};

5293. 子串的最大出现次数

题目描述

给你一个字符串 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 只包含小写英文字母。

题解1

代码1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Solution {
public:
    int maxFreq(string s, int maxLetters, int minSize, int maxSize) {
        int len = s.size();
        int maxLen = 0;
        map<string, int>res;
        bool mark[26];
        for(int i = 0; i < len; ++i){
            if(i + minSize - 1 < len){
                memset(mark, false, sizeof(mark));
                int cnt = 0;
                for(int j = i; j < i + minSize; ++j){
                    if(!mark[s[j] - 'a']){
                        ++cnt;
                        mark[s[j] - 'a'] = true;
                    }
                }
                if(cnt <= maxLetters){
                    res[s.substr(i, minSize)]++;
                }
            }
        }
        for(auto &iter:res){
            maxLen = max(maxLen, iter.second);
        }
        return maxLen;
    }
};

5294. 你能从盒子里获得的最大糖果数

题目描述

给你 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

题解1

这个题很好理解，第一反应是个递归，写完才发现爆栈了。然后又把程序改成了循环判断boxs(拥有的盒子)是否存在能够打开的，打开后，如果有新钥匙，则将对应盒子的状态修改为1，有新盒子，则添加到boxs中。如此下去，直到boxs中剩下的盒子都已打开或者不存在能够打开的盒子为止。

代码1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
int sum = 0;
set<int>boxs;
bool mark[1005];
class Solution {
public:
    int maxCandies(vector<int>& status, vector<int>& candies, vector<vector<int>>& keys, vector<vector<int>>& contains, vector<int>& init) {
        sum = 0;
        boxs.clear();//拥有的盒子
        memset(mark, false, sizeof(mark));
        for(int i = 0; i < init.size(); ++i){
            boxs.insert(init[i]);
        }
        while(boxs.size() != 0){//一直循环
            bool flag = true;
            for(auto iter = boxs.begin(); iter != boxs.end(); ++iter){
                int idx = *iter;
                if(!mark[idx] && status[idx]){
                    flag = false;
                    mark[idx] = true;
                    sum += candies[idx];
                    for(int j = 0; j < keys[idx].size(); ++j){//更新钥匙，也就是使对应盒子的status值为1。
                        status[keys[idx][j]] = 1; 
                    }
                    for(int j = 0; j < contains[idx].size(); ++j){//更新拥有的盒子
                        boxs.insert(contains[idx][j]);
                    }
                }
            }
            if(flag) {//flag为true表示盒子都已打开或不存在能够打开的盒子
                break;
            }
        }
        return sum;
    }
};