力扣刷题日记

给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的某个变位词。
换句话说，第一个字符串的排列之一是第二个字符串的 子串 。

示例 1：
输入: s1 = “ab” s2 = “eidbaooo”
输出: True
解释: s2 包含 s1 的排列之一 (“ba”).

示例 2：
输入: s1= “ab” s2 = “eidboaoo”
输出: False

提示：
1 <= s1.length, s2.length <= 10⁴
s1 和 s2 仅包含小写字母

思路1：滑动窗口

字符串 s1 中字符，那么就可以从头开始找 s2 中相同长度的字符串，判断 s1 与 s2的子串 中每个字符的个数是否相等。相等则表示 s2 中含有 s1 的变位词；反之则说明不包含，继续继续判断下个子串。s2 的子串就可以看成一个滑动窗口，某滑动窗口不包含 s1 的变位词，就把窗口往后移动一个元素。

代码如下：

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
        int size1 = s1.size(), size2 = s2.size();
        if(size1 > size2)
            return false;
        vector<int> v1(26, 0), v2(26, 0);
        for(int i = 0; i < size1; ++i){
            ++v1[s1[i] - 'a'];
            ++v2[s2[i] - 'a'];
        }
        if(v1 == v2)
            return true;
        for(int i = size1; i < size2; ++i){
            ++v2[s2[i] - 'a']; // 加上下一个元素
            --v2[s2[i - size1] - 'a']; // 去掉第一个元素
            if(v1 == v2)
                return true;
        }
        return false;
    }
};

时间复杂度：O(s2.size())；空间复杂度：O(2 * 26)。

思路2：思路1进一步优化

可以对思路 1 中的方法进行优化，进一步减少空间复杂度。我们可以把 s1 中字符出现的次数设为负数，而 s2子串 中字符出现的次数设为正数。如果两个字符串中所有字符出现的次数都是 0，那么说明 s2 中包含 s1 的某个变位词。

代码如下：

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
        int size1 = s1.size(), size2 = s2.size();
        if(size1 > size2)
            return false;
        vector<int> v(26, 0);
        for(int i = 0; i < size1; ++i){
            --v[s1[i] - 'a'];
            ++v[s2[i] - 'a'];
        }
        if(IsZero(v))
            return true;
        for(int i = size1; i < size2; ++i){
            ++v[s2[i] - 'a'];
            --v[s2[i - size1] - 'a'];
            if(IsZero(v))
                return true;
        }
        return false;
    }

    bool IsZero(vector<int>& v){
        for(int& n : v){
            if(n != 0)
                return false;
        }
        return true;
    }
};

时间复杂度：O(s2.size())；空间复杂度：O(26)。

思路3：双指针

在思路2的基础上，我们也可以考虑使用双指针的方法。思路2是固定窗口长度为 s1 的长度，然后判断 数组v 中元素是不是全部为0。双指针的思路可以反过来，即可以在保证 数组v 中元素不为正的情况下，判断该区间的长度是不是 s1 的长度。

用两个指针 left 和 right 表示考察的区间 [left,right]。right 每向右移动一次，就统计一次进入区间的字符 x。为保证 v 的值不为正，若此时 v[x]>0，则向右移动左指针，减少离开区间的字符的 v 值直到 v[x]≤0。[left,right] 的长度每增加 1，v 的元素值之和就增加 1。当 [left,right] 的长度恰好为 s1.size() 时，就意味着 v 的元素值之和为 0。由于 v 的值不为正，元素值之和为 0 就意味着所有元素均为 0，这样我们就找到了一个目标子串。（参考官方题解）

代码如下：

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
        int size1 = s1.size(), size2 = s2.size();
        if(size1 > size2)
            return false;
        int left = 0, right = 0;
        vector<int> v(26, 0);
        for(int i = 0; i < size1; ++i){
            --v[s1[i] - 'a'];
        }
        while(right < size2){
            ++v[s2[right] - 'a'];
            while(v[s2[right] - 'a'] > 0){
                --v[s2[left] - 'a'];
                ++left;
            }
            if(++right - left == size1)
                return true;
        }
        return false;
    }
};

时间复杂度：O(s1.size() + s2.size())；空间复杂度：O(26)。