[LeetCode] 30. Substring with Concatenation of All Words 解题思路 - Java

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 wordsexactly once and without any intervening characters.

For example, given:
s:

"barfoothefoobarman"

words:

["foo", "bar"]

You should return the indices:

[0,9]

.
(order does not matter).


问题：给定一个字符串 s 和 一列单词 words 。找出 s 中所有满足下面条件的全部子字符串的开始下标：要求子字符串恰好由 words 的所有单词拼接而成，每个单词仅对应地出现一次。

由于 words 里面单词是无序的，目标子字符串的成员单词也是无序的，所以，考虑用 Hashtable 作为数据存储。

需要充分利用的两个题目条件：

1. 所有单词等长

2. 目标子字符串是由单词连续无中断地连接而成

根据上面两个条件，可以将 s 全部分割为长度为 length 的子字符串，共有 length 种分法。length 种分法会覆盖全部需要找的子字符串。

对于每一种分割，可以将长度为 length 的子字符串视为不再分割的单元，利用滑动窗口算法(Slide Window Algorithm)，线性时间找到符合条件的目标子字符串，O(n/length) 复杂度，其中 n 为 s 的长度。一共有 length 种分发，则耗时 O(length * n/length) = O(n)。

算法实现思路：

将 s 全部分割为长度为 length 的连续子串的方法，一共有 length 种。

对于每一种 k (0 <= k < length， 表示开始分割的起始下标 ) 有：

　　以 k 为起始位置，长度为 length 子字符串即为一个待验证子串 subs

　　左右指针指向首个 subs

　　若右指针指向的 subs 是要找的 word， 并且已记录的次数小于需要找到的次数，则记录新找到一个 subs，右指针右移

　　若右指针指向的 subs 是要找的 word，并且已记录的次数等于需要找到的次数， 则将左指针当前单词从记录中排除，并左指针右移，重复此操作直到从记录中排除一个右指针当前的 subs。使得 [ subs 已记录的次数小于需要找到的次数 ]。

　　若右指针指向的 subs 不是要找的 word，则右指针右移，左指针指向右指针位置，并情况记录。

　　若已找到的记录（左右指针内元素）恰好等于需要找到全部 words ，则保存左指针所在位置，即为一个需要找的下标。然后，将左指针当前元素从记录中排除，左指针右移。

实现代码：

import java.util.Hashtable;
import java.util.LinkedList;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;

class Utility{

/**
* reset the value of matched result str_cnt_mch
*
* @param str_cnt_mch
*/
public static void resetHashtable(Hashtable<String, Integer> str_cnt_mch){
Set<Entry<String, Integer>> set = str_cnt_mch.entrySet();
for (Entry<String, Integer> s_c : set){
s_c.setValue(0);
}
}
}

public class Solution {

public List<Integer> findSubstring(String s, String[] words) {
List<Integer> res = new LinkedList<Integer>();

Hashtable<String, Integer> str_cnt = new Hashtable<String, Integer>();
Hashtable<String, Integer> str_cnt_mch = new Hashtable<String, Integer>();

for (String wrd : words) {
if (str_cnt.containsKey(wrd)) {
str_cnt.put(wrd, str_cnt.get(wrd) + 1);
} else {
str_cnt.put(wrd, 1);
}

str_cnt_mch.put(wrd, 0);
}

int length = words[0].length();

for (int k = 0; k < length; k++) {

int lft = k;
int rgh = k;

Utility.resetHashtable(str_cnt_mch);
int mchCnt = 0;

while (rgh + length <= s.length()) {

String subs = s.substring(rgh, rgh + length);

if (str_cnt.containsKey(subs)) {

if (str_cnt_mch.get(subs) < str_cnt.get(subs)) {

str_cnt_mch.put(subs, str_cnt_mch.get(subs) + 1);
mchCnt++;

rgh += length;

} else {
// the number of subs in str_cnt_mch is the same as that
// in str_cnt

while (true) {

String subsl = s.substring(lft, lft + length);

str_cnt_mch.put(subsl, str_cnt_mch.get(subsl) - 1);
mchCnt--;

lft +=length;

if (subsl.equals(subs)) {
break;
}
}
}
} else {
// subs is not a word in words
Utility.resetHashtable(str_cnt_mch);
mchCnt = 0;

rgh = rgh + length;
lft = rgh;
}

if (mchCnt == words.length){
res.add(lft);

String subsl = s.substring(lft, lft + length);
str_cnt_mch.put(subsl, str_cnt_mch.get(subsl) - 1);
mchCnt--;

lft = lft + length;
}
}
}

return res;
}
}

参考资料：

Substring with Concatenation of All Words -- LeetCode, Code_Ganker, CSDN