Leetcode三道字符串滑动窗口的题目总结

Leetcode 438

给定一个字符串 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" 的字母异位词。

 

特点，窗口大小固定，为p的长度。

技巧用一个计数器count记录窗口中，p中字符出现的次数，来看是否满足条件，还需要借助一个辅助的HashMap。先对p Hash一次，将字符串字符与频率对应起来。后面右指针在移动过程中，找到频率减少，左指针移动频率增加（还回来）

窗口滑动的时候，开始的时候两个指针均位于原点，右指针先移动窗口大小步，左指针开始移动。一次移动一步

class Solution {
public:
    vector<int> findAnagrams(string s, string p) 
    {
        if(s.size()<p.size()) return {};
        int hash[26] ={0};                        // 开一个数组当Hash表
        for(auto c:p) hash[c-'a']++;              // 先存一遍p
        vector<int> res;
        int count = 0;                            // count保存窗口中满足要求字符串的个数
        for(int i=0,j=0;j<s.size();j++){
            hash[s[j]-'a']--;
            if(hash[s[j]-'a']>=0) count++;
            // 开始i不动j一直滑动到p.size()-1
            // 当移动到p.size()的位置时，i开始移动
            if(j>p.size()-1){
                hash[s[i]-'a']++;
                if(hash[s[i]-'a']>0) count--;          // 说明这个字符在p中出现
                i++;
            }
            // 跟新结果
            if(count==p.size())
                res.push_back(i);
        }
        return res;
    }
};

567. 字符串的排列

给定两个字符串 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) {
        // 判断s2 是否包含s1
        if(s2.size()<s1.size()) return false;
        int Hash[256]={0};
        for(auto c:s1) Hash[c]++;
        int count = 0;
        for(int i=0,j=0;j<s2.size();j++){
            Hash[s2[j]]--;
            if(Hash[s2[j]]>=0) count++;
            if(j>=s1.size()){
                Hash[s2[i]]++;
                if(Hash[s2[i]]>0) count--;
                i++;
            }
            if(count==s1.size()){
                return true;
            }
        }
        return false;
    }
};

 

上面的滑窗是属于窗口大小固定不动的滑窗，每次只右指针和左指针均只滑动一步，更难的滑窗是窗口大小会变的

 

Leetcode 76题

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

示例：

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

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

 

这里找的是最小的子串，所以窗口的长度是不固定的，很容易知道，窗口的最大长度就是整个字符串S

同样要使用HashMap存一遍T

所以在窗口滑动的过程中， 先移动右指针j，什么时候移动左指针i？当发现i指针在这个点是无用的时候，即Hash[S[i]] <0 时候，就移动i指针， 同时要把令Hash[S[i]]++， 此时不用count--，因为移动的是无用的点，是不会造成影响。

class Solution {
public:
    string minWindow(string s, string t) {
        string res="";
        if(s.size()<t.size()) return res;
        int Hash[256] = {0};                  // 字符串可以用256长度的数组
        for(auto c:t) Hash[c]++;
        int count = 0,max = s.size()+1;
        for(int i=0,j=0;j<s.size();j++){
            Hash[s[j]]--;                     
            if(Hash[s[j]]>=0)                 // s[j]>=0 的点，说明在t中出现过，count++
                count++;
            
            while(i<j &&Hash[s[i]]<0){
                Hash[s[i++]]++;               // s[i]<0的点跳过去,  
            }
            if(count==t.size() && j-i+1<max){
                max = j-i+1;
                res = s.substr(i,j-i+1);
            }
        }
        return res;
    }
};

3. 无重复字符的最长子串

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

示例 1:

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

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

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

 

这里也是一个变长滑窗问题， 右区间j往右边走，左区间往右边走的条件是Hash[s[j]]>1

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int Hash[256] = {0};
        int res = 0;
        for(int i=0,j=0;j<s.size();j++)
        {
            Hash[s[j]]++;
            while(i<j && Hash[s[j]]!=1)
                Hash[s[i++]]--;
            res = max(res, j-i+1);
        }
        return res;
    }
};

给你一个仅由大写英文字母组成的字符串，你可以将任意位置上的字符替换成另外的字符，总共可最多替换 k 次。在执行上述操作后，找到包含重复字母的最长子串的长度。

注意:
字符串长度 和 k 不会超过 104。

示例 1:

输入:
s = "ABAB", k = 2

输出:
4

解释:
用两个'A'替换为两个'B',反之亦然。
示例 2:

输入:
s = "AABABBA", k = 1

输出:
4

解释:
将中间的一个'A'替换为'B',字符串变为 "AABBBBA"。
子串 "BBBB" 有最长重复字母, 答案为 4。

 

class Solution {
public:
    int characterReplacement(string s, int k) {
        int maxlength = 0;
        int Hash[26] = {0};
        int maxLen = 0, res = 0;       // 记录当前区间中出现最多的字符和答案
        for(int i=0,j=0;j<s.size();j++){
            Hash[s[j]-'A']++;
            maxLen = max(maxLen, Hash[s[j]-'A']);
            while(i<j && j-i+1-maxLen>k)
                Hash[s[i++]-'A']--;
            res = max(res,j-i+1);
        }
        return res;
    }
};