【leetcode】Substring with Concatenation of All Words

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

 

第一种简单的思路：

用两个map，一个map用于表示L中各个单词的数目，另一个map用于统计当前遍历S得到的单词的数目

 

从第0个，第1个，第2个位置开始遍历S串

统计得到的单词的数目，如果某个单词数目超出了L中该单词的数目，或者某个单词没有再L中出现，则重新从下一个位置开始统计

 

 1 class Solution {

 2 public:

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

 4        

 5         if(L.size()==0) return vector<int>();

 6        

 7         int wordLen=L[0].size();

 8        

 9         map<string,int> wordCount;

10        

11         int i,j;

12         for(i=0;i<L.size();i++)  wordCount[L[i]]++;

13        

14        

15         vector<int> result;

16         map<string,int> counting;

17        

18         for(i=0;i<(int)S.length()-wordLen*L.size()+1;i++)

19         {

20             counting.clear();

21             for(j=0;j<L.size();j++)

22             {

23                 string str=S.substr(i+j*wordLen,wordLen);

24                 if(wordCount.find(str)!=wordCount.end())

25                 {

26                     counting[str]++;

27                     if(counting[str]>wordCount[str])

28                     {

29                         break;

30                     }

31                 }

32                 else

33                 {

34                     break;

35                 }

36             }

37            

38             if(j==L.size())

39             {

40                 result.push_back(i);

41                 //i=i+L.size()*wordLen-1;

42             }

43         }

44        

45         return result;

46  

47     }

48 };

 

 

 

 

第二种思路，维护一个窗口，在遍历时分别要从0,1……wordLen开始遍历一遍，防止遗漏

 

如果发现某个单词不在L中，则从下一个位置开始，重新统计

如果发现某个单词出现的次数多了，则需从这个单词第一次出现位置的后面一位开始统计，并要剔除这个位置之前统计的一些结果

 

 1 class Solution {

 2 public:

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

 4        

 5         if(L.size()==0) return vector<int>();

 6        

 7         int wordLen=L[0].size();

 8        

 9         map<string,int> wordCount;

10        

11         int i,j;

12         for(i=0;i<L.size();i++)  wordCount[L[i]]++;

13        

14        

15         vector<int> result;

16         map<string,int> counting;

17        

18        

19         int count=0;

20         int start;

21        

22         for(i=0;i<wordLen;i++)

23         {

24             count=0;

25             start=i;

26             counting.clear();

27             for(int j=i;j<S.length()-wordLen+1;j=j+wordLen)

28             {

29                 string str=S.substr(j,wordLen);

30                

31                 if(wordCount.find(str)!=wordCount.end())

32                 {

33                     counting[str]++;

34                     count++;

35                     if(counting[str]>wordCount[str])

36                     {

37                         //更新start位于str第一次出现之后，更新counting，更新count

38                         getNextIndex(start,str,counting,S,wordLen,count);

39                     }

40                 }

41                 else

42                 {

43                     counting.clear();

44                     start=j+wordLen;

45                     count=0;

46                 }

47                

48                 if(count==L.size())

49                 {

50                     result.push_back(start);

51                 }

52             }

53         }

54         return result;

55     }

56    

57    

58     void getNextIndex(int &start,string str,map<string,int> &counting,string &S,int &wordLen,int &count)

59     {

60         for(int j=0;;j++)

61         {

62             string tmpStr=S.substr(start+j*wordLen,wordLen);

63             count--;

64             counting[tmpStr]--;

65             if(tmpStr==str)

66             {

67                 start=start+(j+1)*wordLen;

68                 break;

69             }

70         }

71        

72     }

73 };