LeetCode30 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.

For example, given:
s: "barfoothefoobarman"
words: ["foo", "bar"]

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

分析：

题目意思是找到所有起始位置，使得往后的若干连续字符组成的字符串 的正好是集合中所有元素组成的字符串。

自己考虑到的还是一个暴力的做法，没有超时，写起来也没那么容易。

大致思路是建一个hash存放words不同元素出现在words中的次数(开始只存放有无，后来发现words中元素可重复)

然后对s进行遍历，从每个位置开始，依次取len长度的字符串，与hash中的值比较。根据在不在hash内进行跳出循环，hash[words[j]]--等操作.

到words.size() -1 长度自然跳出循环，说明完全匹配，可以将这个i加入结果。

代码：

 class Solution {
 public:
     vector<int> findSubstring(string s, vector<string>& words) {
         int len = words[].size();
         unordered_map<string, int> count;
         vector<int> result;
         if (s.size() < words.size() * len) {
             return result;
         }
          for (int k =  ; k < words.size(); ++k) {
             if (count.find(words[k]) == count.end()) {
                 count[words[k]] = ;
             }
             else {
                 count[words[k]] ++;
             }
         }
         unordered_map<string, int> save = count;
         for (int i = ; i <= s.size() - words.size() * len; i++) {
             int flag = ;
             for (int j = i; j < i + words.size() * len  ; j += len) {
                 string temp = s.substr(j, len);
                 if (count.find(temp) != count.end()) {
                     if (count[temp] > ) {
                         count[temp]--;
                     }
                     else {
                         flag = ;
                         break;
                     }
                 }
                 else {
                     flag = ;
                     break;
                 }
             }
             if (flag == ) {
                 result.push_back(i);
             }
             count = save;
         }
         return result;
     }
 };

8月19日更新：

对于自己的实现中，每次更新i都需要拷贝一次hash表。

可以换一种方式，一个hash作为基准在循环前准备好。然后对于每个i生成一个新的hash，添加元素进去，与老的比较，比拷贝应该效率要高。

其他注意事项：

1. words.size()，s.size()都是unsigned int，所以做减法之后不会出现 -1，所以导致由此限定循环有问题，所以自己在前面加了一个

if (s.size() < words.size() * len) 

 搞清楚原因后前面声明两个int变量可以把这个if去掉。

2. unordered_map<string,int> hash可以直接对hash[temp]++，没有的话就是从0加1，默认初始化的0。

所以修改后的代码：

 class Solution {
 public:
     vector<int> findSubstring(string s, vector<string>& words) {
         int len = words[].size();
         unordered_map<string, int> count;
         vector<int> result;
         for (int k =  ; k < words.size(); ++k) {
             count[words[k]]++;
         }
         //s.size() - words.size() * len 结果是个unsigned;
         int n = s.size(), m = words.size();
         for (int i = ; i <= n - m * len; i++) {
             unordered_map<string, int> hash;
             int flag = ;
             for (int j = i; j < i + words.size() * len  ; j += len) {
                 string temp = s.substr(j, len);
                 hash[temp]++;
                 if (hash[temp] > count[temp]) {
                     flag = ;
                     break;
                 }
             }
             if (flag == ) {
                 result.push_back(i);
             }
         }
         return result;
     }
 };

好像还有个滑动窗口的解法，回头头脑清楚再研究...