【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中出现，则重新从下一个位置开始统计

 

 class Solution {
 public:
     vector<int> findSubstring(string S, vector<string> &L) {

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

         int wordLen=L[].size();

         map<string,int> wordCount;

         int i,j;
         for(i=;i<L.size();i++)  wordCount[L[i]]++;

         vector<int> result;
         map<string,int> counting;

         for(i=;i<(int)S.length()-wordLen*L.size()+;i++)
         {
             counting.clear();
             for(j=;j<L.size();j++)
             {
                 string str=S.substr(i+j*wordLen,wordLen);
                 if(wordCount.find(str)!=wordCount.end())
                 {
                     counting[str]++;
                     if(counting[str]>wordCount[str])
                     {
                         break;
                     }
                 }
                 else
                 {
                     break;
                 }
             }

             if(j==L.size())
             {
                 result.push_back(i);
                 //i=i+L.size()*wordLen-1;
             }
         }

         return result;

     }
 };

 

 

 

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

 

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

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

 

 class Solution {
 public:
     vector<int> findSubstring(string S, vector<string> &L) {

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

         int wordLen=L[].size();

         map<string,int> wordCount;

         int i,j;
         for(i=;i<L.size();i++)  wordCount[L[i]]++;

         vector<int> result;
         map<string,int> counting;

         int count=;
         int start;

         for(i=;i<wordLen;i++)
         {
             count=;
             start=i;
             counting.clear();
             for(int j=i;j<S.length()-wordLen+;j=j+wordLen)
             {
                 string str=S.substr(j,wordLen);

                 if(wordCount.find(str)!=wordCount.end())
                 {
                     counting[str]++;
                     count++;
                     if(counting[str]>wordCount[str])
                     {
                         //更新start位于str第一次出现之后，更新counting，更新count
                         getNextIndex(start,str,counting,S,wordLen,count);
                     }
                 }
                 else
                 {
                     counting.clear();
                     start=j+wordLen;
                     count=;
                 }

                 if(count==L.size())
                 {
                     result.push_back(start);
                 }
             }
         }
         return result;
     }

     void getNextIndex(int &start,string str,map<string,int> &counting,string &S,int &wordLen,int &count)
     {
         for(int j=;;j++)
         {
             string tmpStr=S.substr(start+j*wordLen,wordLen);
             count--;
             counting[tmpStr]--;
             if(tmpStr==str)
             {
                 start=start+(j+)*wordLen;
                 break;
             }
         }

     }
 };