[力扣刷题总结](每日一题篇)

---

372. 超级次方

你的任务是计算 ab 对 1337 取模，a 是一个正整数，b 是一个非常大的正整数且会以数组形式给出。

示例 1：
输入：a = 2, b = [3]
输出：8

示例 2：
输入：a = 2, b = [1,0]
输出：1024

示例 3：
输入：a = 1, b = [4,3,3,8,5,2]
输出：1

示例 4：
输入：a = 2147483647, b = [2,0,0]
输出：1198

提示：
1 <= a <= 231 - 1
1 <= b.length <= 2000
0 <= b[i] <= 9
b 不含前导 0

解法1：递归+快速幂

思路：

代码：

class Solution {
public:
    int mod = 1337;
    //递归实现快速幂
    long long myPow(int a, int b){
        if(b == 0) return 1;
        //b为奇数
        else if (b&1) return myPow(a,b-1)*a%mod;
        else{
            long long half = myPow(a,b/2)%mod;
            return half*half%mod;
        }
    }
    int superPow(int a, vector<int>& b) {
        if(b.size() == 0) return 1;
        int n = b.size()-1;
        int curNum = b[n];
        b.pop_back();

        return myPow(a,curNum) * myPow(superPow(a,b),10) %mod;
    }
};

复杂度分析：

时间复杂度：假设 b 数组所代表的数字为 K，使用快速幂的复杂度为 O(logK)，或者说是 O(n∗log10)，其中 n 为数组 b 的长度，数字 10 所代表的含义是计算一个次方为 10以内的值；而不使用快速幂的复杂度为O(n∗10)

空间复杂度：忽略递归带来的额外空间开销，复杂度为 O(1)

相似题目：50. Pow(x, n)

力扣链接
实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn ）。

示例 1：

输入：x = 2.00000, n = 10
输出：1024.00000
示例 2：

输入：x = 2.10000, n = 3
输出：9.26100
示例 3：

输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25

提示：

-100.0 < x < 100.0
-231 <= n <= 231-1
-104 <= xn <= 104

解法1：快速幂+递归

思路：

代码：

class Solution {
public:
    double fastPow(double x, long long n){
        if(n == 0) return 1;

        if(n % 2 == 1){
            return fastPow(x,n-1)*x;
        }
        double half = myPow(x, n/2);
        return half*half;
    }
    double myPow(double x, int n) {
        long long N = n;
        return N >= 0 ? fastPow(x,N) : 1.0 / fastPow(x,-N);
    }
};

解法2：快速幂+迭代

代码：

class Solution {
public:
    double fastPow(double x, long long n){
        double res = 1.0;
        double x_ = x;
        while(n > 0){
            if(n % 2 == 1){
                res *= x_;
            }
            x_ *= x_;
            n /= 2;
        }
        return res;
    }
    double myPow(double x, int n) {
        long long N = n;
        return N > 0? fastPow(x,N) : 1.0 / fastPow(x,-N);
    }
};

注意理解
if(n % 2 == 1){res *= x_;}在两种情况下会执行，一种是当N一开始就为奇数，如5时，接下来就会把奇数编程偶数；另一种情况是最后N为1时，由此得到票结果。

748. 最短补全词

力扣链接
给你一个字符串 licensePlate 和一个字符串数组 words ，请你找出并返回 words 中的 最短补全词 。
补全词 是一个包含 licensePlate 中所有的字母的单词。在所有补全词中，最短的那个就是 最短补全词 。
在匹配 licensePlate 中的字母时：

忽略 licensePlate 中的 数字和空格 。
不区分大小写。
如果某个字母在 licensePlate 中出现不止一次，那么该字母在补全词中的出现次数应当一致或者更多。

例如：licensePlate = “aBc 12c”，那么它的补全词应当包含字母 ‘a’、‘b’ （忽略大写）和两个 ‘c’ 。可能的 补全词 有 “abccdef”、“caaacab” 以及 “cbca” 。

请你找出并返回 words 中的 最短补全词 。题目数据保证一定存在一个最短补全词。当有多个单词都符合最短补全词的匹配条件时取 words 中 最靠前的 那个。

示例 1：
输入：licensePlate = “1s3 PSt”, words = [“step”, “steps”, “stripe”, “stepple”]
输出：“steps”
解释：最短补全词应该包括 “s”、“p”、“s”（忽略大小写） 以及 “t”。
“step” 包含 “t”、“p”，但只包含一个 “s”，所以它不符合条件。
“steps” 包含 “t”、“p” 和两个 “s”。
“stripe” 缺一个 “s”。
“stepple” 缺一个 “s”。
因此，“steps” 是唯一一个包含所有字母的单词，也是本例的答案。

示例 2：
输入：licensePlate = “1s3 456”, words = [“looks”, “pest”, “stew”, “show”]
输出：“pest”
解释：licensePlate 只包含字母 “s” 。所有的单词都包含字母 “s” ，其中 “pest”、“stew”、和 “show” 三者最短。答案是 “pest” ，因为它是三个单词中在 words 里最靠前的那个。

示例 3：
输入：licensePlate = “Ah71752”, words = [“suggest”,“letter”,“of”,“husband”,“easy”,“education”,“drug”,“prevent”,“writer”,“old”]
输出：“husband”

示例 4：
输入：licensePlate = “OgEu755”, words = [“enough”,“these”,“play”,“wide”,“wonder”,“box”,“arrive”,“money”,“tax”,“thus”]
输出：“enough”

示例 5：
输入：licensePlate = “iMSlpe4”, words = [“claim”,“consumer”,“student”,“camera”,“public”,“never”,“wonder”,“simple”,“thought”,“use”]
输出：“simple”

提示：
1 <= licensePlate.length <= 7
licensePlate 由数字、大小写字母或空格 ’ ’ 组成
1 <= words.length <= 1000
1 <= words[i].length <= 15
words[i] 由小写英文字母组成

解法1：统计字符出现次数

代码：

class Solution {
public:
    string shortestCompletingWord(string licensePlate, vector<string>& words) {
        vector<int> cnt(26,0); 
        for(char c:licensePlate){
            if(c>='a' && c <='z'){
                cnt[c-'a']++;
            }
            else if (c>='A' && c <='Z'){
                cnt[c-'A']++;
            }
        }
        string res;
        int idx = -1;

        for(int i = 0;i<words.size();i++){
            vector<int> cntS(26,0);
            for (char c:words[i]){
                cntS[c-'a']++;
            }
            bool ok = true;
            for (int j = 0; j < 26; ++j) {
                if (cntS[j] < cnt[j]) {
                    ok = false;
                    break;
                }
            }
            if (ok && (idx < 0 || words[i].length() < words[idx].length())) {
                idx = i;
            }

        }

        return words[idx];
    }

};

复杂度分析：

911. 在线选举

力扣链接

给你两个整数数组 persons 和 times 。在选举中，第 i 张票是在时刻为 times[i] 时投给候选人 persons[i] 的。

对于发生在时刻 t 的每个查询，需要找出在 t 时刻在选举中领先的候选人的编号。

在 t 时刻投出的选票也将被计入我们的查询之中。在平局的情况下，最近获得投票的候选人将会获胜。

实现 TopVotedCandidate 类：

TopVotedCandidate(int[] persons, int[] times) 使用 persons 和 times 数组初始化对象。
int q(int t) 根据前面描述的规则，返回在时刻 t 在选举中领先的候选人的编号。

示例：
输入：
[“TopVotedCandidate”, “q”, “q”, “q”, “q”, “q”, “q”]
[[[0, 1, 1, 0, 0, 1, 0], [0, 5, 10, 15, 20, 25, 30]], [3], [12], [25], [15], [24], [8]]
输出：
[null, 0, 1, 1, 0, 0, 1]

解释：
TopVotedCandidate topVotedCandidate = new TopVotedCandidate([0, 1, 1, 0, 0, 1, 0], [0, 5, 10, 15, 20, 25, 30]);
topVotedCandidate.q(3); // 返回 0 ，在时刻 3 ，票数分布为 [0] ，编号为 0 的候选人领先。
topVotedCandidate.q(12); // 返回 1 ，在时刻 12 ，票数分布为 [0,1,1] ，编号为 1 的候选人领先。
topVotedCandidate.q(25); // 返回 1 ，在时刻 25 ，票数分布为 [0,1,1,0,0,1] ，编号为 1 的候选人领先。（在平局的情况下，1 是最近获得投票的候选人）。
topVotedCandidate.q(15); // 返回 0
topVotedCandidate.q(24); // 返回 0
topVotedCandidate.q(8); // 返回 1

提示：
1 <= persons.length <= 5000
times.length == persons.length
0 <= persons[i] < persons.length
0 <= times[i] <= 109
times 是一个严格递增的有序数组
times[0] <= t <= 109
每个测试用例最多调用 104 次 q

解法1：预处理+二分查找

思路：

（1）票选是在离散时间上发生的，每次更新只会对票数+1。 基于此，我们首先要对投票按照时间排序，然后按照时间顺序遍历，找出每个时间点票数最高的人。

（2）计票，我们需要建立一个hashmap，存储每个候选人的票数。
在遍历过程也就是对应到现实中的唱票过程里，我们用votes和top记录票数最高的同学和对应的得票，发先当前得票候选者如果票数更高时，我们就更新top和votes。这样我们就可以得到每时每刻的最高票的候选人。

（3）但由于时间是不连续的，最后给出任意一个时间点查询时，我们还需要进行一次二分搜索。
找到到当前时间点最近的一次投票时间点，那个时候对应的最领先的候选人就是答案。

代码：

class TopVotedCandidate {
private:
    vector<int> tops;
    vector<int> times;
public:
    TopVotedCandidate(vector<int>& persons, vector<int>& times) {
        unordered_map<int,int> counts;//候选人->票数
        counts[-1] = -1;
        int top = -1;
        for(auto& p:persons){
            counts[p]++;
            if(counts[p] >= counts[top]) top = p;
            tops.push_back(top);
        }
        this->times = times;
    }
    
    int q(int t) {
        int left = 0, right = times.size()-1;
        while(left<right){
            int mid = left + (right-left+1) / 2;
            if(times[mid]<=t){
                left = mid;
            }else{
                right = mid-1;
            }
        }
        return tops[left];
    }
};

/**
 * Your TopVotedCandidate object will be instantiated and called as such:
 * TopVotedCandidate* obj = new TopVotedCandidate(persons, times);
 * int param_1 = obj->q(t);
 */

复杂度分析：

时间复杂度：预处理的时间复杂度为 O(N)，其中 N 为persons 的长度。单次查询的时间复杂度为 O(logN)。

空间复杂度：O(N)。

1610. 可见点的最大数目

力扣链接
给你一个点数组 points 和一个表示角度的整数 angle ，你的位置是 location ，其中 location = [posx, posy] 且 points[i] = [xi, yi] 都表示 X-Y 平面上的整数坐标。

最开始，你面向东方进行观测。你 不能 进行移动改变位置，但可以通过 自转 调整观测角度。换句话说，posx 和 posy 不能改变。你的视野范围的角度用 angle 表示， 这决定了你观测任意方向时可以多宽。设 d 为你逆时针自转旋转的度数，那么你的视野就是角度范围 [d - angle/2, d + angle/2] 所指示的那片区域。

对于每个点，如果由该点、你的位置以及从你的位置直接向东的方向形成的角度 位于你的视野中 ，那么你就可以看到它。

同一个坐标上可以有多个点。你所在的位置也可能存在一些点，但不管你的怎么旋转，总是可以看到这些点。同时，点不会阻碍你看到其他点。

返回你能看到的点的最大数目。

示例 1：

输入：points = [[2,1],[2,2],[3,3]], angle = 90, location = [1,1]
输出：3
解释：阴影区域代表你的视野。在你的视野中，所有的点都清晰可见，尽管 [2,2] 和 [3,3]在同一条直线上，你仍然可以看到 [3,3] 。

示例 2：
输入：points = [[2,1],[2,2],[3,4],[1,1]], angle = 90, location = [1,1]
输出：4
解释：在你的视野中，所有的点都清晰可见，包括你所在位置的那个点。

示例 3：

输入：points = [[1,0],[2,1]], angle = 13, location = [1,1]
输出：1
解释：如图所示，你只能看到两点之一。

提示：

1 <= points.length <= 105
points[i].length == 2
location.length == 2
0 <= angle < 360
0 <= posx, posy, xi, yi <= 100

解法1：极角几何+双指针

思路：

代码：

class Solution {
public:
    int visiblePoints(vector<vector<int>>& points, int angle, vector<int>& location) {
        int x = location[0], y = location[1];
        vector<double> list;//极角
        int cnt = 0;
        double pi = M_PI, t = angle*pi/180;
        for(auto& point:points){
            int a = point[0], b = point[1];
            //所有与原点重合的点都可见，特殊处理
             if (a == x && b == y ) {
                cnt++;
                continue;
             }
            //atan2范围[-π,π]，加一个π是为了让角度范围变成[0,2π]
            list.push_back(atan2(b-y,a-x)+pi);
        }
        sort(list.begin(),list.end());
        int n = list.size(), maxVal = 0;
        //将所有点向[2π,4π]拓宽，使得一四象限范围内的点可以被包含
        for(int i = 0;i<n;i++) list.push_back(2*pi+list[i]);
        //滑动窗口+双指针求范围内点最多的区域
        for(int i = 0,j = 0;j<2*n;j++){
            while(i<j && list[j]-list[i]>t) i++;
            maxVal = max(maxVal,j-i+1);
        }
        return maxVal+cnt;
    }
};

1518. 换酒问题

力扣链接
小区便利店正在促销，用 numExchange 个空酒瓶可以兑换一瓶新酒。你购入了 numBottles 瓶酒。

如果喝掉了酒瓶中的酒，那么酒瓶就会变成空的。

请你计算 最多 能喝到多少瓶酒。

示例 1：

输入：numBottles = 9, numExchange = 3
输出：13
解释：你可以用 3 个空酒瓶兑换 1 瓶酒。
所以最多能喝到 9 + 3 + 1 = 13 瓶酒。

示例 2：

输入：numBottles = 15, numExchange = 4
输出：19
解释：你可以用 4 个空酒瓶兑换 1 瓶酒。
所以最多能喝到 15 + 3 + 1 = 19 瓶酒。

示例 3：

输入：numBottles = 5, numExchange = 5
输出：6

示例 4：

输入：numBottles = 2, numExchange = 3
输出：2

提示：

1 <= numBottles <= 100
2 <= numExchange <= 100

解法1：模拟

class Solution {
public:
    int numWaterBottles(int numBottles, int numExchange) {
        int count = numBottles;
        while(numBottles >= numExchange){
            int newB = numBottles/numExchange;//新兑换的酒
            int restB = numBottles%numExchange;//剩余的未兑换的空瓶子
            count += newB;
            numBottles = newB + restB;//当前的空瓶子
        }
        return count;
    }
};

686. 重复叠加字符串匹配

力扣链接
给定两个字符串 a 和 b，寻找重复叠加字符串 a 的最小次数，使得字符串 b 成为叠加后的字符串 a 的子串，如果不存在则返回 -1。

注意：字符串 “abc” 重复叠加 0 次是 “”，重复叠加 1 次是 “abc”，重复叠加 2 次是 “abcabc”。

示例 1：

输入：a = “abcd”, b = “cdabcdab”
输出：3
解释：a 重复叠加三遍后为 “abcdabcdabcd”, 此时 b 是其子串。

示例 2：

输入：a = “a”, b = “aa”
输出：2

示例 3：

输入：a = “a”, b = “a”
输出：1

示例 4：

输入：a = “abc”, b = “wxyz”
输出：-1

提示：

1 <= a.length <= 104
1 <= b.length <= 104
a 和 b 由小写英文字母组成

解法1：字符串匹配

思路：
（1）STL 中 string 容器有一个 find 函数，是解决子串问题的神器。如果确实不想学 KMP 算法的话，可以自行去了解一下这个函数。

string 中 find() 返回值是子串在母串中的位置（下标记录），如果没有找到，那么会返回一个特别的标记 npos 。（返回值可以看成是一个 int 型的数）

（2）思路分析： 这道题看起来很简单，但是如果没有找到切入点还是比较难以下手的。
首先我们应该知道，如果A的长度大于等于B的长度，这时B是A的重复叠加字符串只有两种情况，
第一种就是本身B就是A的子串（比如A = “abcdefg”, B = “bcd”），
第二种就是B是两个A的子串(A = “abcdefg”, B = “efgab”, 2 * A == “abcdefgabcdefg”)。

如果A的长度小于B的长度，这时B是A的重复子串，则A的重复次数不超过 Bsize / Asize + 2。
其中“Bsize / Asize”代表的B串中间A重复的次数，“+2”代表的首尾各添加一个A串。

代码：

class Solution {
public:
    int repeatedStringMatch(string a, string b) {
        int aLen = a.size();
        int bLen = b.size();
        if(aLen >= bLen){
            string aDouble = a + a;
            if(a.find(b)!=a.npos){
                return 1;
            }else if(aDouble.find(b) != aDouble.npos){
                return 2;
            }else return -1;
        }

        int count = 1;
        string aTemp = a;
        while(count <= bLen/aLen + 2){
            if(aTemp.find(b) != aTemp.npos){
                return count;
            }
            aTemp += a;
            count++;
        }
        return -1;
    }
};

简化：

class Solution {
public:
    int repeatedStringMatch(string a, string b) {
        int aLen = a.size();
        int bLen = b.size();
        
        int count = 1;
        string aTemp = a;
        while(count <= bLen/aLen + 2){
            if(aTemp.find(b) != aTemp.npos){
                return count;
            }
            aTemp += a;
            count++;
        }
        return -1;
    }
};

507. 完美数

力扣链接
对于一个 正整数，如果它和除了它自身以外的所有 正因子 之和相等，我们称它为 「完美数」。

给定一个 整数 n， 如果是完美数，返回 true，否则返回 false

示例 1：

输入：num = 28
输出：true
解释：28 = 1 + 2 + 4 + 7 + 14
1, 2, 4, 7, 和 14 是 28 的所有正因子。

示例 2：

输入：num = 6
输出：true

示例 3：

输入：num = 496
输出：true

示例 4：

输入：num = 8128
输出：true

示例 5：

输入：num = 2
输出：false

提示：

1 <= num <= 108

解法1：枚举

思路：

代码：

class Solution {
public:
    bool checkPerfectNumber(int num) {
        if(num == 1) return false;
        int numA = 1;
        for(int i = 2;i*i<=num;i++){
            if(num % i == 0){
                numA += i;
                if(i*i != num) numA += num/i;
            } 
        }
        return numA == num;
    }
};

390. 消除游戏

力扣链接
列表 arr 由在范围 [1, n] 中的所有整数组成，并按严格递增排序。请你对 arr 应用下述算法：

从左到右，删除第一个数字，然后每隔一个数字删除一个，直到到达列表末尾。
重复上面的步骤，但这次是从右到左。也就是，删除最右侧的数字，然后剩下的数字每隔一个删除一个。
不断重复这两步，从左到右和从右到左交替进行，直到只剩下一个数字。
给你整数 n ，返回 arr 最后剩下的数字。

示例 1：

输入：n = 9
输出：6
解释：
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
arr = [2, 4, 6, 8]
arr = [2, 6]
arr = [6]
示例 2：

输入：n = 1
输出：1

提示：

1 <= n <= 109

解法1：等差数列模拟

思路：

代码：

class Solution {
public:
    int lastRemaining(int n) {
        int a1 = 1, an = n;
        int k = 0, cnt = n, step = 1;

        while(cnt > 1){
            if(k % 2 == 0){//正向
                a1 = a1 + step;
                an = cnt % 2 == 0 ? an : an - step;
            }else{//反向
                a1 = cnt % 2 == 0 ? a1 : a1 + step;
                an = an - step;
            }
            k++;
            //个数减半
            cnt = cnt >> 1;
            //公差整半
            step = step << 1;
        }
        return a1;
    }
};

复杂度分析：

时间复杂度：O(logn)，其中 n 为初始整数列表的元素数目。每次删除都会将元素数目减半，所以时间复杂度为 O(logn)。

空间复杂度：O(1)。只需要使用常数的额外空间。

1576. 替换所有的问号

力扣链接
给你一个仅包含小写英文字母和 ‘?’ 字符的字符串 s，请你将所有的 ‘?’ 转换为若干小写字母，使最终的字符串不包含任何 连续重复 的字符。

注意：你 不能 修改非 ‘?’ 字符。

题目测试用例保证 除 ‘?’ 字符 之外，不存在连续重复的字符。

在完成所有转换（可能无需转换）后返回最终的字符串。如果有多个解决方案，请返回其中任何一个。可以证明，在给定的约束条件下，答案总是存在的。

示例 1：

输入：s = “?zs”
输出：“azs”
解释：该示例共有 25 种解决方案，从 “azs” 到 “yzs” 都是符合题目要求的。只有 “z” 是无效的修改，因为字符串 “zzs” 中有连续重复的两个 ‘z’ 。
示例 2：

输入：s = “ubv?w”
输出：“ubvaw”
解释：该示例共有 24 种解决方案，只有替换成 “v” 和 “w” 不符合题目要求。因为 “ubvvw” 和 “ubvww” 都包含连续重复的字符。
示例 3：

输入：s = “j?qg??b”
输出：“jaqgacb”
示例 4：

输入：s = “??yw?ipkj?”
输出：“acywaipkja”

提示：

1 <= s.length <= 100

s 仅包含小写英文字母和 ‘?’ 字符

解法1：字符串+模拟

思路：

代码：

class Solution {
public:
    string modifyString(string s) {
        if(s[0] == '?') s[0] = 'a';
        for(int i = 1;i<s.size();i++) {
            if(s[i] == '?') s[i] = (s[i-1] - 'a' + 1) % 26 + 'a';
            else if(s[i] == s[i-1]) {
                s[i-1] = (s[i-1]-'a'+1)%26 +'a';
            }
        }
        return s;
    }
};

1629. 按键持续时间最长的键

力扣链接
LeetCode 设计了一款新式键盘，正在测试其可用性。测试人员将会点击一系列键（总计 n 个），每次一个。

给你一个长度为 n 的字符串 keysPressed ，其中 keysPressed[i] 表示测试序列中第 i 个被按下的键。releaseTimes 是一个升序排列的列表，其中 releaseTimes[i] 表示松开第 i 个键的时间。字符串和数组的 下标都从 0 开始 。第 0 个键在时间为 0 时被按下，接下来每个键都 恰好 在前一个键松开时被按下。

测试人员想要找出按键 持续时间最长 的键。第 i 次按键的持续时间为 releaseTimes[i] - releaseTimes[i - 1] ，第 0 次按键的持续时间为 releaseTimes[0] 。

注意，测试期间，同一个键可以在不同时刻被多次按下，而每次的持续时间都可能不同。

请返回按键 持续时间最长 的键，如果有多个这样的键，则返回 按字母顺序排列最大 的那个键。

示例 1：

输入：releaseTimes = [9,29,49,50], keysPressed = “cbcd”
输出：“c”
解释：按键顺序和持续时间如下：
按下 ‘c’ ，持续时间 9（时间 0 按下，时间 9 松开）
按下 ‘b’ ，持续时间 29 - 9 = 20（松开上一个键的时间 9 按下，时间 29 松开）
按下 ‘c’ ，持续时间 49 - 29 = 20（松开上一个键的时间 29 按下，时间 49 松开）
按下 ‘d’ ，持续时间 50 - 49 = 1（松开上一个键的时间 49 按下，时间 50 松开）
按键持续时间最长的键是 ‘b’ 和 ‘c’（第二次按下时），持续时间都是 20
‘c’ 按字母顺序排列比 ‘b’ 大，所以答案是 ‘c’

示例 2：

输入：releaseTimes = [12,23,36,46,62], keysPressed = “spuda”
输出：“a”
解释：按键顺序和持续时间如下：
按下 ‘s’ ，持续时间 12
按下 ‘p’ ，持续时间 23 - 12 = 11
按下 ‘u’ ，持续时间 36 - 23 = 13
按下 ‘d’ ，持续时间 46 - 36 = 10
按下 ‘a’ ，持续时间 62 - 46 = 16
按键持续时间最长的键是 ‘a’ ，持续时间 16

提示：

releaseTimes.length == n
keysPressed.length == n
2 <= n <= 1000
1 <= releaseTimes[i] <= 109
releaseTimes[i] < releaseTimes[i+1]
keysPressed 仅由小写英文字母组成

解法1：字符串

代码：

class Solution {
public:
    char slowestKey(vector<int>& releaseTimes, string keysPressed) {
        char result = 'a';
        int maxcount = 0;
        
        for(int i = 0;i<keysPressed.size();i++){
            int count = i == 0? releaseTimes[i] : releaseTimes[i] - releaseTimes[i-1];
            char c = keysPressed[i];
            if(count > maxcount){
                maxcount = count;
                result = c;
            }else if(count == maxcount && c > result){
                result = c;
            }
        }

        return result;
    }
};

2034. 股票价格波动

力扣链接
给你一支股票价格的数据流。数据流中每一条记录包含一个 时间戳 和该时间点股票对应的 价格 。

不巧的是，由于股票市场内在的波动性，股票价格记录可能不是按时间顺序到来的。某些情况下，有的记录可能是错的。如果两个有相同时间戳的记录出现在数据流中，前一条记录视为错误记录，后出现的记录 更正 前一条错误的记录。

请你设计一个算法，实现：

更新 股票在某一时间戳的股票价格，如果有之前同一时间戳的价格，这一操作将 更正 之前的错误价格。
找到当前记录里 最新股票价格 。最新股票价格 定义为时间戳最晚的股票价格。
找到当前记录里股票的 最高价格 。
找到当前记录里股票的 最低价格 。
请你实现 StockPrice 类：

StockPrice() 初始化对象，当前无股票价格记录。
void update(int timestamp, int price) 在时间点 timestamp 更新股票价格为 price 。
int current() 返回股票 最新价格 。
int maximum() 返回股票 最高价格 。
int minimum() 返回股票 最低价格 。

示例 1：

输入：
[“StockPrice”, “update”, “update”, “current”, “maximum”, “update”, “maximum”, “update”, “minimum”]
[[], [1, 10], [2, 5], [], [], [1, 3], [], [4, 2], []]
输出：
[null, null, null, 5, 10, null, 5, null, 2]

解释：
StockPrice stockPrice = new StockPrice();
stockPrice.update(1, 10); // 时间戳为 [1] ，对应的股票价格为 [10] 。
stockPrice.update(2, 5); // 时间戳为 [1,2] ，对应的股票价格为 [10,5] 。
stockPrice.current(); // 返回 5 ，最新时间戳为 2 ，对应价格为 5 。
stockPrice.maximum(); // 返回 10 ，最高价格的时间戳为 1 ，价格为 10 。
stockPrice.update(1, 3); // 之前时间戳为 1 的价格错误，价格更新为 3 。
// 时间戳为 [1,2] ，对应股票价格为 [3,5] 。
stockPrice.maximum(); // 返回 5 ，更正后最高价格为 5 。
stockPrice.update(4, 2); // 时间戳为 [1,2,4] ，对应价格为 [3,5,2] 。
stockPrice.minimum(); // 返回 2 ，最低价格时间戳为 4 ，价格为 2 。

提示：

1 <= timestamp, price <= 109
update，current，maximum 和 minimum 总 调用次数不超过 105 。
current，maximum 和 minimum 被调用时，update 操作 至少 已经被调用过 一次 。

解法1：哈希表 + 有序集合

代码：

class StockPrice {
private:
    int t_max = 0;
    unordered_map<int,int> umap;// 时间-价格 哈希表
    multiset<int> mset;// 可重复有序集合
public:
    StockPrice() {

    }
    
    void update(int timestamp, int price) {
        t_max = max(timestamp,t_max);// 更新最新时间
        auto it = umap.find(timestamp);
        if(it!=umap.end()){// 哈希表中存在该时间点
            mset.erase(mset.find(it->second));// 有序集合中移除该价格
            it->second = price;// 更新哈希表中该时间点的价格
        }else{// 哈希表中不存在该时间点，直接在哈希表上记录该时间点的价格
            umap[timestamp] = price;
        }
        mset.insert(price);// 有序集合加入该价格
    }
    
    int current() {
        return umap[t_max];// 返回最新时间点的价格
    }
    
    int maximum() {
        return *mset.rbegin();// 返回有序集合尾元素
    }
    
    int minimum() {
        return * mset.begin();// 返回有序集合头元素
    }
};

/**
 * Your StockPrice object will be instantiated and called as such:
 * StockPrice* obj = new StockPrice();
 * obj->update(timestamp,price);
 * int param_2 = obj->current();
 * int param_3 = obj->maximum();
 * int param_4 = obj->minimum();
 */

884. 两句话中的不常见单词

力扣链接
句子 是一串由空格分隔的单词。每个 单词 仅由小写字母组成。

如果某个单词在其中一个句子中恰好出现一次，在另一个句子中却 没有出现 ，那么这个单词就是 不常见的 。

给你两个 句子 s1 和 s2 ，返回所有 不常用单词 的列表。返回列表中单词可以按 任意顺序 组织。

示例 1：

输入：s1 = “this apple is sweet”, s2 = “this apple is sour”
输出：[“sweet”,“sour”]

示例 2：

输入：s1 = “apple apple”, s2 = “banana”
输出：[“banana”]

提示：

1 <= s1.length, s2.length <= 200
s1 和 s2 由小写英文字母和空格组成
s1 和 s2 都不含前导或尾随空格
s1 和 s2 中的所有单词间均由单个空格分隔

解法1：字符串+哈希表

思路：

可以理解成拼接字符串A+B，然后返回拼接后的字符串中只出现过一次的单词

代码：

class Solution {
public:
    vector<string> uncommonFromSentences(string s1, string s2) {
        string s = s1 + " " + s2;
        unordered_map<string,int> umap;
        int start = 0;
        for(int i = 0;i<s.size();i++){
            if(s[i] == ' ') {
                umap[s.substr(start,i-start)]++;
                start = i+1;
            }
            else if(i == s.size() - 1) umap[s.substr(start,i-start+1)]++;
        }
        vector<string> res;
        for(auto& s:umap){
            if(s.second == 1) res.push_back(s.first);
        }
        return res;
    }
};

1763. 最长的美好子字符串

力扣链接
当一个字符串 s 包含的每一种字母的大写和小写形式 同时 出现在 s 中，就称这个字符串 s 是 美好 字符串。比方说，“abABB” 是美好字符串，因为 ‘A’ 和 ‘a’ 同时出现了，且 ‘B’ 和 ‘b’ 也同时出现了。然而，“abA” 不是美好字符串因为 ‘b’ 出现了，而 ‘B’ 没有出现。

给你一个字符串 s ，请你返回 s 最长的 美好子字符串 。如果有多个答案，请你返回 最早 出现的一个。如果不存在美好子字符串，请你返回一个空字符串。

示例 1：

输入：s = “YazaAay”
输出：“aAa”
解释：“aAa” 是一个美好字符串，因为这个子串中仅含一种字母，其小写形式 ‘a’ 和大写形式 ‘A’ 也同时出现了。
“aAa” 是最长的美好子字符串。
示例 2：

输入：s = “Bb”
输出：“Bb”
解释：“Bb” 是美好字符串，因为 ‘B’ 和 ‘b’ 都出现了。整个字符串也是原字符串的子字符串。
示例 3：

输入：s = “c”
输出：""
解释：没有美好子字符串。
示例 4：

输入：s = “dDzeE”
输出：“dD”
解释：“dD” 和 “eE” 都是最长美好子字符串。
由于有多个美好子字符串，返回 “dD” ，因为它出现得最早。

提示：

1 <= s.length <= 100
s 只包含大写和小写英文字母。

解法1：字符串+位运算

思路：
对于某个子串而言，我们只关心大小写是否同时出现，而不关心出现次数。

因此我们无须使用二维数组来记录具体的词频，可以在枚举子串时，使用两个 int 的低 2626 位分别记录大小写字母的出现情况，利用枚举子串时右端点后移，维护两变量，当且仅当两变量相等时，满足 2626 个字母的大小写同时出现或同时不出现。

代码：

class Solution {
public:
    string longestNiceSubstring(string s) {
        int n = s.size();
        string result = "";
        int maxLen = 0;
        for(int i = 0;i<n;i++){
            int lower = 0, upper = 0;
            for(int j = i;j<n;j++){
                if(s[j]>='A'&& s[j]<='Z') upper |= 1<< (s[j] - 'A');
                else if(s[j]>='a'&& s[j]<='z') lower |= 1<<(s[j] - 'a');
                if(lower == upper && j-i+1 > maxLen) {
                    maxLen = j-i+1;
                    result = s.substr(i,j-i+1);
                }
            }
        }
        return result;
    }
};

解法2 ：字符串+哈希表

思路：
使用s构造集合set1，使用s的全大写版构造集合set2，

如果set1的长度恰好是set2的两倍，则易证s是美好字符串。

代码：

class Solution {
public:
    string longestNiceSubstring(string s) {
        int n = s.size();
        string result = "";
        int maxLen = 0;
        for(int i = 0;i<n;i++){
            unordered_set<char> uset1;
            unordered_set<char> uset2;
            for(int j = i;j<n;j++){
                uset1.insert(s[j]);
                if(s[j]>='a'&& s[j]<='z') uset2.insert(s[j]-'a'+'A');
                else uset2.insert(s[j]);
                if(uset1.size() == 2*uset2.size() && j-i+1 > maxLen) {
                    maxLen = j-i+1;
                    result = s.substr(i,j-i+1);
                }
                }
            }
        return result;
    }
};