[LeetCode] 30. Substring with Concatenation of All Words

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

You can return the answer in any order.

Example 1:

Input: s = "barfoothefoobarman", words = ["foo","bar"]
Output: [0,9]
Explanation: Substrings starting at index 0 and 9 are "barfoo" and "foobar" respectively.
The output order does not matter, returning [9,0] is fine too.

Example 2:

Input: s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
Output: []

Example 3:

Input: s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
Output: [6,9,12]

Constraints:

• 1 <= s.length <= 104
• s consists of lower-case English letters.
• 1 <= words.length <= 5000
• 1 <= words[i].length <= 30
• words[i] consists of lower-case English letters.

串联所有单词的子串。

给定一个字符串 s 和一些 长度相同 的单词 words 。找出 s 中恰好可以由 words 中所有单词串联形成的子串的起始位置。

注意子串要与 words 中的单词完全匹配，中间不能有其他字符 ，但不需要考虑 words 中单词串联的顺序。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/substring-with-concatenation-of-all-words
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路是滑动窗口（sliding window），但是没法套用之前的模板。注意这个题给的条件，words 里面每个单词是等长的，这个条件会使得这个题目简单些。首先创建一个 hashmap 把 words 里面的所有单词和出现次数都记录下来。接着开始遍历字符串 s，每移动一个字符，就要复制一次之前的 hashmap，因为这里的思路是需要看从起点 i 开始的 substring 是否包含 hashmap 里面存的所有单词（及其次数）。当找到一个子串的时候，需要判断这个子串是否还在 hashmap 里，如果这个子串不存在或者次数已经为 0 了则 break，说明以当前 i 为起点的子串无效；如果这个子串存在于 hashmap 则--，同时 words 的个数 K 也要--，这样当 K == 0 的时候就可以知道所有单词都遍历完了，可以把这个子串的起始位置 i 加入结果集了。

时间O(n^2)

空间O(n)

Java实现一 - 超时

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> res = new ArrayList<>();
        // corner case
        if (s == null || words == null || words.length == 0) {
            return res;
        }

        // normal case
        // 单词个数
        int n = words.length;
        // 单词长度
        int m = words[0].length();
        HashMap<String, Integer> map = new HashMap<>();
        for (String str : words) {
            map.put(str, map.getOrDefault(str, 0) + 1);
        }

        for (int i = 0; i <= s.length() - n * m; i++) {
            HashMap<String, Integer> copy = new HashMap<>(map);
            int count = n;
            int j = i;
            while (count > 0) {
                String str = s.substring(j, j + m);
                if (!copy.containsKey(str) || copy.get(str) < 1) {
                    break;
                }
                copy.put(str, copy.get(str) - 1);
                count--;
                j += m;
            }
            if (count == 0) {
                res.add(i);
            }
        }
        return res;
    }
}

 

Java实现二，可以通过。无需像实现一那样一步一步地看 input 字符串。

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> res = new ArrayList<>();
        int wordLen = words[0].length();
        int wordCount = words.length;
        int n = s.length();
        int m = wordLen * wordCount;

        HashMap<String, Integer> map = new HashMap<>();
        for (String word : words) {
            map.put(word, map.getOrDefault(word, 0) + 1);
        }

        for (int i = 0; i < wordLen; i++) {
            int left = i;
            int right = i;
            HashMap<String, Integer> wordsFound = new HashMap<>();
            int count = 0;

            while (right + wordLen <= s.length()) {
                String word = s.substring(right, right + wordLen);
                right += wordLen;
                if (map.containsKey(word)) {
                    wordsFound.put(word, wordsFound.getOrDefault(word, 0) + 1);
                    count++;

                    // 如果当前单词数量超过预期数量，则移动左指针
                    while (wordsFound.get(word) > map.get(word)) {
                        String leftWord = s.substring(left, left + wordLen);
                        wordsFound.put(leftWord, wordsFound.get(leftWord) - 1);
                        count--;
                        left += wordLen;
                    }
                    if (count == wordCount) {
                        res.add(left);
                    }
                } else {
                    wordsFound.clear();
                    count = 0;
                    left = right;
                }
            }
        }
        return res;
    }
}

 

JavaScript实现

/**
 * @param {string} s
 * @param {string[]} words
 * @return {number[]}
 */
var findSubstring = function (s, words) {
    // corner case
    if (s == null || words == null || words.length == 0) {
        return [];
    }

    // normal case
    let res = [];
    let n = words.length;
    let m = words[0].length;
    let map = {};
    for (let str of words) {
        map[str] = (map[str] || 0) + 1;
    }

    for (let i = 0; i <= s.length - n * m; i++) {
        let copy = { ...map };
        let k = n;
        let j = i;
        while (k > 0) {
            let str = s.substring(j, j + m);
            if (!copy[str] || copy[str] < 1) {
                break;
            }
            copy[str]--;
            k--;
            j += m;
        }
        if (k == 0) {
            res.push(i);
        }
    }
    return res;
};

 

sliding window相关题目

LeetCode 题目总结