C++算法：串聯所有單詞的子串 ---全排列（思路一）----map比較（思路二）

題目：

給定一個字符串 s 和一些長度相同的單詞 words。找出 s 中恰好可以由 words 中所有單詞串聯形成的子串的起始位置。
注意子串要與 words 中的單詞完全匹配，中間不能有其他字符，但不需要考慮 words 中單詞串聯的順序。

示例 1：

輸入：s = “barfoothefoobarman”,words = [“foo”,“bar”] 輸出：[0,9] 解釋：從索引 0 和 9 開始的子串分別是 “barfoor” 和 “foobar” 。輸出的順序不重要, [9,0] 也是有效答案。

示例 2：

輸入： s = “wordgoodgoodgoodbestword”, words = [“word”,“good”,“best”,“word”] 輸出：[]

思路一（只能通過大部分，少部分超時）：

首先將words的全排列，然後將每個排列都組成一個string放在一個vector(即ret_str)中然後將即ret_str中的元素一一在s串中循環尋找

思路二（通過率比前面的高，簡單）：

因爲單詞word的長度一樣,所以可以截取s子串做成map，與words做成的map相比較，相等則爲結果中的一個！！！
//map自動排序，並可去重,所以不能直接插入，得判斷是否存在，存在則值+1 例如：輸入"wordgoodgoodgoodbestword" 輸出 [“word”,“good”,“best”,“word”]

思路三:優化思路二

每次在構造sub_map時，先檢測是否在words_map中，不在則直接pass掉

思路一代碼：

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        
        //思路:首先將words的全排列的所有可能性放在一個vector(即ret_str)中然後將即ret_str中的元素一一在s串中循環尋找        
        
        vector<string> ret_str;  //返回拼接完成後的所有情況      
        string temp_str;       
        vector<int> ret_temp, ret;        
        int temp;
        
        //求出所有可能子串
        full_prem(0, words, temp_str, ret_str);
        
        //查找子串
        for(vector<string>::iterator iter = ret_str.begin(); iter < ret_str.end(); iter++)
        {
            temp = s.find(*iter);
            while(temp != -1)
            {
                ret_temp.push_back(temp);
                temp = s.find(*iter, temp+1);
            }    
        }
        
        //最後去重
        sort(ret_temp.begin(), ret_temp.end());
        for(temp = 0; temp < ret_temp.size(); temp++)
        {
            if((temp == 0) || (ret_temp[temp-1] != ret_temp[temp]))
                ret.push_back(ret_temp[temp]);
        }
        
        return ret;
    }
    
private:
    //前綴加後續
    void full_prem(int i, vector<string>& words, string& temp, vector<string> &ret_str)
    {
        if(i == words.size()-1)
        {
            temp += words[i];
            
            ret_str.push_back(temp);
        }
        
        else
        {
            for(int j = i; j < words.size(); j++)
            {
                int k = temp.length();
                swap(words[i], words[j]);
                temp += words[i];
                full_prem(i+1, words, temp, ret_str);
                swap(words[i], words[j]);
                temp.erase(k); //注意要抹去的從k到最後的所有元素！！！
            }
        }
    }
    
    void swap(string &str1, string &str2){
        string temp = str1;
        str1 = str2;
        str2 = temp;
    }
};

思路二代碼：

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        
        if(s.length() == 0 || words.size() == 0 || words[0].length() * words.size() > s.length())
            return {};
        
        vector<int> ret;
        
        map<string,int> words_map;
        
        int i,j;
        
        int words_len = words.size();
        
        int one_word_len = words[0].length();
        
        int all_words_len = one_word_len * (words.size());
        
        for(i = 0; i < words_len; i++)
             words_map[words[i]] += 1;
            
        for(i = 0; i < s.length() - all_words_len + 1; i++)
        {
            map<string,int> sub_map;
            for(j = 0; j < words_len; j++)
                sub_map[s.substr(i+j*one_word_len, one_word_len)] += 1;  //substr第二個參數是個數
            
            if( equal(words_map.begin(), words_map.end(), sub_map.begin(), sub_map.end()) )
                ret.push_back(i);
        }
        
        return ret;
    }
};

思路三代碼：

#if 1
//思路三:優化，每次在構造sub_map時，先檢測是否在words_map中，不在則直接pass掉
class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        
        if(s.length() == 0 || words.size() == 0 || words[0].length() * words.size() > s.length())
            return {};
        
        vector<int> ret;
        
        map<string,int> words_map;
        
        int i,j;
        
        int words_len = words.size();
        
        int one_word_len = words[0].length();
        
        int all_words_len = one_word_len * (words.size());
        
        for(i = 0; i < words_len; i++)
             words_map[words[i]] += 1;
            
        for(i = 0; i < s.length() - all_words_len + 1; i++)
        {
            map<string,int> sub_map;
            for(j = 0; j < words_len; j++)
            {
                string str_temp = s.substr(i+j*one_word_len, one_word_len);
                if(words_map.find(str_temp) == words_map.end()) //表明不在words中
                    goto conti;
                sub_map[str_temp] += 1;  //substr第二個參數是個數
            }
               
            if( equal(words_map.begin(), words_map.end(), sub_map.begin(), sub_map.end()) )
                ret.push_back(i);
            conti:  ;
        }
        
        return ret;
    }
};
#endif