Leetcode | Substring with Concatenation of All Words

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

For example, given:
S: "barfoothefoobarman"
L: ["foo", "bar"]

You should return the indices: [0,9].
(order does not matter).

这题真是自作孽不可活啊。一直想用动态规划去做，但是一旦L里面有重复词就很麻烦。花了几个小时还是没做出来啊。。。我可怜的周末。

网上一看，原来就是扫描每一个位置，从该位置开始对每个单词计数。map里面存的是每个单词出现的次数（可能大于1）。

注意点：

1. S.length()返回值是size_t，如果直接用S.length()-int的话，负数会被转成很大的数；所以以后记得取字符串大小时，用一个int先来存。(Line 9)；

2. 用一个map统计word list中每个单词出现的次数； (Line 10-13)

3. 从第i个位置开始，用一个map来统计每个单词出现的次数，该次数不能超过第2步得到的次数；(Line 19)；

4. 如果最终合法的单词总数等于L.size()的话，把i存到结果中；（Line 25)。

5. Line 14 不减去wholeLen会出现TLE.

class Solution {
public:
    vector<int> findSubstring(string S, vector<string> &L) {
        vector<int> ret;
        if (S.empty()) return ret;
        if (L.empty()) return ret;
        int len = L[0].size();
        int wholeLen = len * L.size();
        int n = S.length();
        map<string, int> wordCount;
        for (int j = 0; j < L.size(); ++j) {
            wordCount[L[j]]++;
        }
        for (int i = 0; i <= n - wholeLen; ++i) {
            string tmp = S.substr(i, len);
            int pos = i;
            int c = 0;
            map<string, int> exist;
            while (wordCount.count(tmp) > 0 && exist[tmp] < wordCount[tmp]) {
                c++;
                pos += len;
                exist[tmp]++;
                tmp = S.substr(pos, len);
            }
            if (c == L.size()) ret.push_back(i);
        }
        return ret;
    }  
};

 事实上用dfs应该也可以，原理上是一样的，而且后面的不够长的位置就不用检查了。但是会出现MLE.

第三次写简洁许多。一次过。

class Solution {
public:
    vector<int> findSubstring(string S, vector<string> &L) {
        vector<int> ans;
        if (L.empty() || S.empty()) return ans;
        unordered_map<string, int> counts, appeared;
        for (auto str : L) {
            counts[str]++;
        }
        int len = L[0].length(), whole = len * L.size(), n = S.length();
        for (int start = 0; start + whole <= n; start++) {
            appeared.clear();
            bool found = true;
            for (int i = 0; i < whole && start + i < n; i += len) {
                string tmp = S.substr(start + i, len);
                appeared[tmp]++;
                if (counts.count(tmp) < 0 || appeared[tmp] > counts[tmp]) {
                    found = false;
                    break;
                }
            }
            if (found) ans.push_back(start);
        }
        
        return ans;
    }
};