滑动窗口：438找到字符串中所有字母异位词;76最小覆盖子串;567字符串的排列；3无重复字符的最长子串

滑动窗口总结

int left = 0, right = 0;
while (right < s.size()) {`
    // 增大窗口
    window.add(s[right]);
    right++;
    while (window needs shrink) {
        // 缩小窗口
        window.remove(s[left]);
        left++;
    }
}

/* 滑动窗口算法框架 */
void slidingWindow(string s, string t) {
    unordered_map<char, int> need, window;
    for (char c : t) need[c]++;

    int left = 0, right = 0;
    int valid = 0; 
    while (right < s.size()) {
        // c 是将移入窗口的字符
        char c = s[right];
        // 右移窗口
        right++;
        // 进行窗口内数据的一系列更新
        ...
        // 判断左侧窗口是否要收缩
        while (window needs shrink) {
            // d 是将移出窗口的字符
            char d = s[left];
            // 左移窗口
            left++;
            // 进行窗口内数据的一系列更新
            ...
        }
    }
}

 

给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。

字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。

说明：

    字母异位词指字母相同，但排列不同的字符串。
    不考虑答案输出的顺序。

示例 1:

输入:
s: "cbaebabacd" p: "abc"

输出:
[0, 6]

解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的字母异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的字母异位词。

 示例 2:

输入:
s: "abab" p: "ab"

输出:
[0, 1, 2]

解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的字母异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的字母异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的字母异位词。

class Solution {//暴力解法 O(SP)
public:
    vector<int> findAnagrams(string s, string p) {
        int sSize=s.size(),pSize=p.size();
        if(sSize<pSize)return{};
        vector<int>v(26,0),res;
        for(char c:p)
            ++v[c-'a'];            
        for(int i=0,j;i<=sSize-pSize;++i){
            vector<int>temp(v);            
            for(j=i;j<i+pSize;++j){
                if(--temp[s[j]-'a']<0)
                    break;
            }
            if(j==i+pSize)res.push_back(i);
        }
        return res;
    }
};

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        unordered_map<char,int>need,windows;//needs 和 window 相当于计数器，分别记录 T 中字符出现次数和「窗口」中的相应字符的出现次数。
        vector<int>res;
        for(char c:p)++need[c];
        int sSize=s.size(),pSize=p.size(),nSize=need.size();
        int le=0,ri=0;//[le,ri)
        int validCount=0;//窗口中满足 need 条件的字符个数，如果 validCount和 need.size 的大小相同，则说明窗口已满足条件，已经完全覆盖了串 T。
        while(ri<sSize){
            char c=s[ri++];
            //1、当移动 right 扩大窗口，即加入字符时，应该更新哪些数据？
            if(need.count(c))
                if(need[c]==++windows[c])
                    ++validCount;
            //2、什么条件下，窗口应该暂停扩大，开始移动 left 缩小窗口？
            while(ri-le>=pSize){
                //4、我们要的结果应该在扩大窗口时还是缩小窗口时进行更新？
                if(validCount==nSize)
                    res.push_back(le);
                char c=s[le++];
                //3、当移动 left 缩小窗口，即移出字符时，应该更新哪些数据？
                if(need.count(c))
                    if(need[c]==windows[c]--)
                        --validCount;
            }
        }
        return res;
    }
};

给你一个字符串 S、一个字符串 T，请在字符串 S 里面找出：包含 T 所有字符的最小子串。

示例：

输入: S = "ADOBECODEBANC", T = "ABC"
输出: "BANC"

说明：

    如果 S 中不存这样的子串，则返回空字符串 ""。
    如果 S 中存在这样的子串，我们保证它是唯一的答案。

class Solution {
public:
    string minWindow(string s, string t) {
        unordered_map<char,int>need,windows;//needs 和 window 相当于计数器，分别记录 T 中字符出现次数和「窗口」中的相应字符的出现次数。
        int pos=0,len=INT_MAX;
        for(char c:t)++need[c];
        int sSize=s.size(),nSize=need.size();
        int le=0,ri=0;//[le,ri)
        int validCount=0;//窗口中满足 need 条件的字符个数，如果 validCount和 need.size 的大小相同，则说明窗口已满足条件，已经完全覆盖了串 T。
        while(ri<sSize){
            char c=s[ri++];
            //1、当移动 right 扩大窗口，即加入字符时，应该更新哪些数据？
            if(need.count(c))
                if(need[c]==++windows[c])
                    ++validCount;
            //2、什么条件下，窗口应该暂停扩大，开始移动 left 缩小窗口？
            while(validCount==nSize){
                //4、我们要的结果应该在扩大窗口时还是缩小窗口时进行更新？
                if(ri-le<len){
                    len=ri-le;
                    pos=le;
                }
                char c=s[le++];
                //3、当移动 left 缩小窗口，即移出字符时，应该更新哪些数据？
                if(need.count(c))
                    if(need[c]==windows[c]--)
                        --validCount;
            }
        }
        return len==INT_MAX?"":s.substr(pos,len);
    }
};

给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的排列。

换句话说，第一个字符串的排列之一是第二个字符串的子串。

示例1:

输入: s1 = "ab" s2 = "eidbaooo"
输出: True
解释: s2 包含 s1 的排列之一 ("ba").

 

示例2:

输入: s1= "ab" s2 = "eidboaoo"
输出: False

 

注意：

    输入的字符串只包含小写字母
    两个字符串的长度都在 [1, 10,000] 之间

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
        unordered_map<char,int>need,windows;//needs 和 window 相当于计数器，分别记录 T 中字符出现次数和「窗口」中的相应字符的出现次数。
        for(char c:s1)++need[c];
        int s2Size=s2.size(),s1Size=s1.size(),nSize=need.size();
        int le=0,ri=0;//[le,ri)
        int validCount=0;//窗口中满足 need 条件的字符个数，如果 validCount和 need.size 的大小相同，则说明窗口已满足条件，已经完全覆盖了串 T。
        while(ri<s2Size){
            char c=s2[ri++];
            //1、当移动 right 扩大窗口，即加入字符时，应该更新哪些数据？
            if(need.count(c))
                if(need[c]==++windows[c])
                    ++validCount;
            //2、什么条件下，窗口应该暂停扩大，开始移动 left 缩小窗口？
            while(ri-le>=s1Size){
                //4、我们要的结果应该在扩大窗口时还是缩小窗口时进行更新？
                if(validCount==nSize)return true;
                char c=s2[le++];
                //3、当移动 left 缩小窗口，即移出字符时，应该更新哪些数据？
                if(need.count(c))
                    if(need[c]==windows[c]--)
                        --validCount;
            }
        }
        return false;
    }
}

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_map<char,int>windows;
        int sSize=s.size(),le=0,ri=0,res=0,validCount=0;
        while(ri<sSize){
            char c=s[ri++];
            if(++windows[c]==1)++validCount;
            if(ri-le==validCount)
                res=max(res,validCount);
            while(ri-le>validCount){
                char c=s[le++];
                if(windows[c]--==1)--validCount;
            }
        }
        return res;
    }
};

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_map<char,int>windows;
        int sSize=s.size(),le=0,ri=0,res=0;
        while(ri<sSize){
            char c=s[ri++];   
            ++windows[c];              
            while(windows[c]>1){
                char c=s[le++];
                --windows[c];
            }
            res=max(res,ri-le);
        }
        return res;
    }
};