5.10滑动窗口专题（leecode438，leecode567, leecode904)

leecode438. 找到字符串中所有字母异位词

第一次写这道题，确实写了很久，虽然在leecode上面也过了，但是时间比较久

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        int l = 0;
        int r = 0;
        vector<int> cnta(26);
        vector<int> cntb(26);
        vector<int> result;
        if(s.size() < p.size()) return vector<int>();
	
        else{
        for(int i = 0; i < p.size(); i++){
            cnta[p[i] - 'a']++;
        }
        
        r = l + p.size() - 1;

        for(r; r < s.size(); r++){
            l = r - p.size() + 1;
            while(l <= r){
                cntb[s[l] - 'a']++;
                l++;
            }
			
			// 如果相等，push完后直接清空重新判断
            if(cnta == cntb){
                result.push_back(r - p.size() + 1);
                fill(cntb.begin(),cntb.end(),0);
            }
            
            //如果不相等也是清空重新判即可
            else{
                fill(cntb.begin(),cntb.end(),0);
            }
        }

        return result;
        }
    }
};

看了题解之后，有了如下写法，维持窗口的大小不变，用两个vector储存字符串中的字符数量

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        vector<int> cnts(26);
        vector<int> cntp(26);

        if(p.size() > s.size()) return vector<int>(0);
        else{
        for(int i = 0; i < p.size(); i++){
            cnts[s[i] - 'a']++;
            cntp[p[i] - 'a']++;
        }

        vector<int> result;

        int windows = p.size();
        int l = 0;
        int r = l + windows - 1;
        r = r + 1;
        //维护窗口，一定要先r+1，这里跟写法有关系
        while(r < s.size()){
            if(cnts == cntp){
                result.push_back(l);
            }
			//当窗口向右边移动，出窗口的值--，进入窗口的值++
            cnts[s[r] - 'a']++;
            cnts[s[l] - 'a']--;

            r++;
            l++;


        
            
        }
		//这里还需要进行最后一次判断，因为当r == s.size()
		//时，没有再进行一次判断从而丢失了一种情况
        if(cntp == cnts) result.push_back(l);

        //这里需要再判断最后一次
        return result;
        }

    }
};

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        if(s.size()<p.size())
            return {};
        else{
        int l = 0;
        int r = 0;
        vector<int> cnts(200);
        vector<int> cntp(200);
        vector<int> ans;

        while(r < p.size()){
            cntp[p[r]]++;
            cnts[s[r]]++;
            r++;
        }
        

        while(r < s.size()){
            if(cntp == cnts) ans.push_back(l);
            cnts[s[l]]--;
            //千万注意不能这么些，因为这里的r已经超了一个了位置了
            cnts[s[r]]++;   
            l++;
            r++;
        }

        //这里也一定要记得再次判断，因为r比想象的要大一个，所以最后一种情况并没有判断
    
        if(cnts == cntp) ans.push_back(l);
        

        
        return ans;
        }
    }
};

而如下这种写法，只是先判断了第一种情况，然后判断后面的情况。跟上面第二种写法是一样的

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        if(s.size()<p.size())
            return {};
        int l = 0, r = -1;
        vector<int> freq_s(26, 0), freq_p(26, 0), res;
        // 初始化代码值
        for( int i = 0 ; i < p.size() ; i++ ){
            freq_p[p[i] - 'a' ]++;
            freq_s[s[++r] - 'a' ]++;
        }
        if ( freq_s == freq_p )
            res.push_back( l );
        // 固定长度的滑动窗口
        while( r < s.size()-1 ){
            freq_s[s[++r] - 'a' ]++;
            freq_s[s[l++] - 'a' ]--;
            if ( freq_s == freq_p )
                res.push_back( l );
        }
        return res;
    }
};

leecode567. 字符串的排列

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
        //这道题跟leecode438一摸一样
        vector<int> cnts1(26);
        vector<int> cnts2(26);
        bool result = false;
        if(s1.size() > s2.size()) return false;

        else{
        //先将字串的元素储存进cnts1,同时移动窗口将
        //s2的第一个窗口录入，以便比较。
        for(int i = 0; i < s1.size(); i++){
            cnts1[s1[i] - 'a']++;
            cnts2[s2[i] - 'a']++;
        }
        
        

        int l = 0;
        int r = l + s1.size() - 1;
        //窗口先移动一格，因为下面要先比较
        r = r + 1;

        //移动窗口分别比较
        while(r < s2.size()){
            if(cnts1 == cnts2){
                result = true;
                break;
            }

            cnts2[s2[r] - 'a']++;
            cnts2[s2[l] - 'a']--;
            r++;
            l++;
        }

        //最后这步比较非常的有必要，因为当r = s2.size()-1
        //的时候，循环就会停止，不回再判断，所以要判断
        //r = s2,size()-1这一段
        if(cnts1 == cnts2) result = true;


        }

        return result;
    }
};

leecode904. 水果成篮

此题与leecode3一摸一样！

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        //经过理解，本题目是选只有两个元素的最长子序列
        unordered_map<int, int> cnt;
        int r, l = 0;
        int sub;
        int result;
        while(r < fruits.size()){
            cnt[fruits[r]]++;
            while(cnt.size() > 2){
                cnt[fruits[l]]--;
                if(cnt[fruits[l]] == 0)
                {
                     cnt.erase(fruits[l]);
                }
                l++;
                sub = r - l  + 1;
                
                result = max(result, sub);
            }

            
            sub = r - l + 1;
            r++;
            result = max(result, sub);



        }

        return result;
    }
};