LeetCode之567. 字符串的排列

题目

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

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

示例1:

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

示例2:

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

注意：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/permutation-in-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析

看到题目以后第一反应是回溯法可以解决，但是回溯法一个最大的缺点就是效率较低，所以可想而知的，超时了。。。。
看了题解以后才发现原来还有这种方法可以解决问题，称之为“滑动窗口”。

回溯法(超时)

• 使用1个map记录s1的字符分布；
• 逐步读取s2，如果s2中的字符不在s1集合内，则遍历到下一个字符;
• 如果s2的字符=s1的字符，则表示开始校验是否符合要求，然后map内的该字符数量-1，然后继续往下遍历，以此类推，直到map为空，则表示含有匹配项，返回true即可；
• 如果中途遇到没有匹配的字符，则从该字符开始从头开始匹配s1的字符集。
• 同时，若当前字符在s1的字符集内，也要考虑该字符虽然属于s1的字符集，但是不在答案范围内的情况。
  代码如下：

class Solution {
public:
	// 记录s1的字符集，当遇到不匹配的字符时能够恢复字符集
    unordered_map<char, int> m_Map;

    bool checkInclusion(string s1, string s2) {
        if (s1.empty() && s2.empty()) {
            return false;
        }
        unordered_map<char, int> map; // s1的字符集
        for (auto &c : s1) {
            auto item = map.find(c);
            if (item == map.end()) {
                map.insert(make_pair(c, 1));
            } else {
                ++map[c];
            }
        }
        m_Map = map;
        return back(s2, 0, map, false); // 开始回溯
    }

    bool back(string s2, int i, unordered_map<char, int> &map, bool isBegin) {
        if (map.empty()) {
            return true;
        }

        if (i == s2.size()) {
            return false;
        }

        if (map.find(s2[i]) == map.end()) {
            // 当前字符不在map中
            if (isBegin) {
                // 已经开始遍历s1了
                return false;
            }
            return back(s2, i + 1, map, false);
        }

        int tmp = map[s2[i]];
        if (--map[s2[i]] == 0) {
            map.erase(s2[i]);
        }

        bool left = back(s2, i + 1, map, true);

        map = m_Map;
        bool right = back(s2, i + 1, map, false);
        return left || right;
    }
};

滑动窗口

滑动窗口的概念比较容易理解了，假设s1和s2为2个窗口，窗口内的元素是一个集合。然后逐步滑动和比对s1和s2窗口。

根据题意，我们知道s1的长度一定是比s2的长度要小，如果反之，则一定返回false。

• 以s1的长度为窗口的大小，创建2个“窗口”，实际上是2个数组，数组的大小为26（因为只包含26个字母），每个字母 - 'a'为索引，数组的值为该字母出现的次数。
• 两个窗口设置完毕后，用memcmp（内存比较非常非常非常快）对两个数组进行比较。
• 若不一致，则s2窗口像右滑动一个单位，然后继续比较，直到结束。
• 若过程中比较结果一致，则返回true。

代码

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
        if (s1.size() > s2.size()) {
            return false;
        }

        int vec1[26] = {0};
        int vec2[26] = {0};

        int minSize = s1.size();

        for (int i = 0; i < minSize; ++i) {
            ++vec1[s1[i] - 'a'];
            ++vec2[s2[i] - 'a'];
        }

        for (int i = minSize; i < s2.size(); ++i) {
            if (memcmp(vec1, vec2, 26 * sizeof(int)) == 0) {
                return true;
            }

            // 窗口向后滑动
            ++vec2[s2[i] - 'a'];
            --vec2[s2[i - minSize] - 'a'];
        }
        return memcmp(vec1, vec2, 26 * sizeof(int)) == 0;
    }
};