LeetCode Substring with Concatenation of All Words

class Solution {

public:

    vector<int> findSubstring(string S, vector<string> &L) {

        vector<int> res;

		unordered_map<string, int> stat;

		unordered_map<string, int> run;

        int len = S.size();

		int num = L.size();

		int per = 0;



		if (num == 0 || !(per = L[0].size())) return res;

		

		int part= num * per;

		if (part > len) return res;

		

		int end = len - part;

        unordered_map<string, int>::iterator iter;

        pair<unordered_map<string, int>::iterator, bool> ir;

        

        for (int i=0; i<num; i++) {

			ir = stat.insert(pair<string, int>(L[i], 1));

			if (ir.second == false){

				ir.first->second++;				

			}

		}

		

		int i, j, pos, wc;

		string pre;

		for (i=0; i<=end; i++) {

			pos = i;

			for (j=0; j<num; j++, pos += per) {

				string seg = S.substr(pos, per);

				if (j == 0 || seg != pre) {

					iter = stat.find(seg);

					if (iter == stat.end()) break;

					wc = iter->second;

					ir = run.insert(pair<string, int>(seg, 1));

					iter = ir.first;

					if (ir.second) {

						pre = seg;

						continue;

					}

				}

				iter->second++;

				if (wc < iter->second) break;

			}

			if (j == num) res.push_back(i);

			run.clear();

    	}

    	return res;

    }

};

暴力解，跑了500+ms，如果每次都这样把题目应付过去，显然做题没有意义了。于是看Leetcode上关于那题的discuss，有人说可以用解决Minimum Window Substring的方法来解这一题，的确是可以。又搜了份Java实现的代码，一跑竟然也可以达到500ms，看来两种方法效率的确差很多。下面给出自己实现的代码

 1 class Solution3 {

 2 public:

 3     vector<int> findSubstring(string S, vector<string> &L) {

 4         vector<int> res;

 5         unordered_map<string, int> stat;

 6         unordered_map<string, int> run;

 7         int len = S.size();

 8         int num = L.size();

 9         int per = 0;

10 

11         if (num == 0 || !(per = L[0].size())) return res;

12         

13         int part = num * per;

14         if (part > len) return res;

15         

16         unordered_map<string, int>::iterator iter;

17         pair<unordered_map<string, int>::iterator, bool> ir;

18         

19         for (int i = 0; i < num; i++) {

20             ir = stat.insert(pair<string, int>(L[i], 0));

21             ir.first->second++;

22         }

23         int wc;

24         for (int i = 0; i < per; i++) {

25             int step = 0;

26             run.clear();

27             // scan like a worm, string[spos, epos] is the candidate

28             int spos=i, epos = i + per - 1;

29             for (; epos < len; epos += per) {

30                 string seg = S.substr(epos - per + 1, per);

31                 iter = stat.find(seg);

32                 // encounter some word not in L

33                 if (iter == stat.end()) {

34                     spos = epos + 1;

35                     step = 0;

36                     run.clear();

37                     continue;

38                 }

39                 

40                 wc = iter->second;

41                 step++;

42                 

43                 ir = run.insert(pair<string, int>(seg, 0));

44                 iter = ir.first;

45                 iter->second++;

46                 

47                 // string[spos, epos] is matched

48                 if (iter->second == wc && step == num) { 

49                     res.push_back(spos);

50                     run.find(S.substr(spos, per))->second--;

51                     step--;

52                     spos += per;

53                     continue;

54                 }

55                 

56                 // number of duplicated word exceeds needed

57                 if (iter->second > wc) {            

58                     string tmp = S.substr(spos, per);

59                     // find the first duplicated one

60                     while(seg != tmp) {

61                         run.find(tmp)->second--;

62                         step--;

63                         spos += per;

64                         tmp = S.substr(spos, per);

65                     }

66                     // then skip it

67                     iter->second--;

68                     spos += per;

69                     step--;

70                 }

71             }

72         }

73         return res;

74     } 

75 };

跑了一下在100+ms左右，又习得一策略技能！

参考：

zhuli题解 http://www.cnblogs.com/zhuli19901106/p/3570539.html

java实现 https://github.com/shengmin/coding-problem/blob/master/leetcode/substring-with-concatenation-of-all-words/Solution.java

leetcode资料 http://leetcode.com/2010/11/finding-minimum-window-in-s-which.html