19.1.30 [LeetCode 30] Substring with Concatenation of All Words

You are given a string, s, and a list of words, words, that are all of the same length. Find all starting indices of substring(s) in s that is a concatenation of each word in words exactly once and without any intervening characters.

Example 1:

Input:
  s = "barfoothefoobarman",
  words = ["foo","bar"]
Output: [0,9]
Explanation: Substrings starting at index 0 and 9 are "barfoor" and "foobar" respectively.
The output order does not matter, returning [9,0] is fine too.

Example 2:

Input:
  s = "wordgoodgoodgoodbestword",
  words = ["word","good","best","word"]
Output: []

题意

给定字符串s和字符串数组words，对于words中所有字符串任意顺序组合而成的字符串，如果是s的子串的求出在s中出现的所有索引。

题解

一开始暴力TLE了

class Solution {
public:
    set<int>ans;
    void findstr(string s,string now,deque<string>&words) {
        if (words.empty()) {
            int idx = s.find(now), base = 0;
            while (idx != string::npos) {
                ans.insert(idx+base);
                base = base + idx + 1;
                s=s.substr(idx + 1);
                idx = s.find(now);
            }
            return;
        }
        int size = words.size();
        for (int i = 0; i < size; i++) {
            string tmp = words[size-1];
            words.pop_back();
            findstr(s, now + tmp, words);
            words.push_front(tmp);
        }
        return;
    }
    vector<int> findSubstring(string s, vector<string>& words) {
        if (s == "" || words.size() == 0)return vector<int>();
        deque<string>wwords;
        for (int i = 0; i < words.size(); i++)
            wwords.push_back(words[i]);
        findstr(s, "", wwords);
        return vector<int>(ans.begin(),ans.end());
    }
};

 后来搞了种非常混乱的方法，类似于之前有道题的滑动窗口（要看清所有单词都是相同长度的，不然是想不到这种方法的……我一开始就没看见……）

具体就是：

单词长度：l，s长度：sl

每次选定一个值为0~l-1的起始指针，初始尾指针与头指针重合，然后每次判断目前指向的那个单词（指针处于这个单词的头部）如果加进目前头尾指针形成的字符串中是否合法，如果合法就把尾指针后移l，否则把头指针移到尾指针后面。

滑动窗口还算是蛮有趣蛮有用的一个思想吧

class Solution {
public:
    vector<int>contained, cnt, id;
    map<string, int>idx;
    int l;
    vector<int> findSubstring(string s, vector<string>& words) {
        if (s == "" || words.size() == 0)return vector<int>();
        vector<int>ans;
        contained.resize(words.size());
        cnt.resize(words.size());
        id.resize(s.length());
        sort(words.begin(), words.end());
        for (int i = 0; i < contained.size(); i++) {
            contained[i] = 0;
            cnt[i] = 0;
            idx.insert(make_pair(words[i], i));
            cnt[idx[words[i]]]++;
        }
        int leng = s.length();
        l = words[0].size();
        for (int i = 0; i < leng; i++) {
            if (idx.find(s.substr(i, l)) != idx.end())
                id[i] = idx[s.substr(i, l)];
            else id[i] = -1;
        }
        for (int i = 0; i < l; i++) {
            int S = i;
            for (int j = i; j < leng; j += l) {
                int now = id[j];
                if (now == -1) {
                    while (S < j) {
                        contained[id[S]]--;
                        S += l;
                    }
                    S += l;
                    continue;
                }
                while (contained[now] >= cnt[now]) {
                    contained[id[S]]--;
                    S += l;
                }
                contained[now]++;
                if (j - S + l == l * words.size())
                    ans.push_back(S);
            }
            for (int j = 0; j < contained.size(); j++)
                contained[j] = 0;
        }
        return ans;
    }
};