题目链接：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).

这道题的要求是给定字符串S，单词列表L（所有单词均等长），在S中找到包含L中所有单词且只包含一次的子字符串，返回符合该要求的所有子串的首位置。

1. 暴力查找

这道题的直接思路是以字符串中每个字符为起始，检查从这个字符开始的子串能否包含L中所有单词且只包含一次。优化查找时，可以对L中的单词进行Hash处理。时间复杂度较高，不过竟然没有超时。。。

时间复杂度：O(nm)（n为字符串S长度，m为单词列表L中单词数量）

空间复杂度：O(ml)（l为单词长度）

 1 class Solution
 2 {
 3 public:
 4     vector<int> findSubstring(string S, vector<string> &L)
 5     {
 6         vector<int> vi;
 7         if(L.size() == 0)
 8             return vi;
 9         
10         for(int i = 0; i + L.size() * L[0].size() - 1 < S.size(); ++ i)
11         {
12             unordered_multiset<string> ss(L.cbegin(), L.cend());
13             for(int j = i; !ss.empty(); j += L[0].size())
14             {
15                 string str = S.substr(j, L[0].size());
16                 auto iter = ss.find(str);
17                 if(iter == ss.end())
18                     break;
19                 ss.erase(iter);
20             }
21             if(ss.empty())
22                 vi.push_back(i);
23         }
24         return vi;
25     }
26 };

2. 双指针查找

可以发现上面的暴力方法中，最坏情况，字符串S中的大部分子串都进行了m次匹配，这其中能否减少次数呢。。。看了该题的Tags或者本文的标签，就回发现这么一个词：Two Point或者双指针。没错，就是这个词，和Longest Substring Without Repeating Characters同样的思路，即使用两个指针维护子串。不同之处是，这道题是判别每个字符串出现过的次数是否超过单词列表中该单词的数量。

思路仍然是维护一个窗口，如果当前单词在单词列表中，则继续移动窗口右端，否则窗口左端可以跳到字符串下一个单词了。

假设字符串S的长度为n，单词列表L中单词的长度为l。因为不是一个字符，所以需要对字符串S所有长度为l的子串进行判断。做法是i从0到l-1个字符开始，得到开始index分别为i, i+l, i+2*l, ...的长度为l的单词。这样就可以保证判断到所有的满足条件的子串。因为每次扫描的时间复杂度是O(2*n/l)（每个单词不会被访问多于两次，一次是窗口右端，一次是窗口左端），总共扫描l次（i=0, ..., l-1)，所以总复杂度是O(2*n/l*l)=O(n)，是一个线性算法。空间复杂度是单词列表的大小，即O(m*l)，其中m是单词列表的单词数量。

思路参考自这里。

时间复杂度：O(n)（n为字符串S长度）

空间复杂度：O(ml)（m为单词列表L中单词数量，l为单词长度）

 1 class Solution
 2 {
 3 public:
 4     vector<int> findSubstring(string S, vector<string> &L)
 5     {
 6         vector<int> vi;
 7         if(L.size() == 0)
 8             return vi;
 9 
10         unordered_map<string, int> msi;
11         for (int i = 0; i < L.size(); ++ i)
12             ++ msi[L[i]];
13 
14         for(int i = 0; i < L[0].size(); ++ i)
15         {
16             int b = i, cnt = 0;
17             unordered_map<string, int> tempmsi;
18             for(int j = i; j + L[0].size() <= S.size(); j += L[0].size())
19             {
20                 string str = S.substr(j, L[0].size());
21                 if(msi.find(str) != msi.end())
22                 {
23                     ++ tempmsi[str];
24                     ++ cnt;
25                     if(tempmsi[str] > msi[str])
26                     {
27                         while(tempmsi[str] > msi[str])
28                         {
29                             string s = S.substr(b, L[0].size());
30                             -- tempmsi[s];
31                             -- cnt;
32                             b += L[0].size();
33                         }
34                     }
35                     else if(cnt == L.size())
36                     {
37                         vi.push_back(b);
38                         -- tempmsi[S.substr(b, L[0].size())];
39                         -- cnt;
40                         b += L[0].size();
41                     }
42                 }
43                 else
44                 {
45                     tempmsi.clear();
46                     b = j + L[0].size();
47                     cnt = 0;
48                 }
49             }
50         }
51         return vi;
52     }
53 };