【LeetCode】30. Substring with Concatenation of All Words 单词匹配子串

一、概述

输入一个字符串s和一个字符串数组words，words中的字符串等长，若s有一个子串，由words中所有元素构成，则输出这个字串的第一个字符的下标。输出所有该类型子串的下标。

要求有点繁琐，举例子就很简单：

s = "barfoothefoobarman",
words = ["foo","bar"]

那么子串有barfoo，下标为0；foobar，下标为9。解答起来也很麻烦。

二、分析

我的代码时空复杂度还不错，因此就只分析我自己的了。

首先注意到words中元素的限制条件——长度相同，设置其为l，那么就可以根据这一点来进行遍历：

第一轮：从s的第0个开始，每l个一组，与words中的元素比较；

第二轮：从s的第1个开始；第三轮，从s的第2个开始；...第l轮：从s的第l-1个开始。

然后就结束了。从第l个开始等价于从第0个开始。因此时间复杂度为O(l*n)，n为s的长度。

然后要注意到words中的元素可以有重复的，最开始我就是没注意到这点，用set去做，发现了之后所有代码都要推倒从来，很是蛋疼。

对于每轮比较，我们维护一个hash表m，储存当前words中还没匹配的元素；维护一个指针tmp_ans，指向当前子串的头部；维护一个整数now_len，表示当前子串的长度。当比较的时候，会出现三种情况：

①、s中的该子串在words中没有对应的。那么头指针将指向该子串的下一个。now_len置零。m回复初始状态。

②、s中的该子串在word中有对应的，但是words中该子串对应的元素已经全部匹配完。那么开始循环，头指针对应的子串对应的m中的值+1，头指针前移，长度减一；直到words中该子串对应的元素重新出现。

③、s中的该子串在word中有对应的，now_len与words的元素个数相等。那么我们找到一个解。将这个解保存下来，头指针前移；m增加，now_len减少。

代码如下：

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        vector<int> res;
        if(s==""||words.size()==0)
            return res;
        unordered_map<string,int> m;
        for(int i=0;i<words.size();++i)
            if(words[i].size()>s.size())
                return res;
            else
                ++m[words[i]];
        for(int i=0;i<words[0].size();++i)
        {
            int tmp_ans=i;
            int now_len=0;
            for(int j=i;j<=s.size()-words[0].size();j+=words[0].size())
            {
                if(m.find(s.substr(j,words[0].size()))==m.end())
                {
                    while(tmp_ans!=j)
                    {
                        ++m[s.substr(tmp_ans,words[0].size())];
                        tmp_ans+=words[0].size();
                    }
                    tmp_ans+=words[0].size();
                    now_len=0;
                } 
                else
                {
                    --m[s.substr(j,words[0].size())];
                    ++now_len;
                    while(m[s.substr(j,words[0].size())]<0)
                    {
                        ++m[s.substr(tmp_ans,words[0].size())];
                        tmp_ans+=words[0].size();
                        --now_len;
                    }
                    if(now_len==words.size())
                    {
                        res.push_back(tmp_ans);
                        ++m[s.substr(tmp_ans,words[0].size())];
                        tmp_ans+=words[0].size();
                        --now_len;
                    }
                }
            }
            while(now_len>0)
            {
                ++m[s.substr(tmp_ans,words[0].size())];
                tmp_ans+=words[0].size();
                --now_len;
            }
        }
        return res;
    }
};

注意四点：

其一，当头指针出现变化时，一定对应len和m的变化，不要忘了；

第二，每次j遍历完，都要把m恢复原样；

第三，用unorder_map而不是map，可以节省三倍时间；

第四，words中的元素长度如果比s大，可以直接返回。

三、总结

有些复杂的题目，主要就是words可以有重复元素，导致无法使用set，必须使用哈希表才行。这样要维护多个变量和数据结构，就显得有些麻烦。注意，只需要哈希表时不要用map，很拖后腿。