算法专练:滑动窗口

1.1876. 长度为三且各字符不同的子字符串

原题链接

        如果一个字符串不含有任何重复字符，我们称这个字符串为 好 字符串。

        给你一个字符串 s ，请你返回 s 中长度为 3 的 好子字符串 的数量。

        注意，如果相同的好子字符串出现多次，每一次都应该被记入答案之中。
子字符串 是一个字符串中连续的字符序列。

        示例 1：

        输入：s = “xyzzaz”

        输出：1

        解释：总共有 4 个长度为 3 的子字符串：“xyz”，“yzz”，“zza” 和 “zaz” 。

        唯一的长度为 3 的好子字符串是 “xyz” 。

        示例 2：

        输入：s = “aababcabc”

        输出：4

        解释：总共有 7 个长度为 3 的子字符串：“aab”，“aba”，“bab”，“abc”，“bca”，“cab” 和 “abc” 。

        好子字符串包括 “abc”，“bca”，“cab” 和 “abc” 。

        提示：

        1 <= s.length <= 100

        s​​​​​​ 只包含小写英文字母。

滑动窗口，在该过程中维护一个长度为三的窗口即可。不过用两个边界来维护我觉得太麻烦了就用了一个unordered_map,每次先将当前字母加入表中，当下标大于等于3的时候去检查左边界，如果左边界字母仅仅出现了一次就将他移除，代表我们此时找到了一个字串。否则就说明左边界字母重复，将他的出现次数减一。最后当表中又三个元素的时候答案就加一。

class Solution {
public:
    int countGoodSubstrings(string s) {
        unordered_map<char,int> map;
        int n=s.size();
        int ans=0;
        for(int i=0;i<n;i++){
            map[s[i]]++;
            if(i>=3){
                if(map[s[i-3]]==1){
                    map.erase(s[i-3]);
                }else map[s[i-3]]--;
            }
            if(map.size()==3){
                ans++;
            }
        }
        return ans;
    }
};

这种是维护窗口长度的做法:

class Solution {
public:
    int countGoodSubstrings(string s) {
        int hash[128];
        memset(hash,0,sizeof(hash));
        int l=0,r=-1;
        int ans=0;
        int n=s.size()-1;
        while(r<n){
            r++;
            hash[s[r]]++;
            while(hash[s[r]]>1){
                --hash[s[l]];
                l++;
            }
            //如果右边界的字符出现次数大于了1，就抛弃该区间并清除该区间内字符出现次数
            while(r-l+1>3){
                --hash[s[l]];
                l++;
            }//如果窗口长度大于3也要移动左区间
            if(r-l+1==3){
                ans++;
            }
        }
        return ans;
    }
};

2.1839. 所有元音按顺序排布的最长子字符串

原体链接

        当一个字符串满足如下条件时，我们称它是 美丽的 ：

        所有 5 个英文元音字母（‘a’ ，‘e’ ，‘i’ ，‘o’ ，‘u’）都必须 至少 出现一次。

        这些元音字母的顺序都
        必须按照 字典序 升序排布（也就是说所有的 ‘a’ 都在 ‘e’ 前面，所有的 ‘e’ 都在 ‘i’ 前面，以此类推）

        比方说，字符串 “aeiou” 和 “aaaaaaeiiiioou” 都是 美丽的 ，但是 “uaeio” ，“aeoiu” 和 “aaaeeeooo” 不是美丽的 。

        给你一个只包含英文元音字母的字符串 word ，请你返回 word 中 最长美丽子字符串的长度 。如果不存在这样的子字符串，请返回 0 。

        子字符串 是字符串中一个连续的字符序列。

示例 1：

输入：wod = “aeiaaioaaaaeiiiiouuuooaauuaeiu”

输出：13

解释：最长子字符串是 “aaaaeiiiiouuu” ，长度为 13 。

示例 2：

输入：word = “aeeeiiiioooauuuaeiou”

输出：5

解释：最长子字符串是 “aeiou” ，长度为 5 。

示例 3：

输入：word = “a”

输出：0

解释：没有美丽子字符串，所以返回 0 。

提示：

1 <= word.length <= 5 * 105

word 只包含字符 ‘a’，‘e’，‘i’，‘o’ 和 ‘u’ 。

挺麻烦的一道题的，先看看模拟的做法：

class Solution {
public:
    int longestBeautifulSubstring(string word) {
        if(word.size()<5){
            return 0;
        }
        int ans=0;
        int len=1,type=1;
        for(int i=1;i<word.size();i++){
            if(word[i]>=word[i-1]){
                len++;
            }
            if(word[i]>word[i-1]){
                type++;
            }
            if(word[i]<word[i-1]){
                len=1,type=1;
            }
            if(type==5){
                ans=max(ans,len);
            }
        }
        return ans;
    }
};

代码很简单不再解释了，下面是滑动窗口的做法：

class Solution {
    int getindex(char c){
        char ch[6]={'a','e','i','o','u'};
        for(int i=0;i<5;++i){
            if(c==ch[i]){
                return i;
            }
        }
        return -1;
    }
    void gettype(char& c,int &cnt){
        int index=getindex(c);
        cnt|=(1<<(index));
    }
public:
    int longestBeautifulSubstring(string word) {
        int ans=0;
        int r=0;
        while(r<word.size()){
            if(word[r]!='a'){
                r++;
                continue;
            }
            int len=1,cnt=0;
            gettype(word[r],cnt);
            while(r+len<word.length()&&word[r+len-1]<=word[r+len]){
                gettype(word[r+len],cnt);
                ++len;
            }
            r+=len;
            if(cnt==31){
                ans=max(ans,len);
            }
        }
        return ans;
    }
};

这里的r其实设置为l更合适也就是窗口的左边界，下面解释就先用r来解释了。首先得到word[r]的字符种类，也就是cnt，这里就采用了状态压缩的思想。之后从当前长度len=1开始往后模拟，首先r+len不能超过字符串的长度，并且下一个字符要大于等于他的前一个字符，之后当前长度加一，并且种类的状态也进行累计。最后让左边界移动len位，并在五个元音都存在的情况下更新ans.

3.1984. 学生分数的最小差值

原题链接

给你一个 下标从 0 开始 的整数数组 nums ，其中 nums[i] 表示第 i 名学生的分数。另给你一个整数 k 。
从数组中选出任意 k 名学生的分数，使这 k 个分数间 最高分 和 最低分 的 差值 达到 最小化 。
返回可能的 最小差值 。

示例 1：

输入：nums = [90], k = 1

输出：0

解释：选出 1 名学生的分数，仅有 1 种方法：

示例 2：

输入：nums = [9,4,1,7], k = 2

输出：2

解释：选出 2 名学生的分数，有 6 种方法：

提示：

1 <= k <= nums.length <= 1000

0 <= nums[i] <= 105

这个就是水题了，不再过多解释。

class Solution {
public:
    int minimumDifference(vector<int>& nums, int k) {
        if(k==1)
        return 0;
        int ans=INT_MAX;
        sort(nums.begin(),nums.end());
        int n=nums.size();
        for(int i=0;i<=n-k;i++)
        ans=min(ans,nums[i+k-1]-nums[i]);
        return ans;
    }
};

4.1052爱生气的书店老板

原体链接

有一个书店老板，他的书店开了 n 分钟。每分钟都有一些顾客进入这家商店。给定一个长度为 n 的整数数组 customers ，其中 customers[i] 是在第 i 分钟开始时进入商店的顾客的编号，所有这些顾客在第 i 分钟结束后离开。
在某些时候，书店老板会生气。 如果书店老板在第 i 分钟生气，那么 grumpy[i] = 1，否则 grumpy[i] = 0。
当书店老板生气时，那一分钟的顾客就会不满意，若老板不生气则顾客是满意的。
书店老板知道一个秘密技巧，能抑制自己的情绪，可以让自己连续 minutes 分钟不生气，但却只能使用一次。
请你返回 这一天营业下来，最多有多少客户能够感到满意 。

示例 1：

输入：customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], minutes = 3

输出：16

解释：书店老板在最后 3 分钟保持冷静。

感到满意的最大客户数量 = 1 + 1 + 1 + 1 + 7 + 5 = 16.

示例 2：

输入：customers = [1], grumpy = [0], minutes = 1

输出：1

提示：

n == customers.length == grumpy.length

1 <= minutes <= n <= 2 * 10^4

0 <= customers[i] <= 1000

grumpy[i] == 0 or 1

这道题就有点难度了，不过搞清楚了老板生气的区间和顾客编号区间对应关系就简单多了。
先看代码吧：

class Solution {
    #define maxn 20005
public:
    int maxSatisfied(vector<int>& customers, vector<int>& grumpy, int minutes) {
        int prev[maxn];
        int gprev[maxn];
        memset(prev,0,sizeof(prev));
        memset(gprev,0,sizeof(prev));
        int n=customers.size();
        for(int i=1;i<=n;i++){
            prev[i]=prev[i-1]+customers[i-1];
            gprev[i]=gprev[i-1]+(!grumpy[i-1])*customers[i-1];
        }
        int i=1,j=0,ans=0;
        while(j<n){
            ++j;
            while(j-i+1>minutes){
                ++i;
            }
            if(j-i+1==minutes){
                int val=gprev[n]-(gprev[j]-gprev[i-1])+(prev[j]-prev[i-1]);
                ans=max(ans,val);
            }
        }
        return ans;
    }
};

先求去两个数组的前缀和，其中prev代表编号的前缀和，也就是在老板在该区间不生气的情况下的编号和，gprev代表该区间在老板生气状况下的编号前缀和.
然后就简单了，我们每次挑选一个minutes的区间，那么这样在[i,j]这个区间内的老板是不生气的，他的编号和就是prev[j]-prev[i-1],接下来我们要做的就是求出将这段区间求出在将这个区间转换成老板不生气的状态之后的新的gprev的前缀和也就是
        gprev[n]-(gprev[j]-gprev[i-1])+(prev[j]-prev[i-1])
这里就是把某个区间变为完全不生气的状态，那么新的编号和就需要先减去该区间生气状态下的编号和再加上该区间不生气状态下的编号和

需要注意的细节就是由于前缀和数组prve[i]和gprev[i]代表的都是[0,i-1]的和所以这里i开始设置为1，j开始设置为0（对应原先的i=0,j=-1)