一、问题描述
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