【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()==0) return vector<int>();
       
        int wordLen=L[0].size();
       
        map<string,int> wordCount;
       
        int i,j;
        for(i=0;i<L.size();i++)  wordCount[L[i]]++;
       
       
        vector<int> result;
        map<string,int> counting;
       
        for(i=0;i<(int)S.length()-wordLen*L.size()+1;i++)
        {
            counting.clear();
            for(j=0;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()==0) return vector<int>();
       
        int wordLen=L[0].size();
       
        map<string,int> wordCount;
       
        int i,j;
        for(i=0;i<L.size();i++)  wordCount[L[i]]++;
       
       
        vector<int> result;
        map<string,int> counting;
       
       
        int count=0;
        int start;
       
        for(i=0;i<wordLen;i++)
        {
            count=0;
            start=i;
            counting.clear();
            for(int j=i;j<S.length()-wordLen+1;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=0;
                }
               
                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=0;;j++)
        {
            string tmpStr=S.substr(start+j*wordLen,wordLen);
            count--;
            counting[tmpStr]--;
            if(tmpStr==str)
            {
                start=start+(j+1)*wordLen;
                break;
            }
        }
       
    }
};