LeetCode 30

一、问题描述

Description:

You are given a string, s, and a list of words, words, that are all of the same length. Find all starting indices of substring(s) in s that is a concatenation of each word in words exactly once and without any intervening characters.

For example:

• s: "barfoothefoobarman"
• words: ["foo", "bar"]

You should return the indices: [0,9].
(order does not matter).

给定一个字符串 s 与一个单词集合 words。

假设 str 是由集合 words 中的所有单词拼接（无序且每个单词仅出现一次）而成的字符串，求 str 在字符串 s 中匹配到的所有起始位置。

二、解题报告

解法一：暴力枚举

枚举字符串 s 的每个起始位置 0≤i≤n−len ，判断从当前位置开始的子串部分能不能由集合 words 里面的单词拼接而成。

判断方法：从起始位置 i 开始时，依次判断接下来的每个单词是否在集合中，如果单词在集合中，就从集合中删除该单词。这里用一个 hash map 来保存单词，这样可以在O(1)时间内判断单词是否在集合中。

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        int word_len = words[0].size();
        int len = words.size()*word_len;
        int n = s.size();
        unordered_map<string, int> m;              // hash_map<单词,出现的次数>
        for(int i=0; i<words.size(); ++i)
        {
            if(m.count(words[i]) == 0)             // 注意count方法的使用
                m.insert(make_pair(words[i], 1));
            else
                ++m[words[i]];
        }

        vector<int> index;
        for(int i=0; i<=n-len; ++i)                // 枚举起始位置
        {
            if(isContain(s.substr(i,len), m, word_len))
                index.push_back(i);
        }
        return index;
    }

    /**
     * 判断子串s是否由集合words里面的单词拼接而成
     */
    bool isContain(string s, unordered_map<string,int> m, int word_len) {
        int i;
        for(i=0; i<s.size(); i+=word_len) {
            string subs = s.substr(i, word_len);
            unordered_map<string,int>::iterator it = m.find(subs);
            if(it!=m.end() && it->second>0)
                --(it->second);
            else
                break;
        }

        if(i==s.size())
            return true;
        else
            return false;
    }
};

假设 n 是字符串的长度，m 是所有单词拼接后的长度，则时间复杂度是 O(n∗m)。

解法二：滑动窗口

本解法的思路和《LeetCode 3 - Longest Substring Without Repeating Characters》差不多，都用了一种滑动窗口的方法。因为单词都是定长的，所以本质上和单个字符一样。

比如s = "a1b2c3a1d4"，words=["a1", "b2", "c3", "d4"]

窗口最开始为空：

• a1在集合中，加入窗口 【a1】b2c3a1d4

• b2在集合中，加入窗口 【a1b2】c3a1d4

• c3在集合中，加入窗口 【a1b2c3】a1d4

• a1在集合中，但前面a1已经出现了一次，达到了次数上限，不能再加入窗口。此时只需要把窗口向右移动一个单词：a1【b2c3a1】d4

• d4在集合中，加入窗口a1【b2c3a1d4】此时找到了一个匹配。

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        int word_len = words[0].size();
        int len = words.size()*word_len;
        int n = s.size();
        unordered_map<string, int> m;              // <单词,出现的次数>
        for(int i=0; i<words.size(); ++i)
        {
            if(m.count(words[i]) == 0)             // 注意count方法的使用
                m.insert(make_pair(words[i], 1));
            else
                ++m[words[i]];
        }

        vector<int> index;
        for(int i=0; i<word_len; ++i)
        {
            unordered_map<string, int> win;
            int left = i;                           // 窗口左边沿
            int count = 0;                          // 窗口中的单词数目
            for(int right=i; right<=n-word_len; right+=word_len)
            {
                string word = s.substr(right, word_len);
                if(m.find(word) != m.end())         // 在集合中
                {
                    if(win.find(word) == win.end()) // 不在窗口中，即添加
                        win[word] = 1;
                    else
                        ++win[word];                // 在窗口中

                    if(win[word] <= m[word])        // 还没出现相应的次数
                        ++count;
                    else  
                    {
                        // 单词在集合中，但是它已经在窗口中出现了相应的次数，不应该加入窗口
                        // 此时把窗口起始位置想左移动到，该单词第一次出现的位置的下一个单词位置
                        for(int k=left;  ; k+=word_len)
                        {
                            string temp = s.substr(k, word_len);
                            --win[temp];
                            if(temp == word)
                            {
                                left = k + word_len;
                                break;
                            }
                            --count;
                        }
                    }

                    if(count == words.size())
                        index.push_back(left);
                }
                else                                // 不在集合中，从窗口右侧重新开始
                {
                    left = right + word_len;
                    win.clear();
                    count = 0;
                }
            }
        }

        return index;
    }
};

此解法的时间复杂度是O(n∗k)，n 是字符串的长度，k 是单词的长度。

由于 k 是个常数，所以这是一个线性算法。[参考]

LeetCode答案源代码：https://github.com/SongLee24/LeetCode