力扣43题 找到字符串中所有字母异位词C++ && 滑动窗口-个人理解存档

0.0我的笨蛋想法

使用一个unordered_map<char,int> pMap存储p中的元素及个数，key为char，value为该字符出现的次数。

顺次遍历s字符串，如果s[i]在pMap中，将s[i]对应的计数--，如果对应计数到0，清除当前key，当pMap空了的时候，说明这一段就是字母异位词；如果s[i]不在pMap中，说明这一段不是字母异位词。

当时想着【遍历一遍】就解决，那如果s[i]不在pMap中，前面这一段就都不可以复用，然后i就可以接下去继续遍历不用回头，但是如果s=”abab"，p="ab"的情况，当读到第二个a时，以b开头的段就会被忽略，所以为了不漏解，还是得回头，整个时间复杂度就来到了O(n^2)。所以就在一些测试用例上狠狠超时了。

所以其实我还是没掌握滑动窗口。😓

1.0我的超时题解

vector<int> findAnagrams1(string s, string p) {
        // 组成串的元素是相同的 
        // 构造子串的元素集合
        unordered_map<char,int> pMap;//key-char value-times出现次数
        for(char c : p){
            if(pMap.find(c)!=pMap.end()){
                pMap.find(c)->second++;
            }
            else{
                pMap.insert({c,1});
            }
        }
        // 找到一个在pMap的再开始检测
        vector<int> indexList;
        for(int i=0;i<s.size();){
            //如果从j开始，到k时不在pMap中，那就从k+1开始考虑
            if(pMap.find(s[i])!=pMap.end()){
                cout<<"Try to start with "<<s[i]<<" at index "<<i<<endl;
                // 先尝试加入当前序号
                indexList.push_back(i);
                unordered_map<char,int> copyPMap=pMap;
                copyPMap.find(s[i])->second--;
                cout<<"Find "<<s[i]<<endl;
                if(copyPMap.find(s[i])->second==0){
                    // 清除已经查找到的元素
                    copyPMap.erase(s[i]);
                    cout<<"Find all "<<s[i]<<endl;
                }
                //检查下一个
                int j=i+1;
                // i++;
                while(copyPMap.find(s[j])!=copyPMap.end()){
                    //能找到
                    copyPMap.find(s[j])->second--;
                    cout<<"Find "<<s[j]<<endl;
                    if(copyPMap.find(s[j])->second==0){
                        // 清除已经查找到的元素
                        cout<<"Find all "<<s[j]<<endl;
                        copyPMap.erase(s[j]);
                    }
                    j++;
                }
                // 退出循环可能是找到了 也可能是被打断了
                if(copyPMap.size()==0){
                    // 都被找到了
                    // 考虑 abab的情况，a考虑完还得从b开始
                    cout<<"Success to start with "<<s[i]<<" at index "<<i<<endl;
                    i++;
                }
                else{
                    // 被打断了 前面的尝试都不再可能，从j开始尝试 ???
                    cout<<"Fail to start with "<<s[i]<<" at index "<<i<<endl;
                    indexList.pop_back();//这个尝试是失败的
                    i++;
                }
            }
            else{
                i++;
            }
        }
        return indexList;
    }

0.1 真正的滑动窗口！！

有几个点是关键：

1.只有小写字母，可以参考以往的子串之类的方法，直接用一个大小为26的数组进行计数统计，直接比较数组是否相等也很快；

2.p是标准，所以窗口的大小是固定的

3.如果i作为窗口开始的位置，窗口长度为pLen，窗口结束的位置应该是i+pLen-1，当滑动的时候，需要清除i-1位置的计数，新增i-1+Lpen位置的计数

最后一个窗口的开始位置应该满足i+pLen-1<sLen 化简得 i<sLen-pLen+1

是真正意义上的一次遍历不用回头重复计算

1.1真正的滑动窗口题解

vector<int> findAnagrams(string s, string p){
        // s的子串长度一定和p长度一致，所以窗口大小是固定的
        // 全是小写字母 使用数组进行计数——可以通过直接比较数组是否相同来判断是否为。。。子串
        int sLen=s.size(),pLen=p.size();
        if(sLen<pLen) return vector<int>();//p比s还多，不可能
        vector<int> res;//存滑动窗口的开头序号
        vector<int> sCount(26);//固定大小 因为只有26个小写字母
        vector<int> pCount(26);
        // 初始化pCount
        for(int i=0;i<pLen;i++){
            pCount[p[i]-'a']++;
        }

        // 先初始化，从0开始的第一个窗口 窗口大小为pLen
        for(int i=0;i<pLen;i++){
            sCount[s[i]-'a']++;
        }
        // 判断第一个窗口是不是可行的
        if(sCount==pCount){
            res.push_back(0);
        }
        // 开始滑动窗口
        // 如果i作为窗口开始的位置，窗口长度为pLen，窗口结束的位置应该是i+pLen-1，当滑动的时候，需要清除i-1位置的计数，新增i-1+Lpen位置的计数
        // 最后一个窗口的开始位置应该满足i+pLen-1<sLen i<sLen-pLen+1
        for(int i=1;i<sLen-pLen+1;i++){
            sCount[s[i-1]-'a']--;
            sCount[s[i+pLen-1]-'a']++;
            // 更新完后判断当前窗口是否可行
            if(sCount==pCount){
                res.push_back(i);
            }
        }
        return res;
    }