Leetcode 30. 串联所有单词的子串

题目

给定一个字符串 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”]
输出：[]

解答

解法一：暴力

使用两个 Map 可以不用再考虑字符串的顺序问题。

暴力的思想：

1. 将所有的 words 单词放入 wordsMap 中。
2. 然后每次都在 s 串中取到 words.length * wordLen 的长度的子串。
3. 将子串存入 curMap 并计数，然后比较 curMap 和 wordsMap 是否相等。
4. 若相等，说明正确，加入结果集。否则跳过当前位置。
5. 变量自增，继续循环。

复杂度：O(n ^ 2) 的时间，O(n) 的空间

代码

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        if(s == null || s.length() == 0) return new ArrayList<>();
        if(words == null || words.length == 0) return new ArrayList<>();
        
        int wordLen = words[0].length();
        int wordsLen = words.length * wordLen;
        Map<String, Integer> wordsMap = new HashMap<>();
        for(String word : words) {
            wordsMap.put(word, wordsMap.getOrDefault(word, 0) + 1);
        }
        
        List<Integer> res = new ArrayList<>();
        for(int i = 0; i + wordsLen <= s.length(); i ++) {
            Map<String, Integer> curMap = new HashMap<>();
            for(int j = 0; j < wordsLen; j += wordLen) {
                String word = s.substring(i + j, i + j + wordLen);
                if(!wordsMap.containsKey(word)) break;
                curMap.put(word, curMap.getOrDefault(word, 0) + 1);
            }
            
            if(curMap.size() != wordsMap.size()) continue;
            
            boolean isEquals = true;
            for(String key : wordsMap.keySet()) {
                if(!wordsMap.get(key).equals(curMap.get(key))) {
                    isEquals = false;
                    break;
                }
            }
            
            if(isEquals) res.add(i); 
        }
        
        return res;
    }
}

结果

解法二：滑动窗口

从第 i （i < wordLen）个索引位置起始的窗口不断向前滑动，每次跳过一个或多个单词。

虽然从不同位置起始的窗口是不一样的，但是窗口的个数却是有限的，总共只有 words.length 个窗口。

每个窗口滑动过程中共分为三种情况：

1. 完全匹配：保存进结果集，去掉第一个单词，继续滑动即可。
2. 当前单词在 wordsMap 里不存在：直接跳到当前单词位置的下一个。
3. 当前单词的数量比 wordsMap 中的多：循环去掉多余的单词。

详情请看 Leetcode 大神的题解（图文并茂，很容易理解）：Leetcode 题解

复杂度：O(n) 的时间，O(n) 的空间

代码

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        if(s == null || s.length() == 0) return new ArrayList<>();
        if(words == null || words.length == 0) return new ArrayList<>();
        
        int wordLen = words[0].length();
        int wordsLen = words.length * wordLen;
        Map<String, Integer> wordsMap = new HashMap<>();
        for(String word : words) {
            wordsMap.put(word, wordsMap.getOrDefault(word, 0) + 1);
        }
        
        List<Integer> res = new ArrayList<>();
        for(int i = 0; i < wordLen; i ++) {
            Map<String, Integer> curMap = new HashMap<>();
            int num = 0;
            int j = i;
            while (j  + wordsLen <= s.length()) {
                while(num < words.length) {
                    String word = s.substring(j + num * wordLen, j + (num + 1) * wordLen);
                    if(!wordsMap.containsKey(word)) {
                        curMap.clear();
                        j += (num + 1) * wordLen;
                        num = 0;
                        break;
                    }
                    
                    curMap.put(word, curMap.getOrDefault(word, 0) + 1);
                    num ++;
                    
                    if(wordsMap.get(word) < curMap.get(word)) {
                        while(wordsMap.get(word) < curMap.get(word)) {
                            String first = s.substring(j, j + wordLen);
                            curMap.put(first, curMap.get(first) - 1);
                            j += wordLen;
                            num --;
                        }
                        
                        break;
                    }
                    
                }
                
                if(num == words.length) {
                    res.add(j);
                    
                    String first = s.substring(j, j + wordLen);
                    curMap.put(first, curMap.get(first) - 1);
                    num --;
                    j += wordLen;
                }
            }
        }
        
        return res;
    }
}

结果