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[0].size();
        unordered_map<string, int> count;
        vector<int> result;
        if (s.size() < words.size() * len) {
            return result;
        }
         for (int k = 0 ; k < words.size(); ++k) {
            if (count.find(words[k]) == count.end()) {
                count[words[k]] = 1;
            } 
            else {
                count[words[k]] ++;
            }
        }
        unordered_map<string, int> save = count;
        for (int i = 0; i <= s.size() - words.size() * len; i++) {
            int flag = 0;
            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] > 0) {
                        count[temp]--;
                    }
                    else {
                        flag = 1;
                        break;
                    }
                }
                else {
                    flag = 1;
                    break;
                }
            }
            if (flag == 0) {
                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[0].size();
        unordered_map<string, int> count;
        vector<int> result;
        for (int k = 0 ; k < words.size(); ++k) {
            count[words[k]]++;    
        }
        //s.size() - words.size() * len 结果是个unsigned;
        int n = s.size(), m = words.size();
        for (int i = 0; i <= n - m * len; i++) {
            unordered_map<string, int> hash;
            int flag = 0;
            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 = 1;
                    break;
                }
            }
            if (flag == 0) {
                result.push_back(i);
            }
        }
        return result;
    }
};

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