LeetCode 30. 串联所有单词的子串 通俗易懂解法

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/substring-with-concatenation-of-all-words/

一.问题描述

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

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

示例 1：

输入：s = “barfoothefoobarman”, words = [“foo”,“bar”]
输出：[0,9]
解释：
从索引 0 和 9 开始的子串分别是 “barfoo” 和 “foobar” 。
输出的顺序不重要, [9,0] 也是有效答案。

二.解题思路分析与代码

方法一：朴素方法求解

1. 分析

对于求串联单词所有的子串，首先想到的暴力方法就是，每次都截取和words中所有单词拼接起来相同长度的串str，然后，开始比较当前str,是否是由words中的所有串拼接而成的，如果是，则记下当前的索引作为答案.

本题，由于单词的长度是一样的，所以我们可以将截取出来的str中截取出一段一段的单词，然后和words中比较是否相等。这里我们可以借用哈希表。

定义两个哈希表，一个是words的，另一个是将截取出来的字符串str中所截的一个一个等长的单词。

代码实现如下：

lass Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> findSubstring(String s, String[] words) {
        Map<String, Integer> map = new HashMap<>();
        int len = words.length, one_len = words[0].length(), s_len = s.length();
        int total_len = one_len * len;
        for(String word : words){
            map.put(word, map.getOrDefault(word,0) + 1);
        }
        // 开始的索引
        for(int i = 0; i < s_len - total_len + 1; i++){
            // 将和words中等长的字符串截取出来
            String s_tmp = s.substring(i, i + total_len);
            // 比较的map
            Map<String,Integer> tmp_map = new HashMap<>();
            for(int k = 0; k < total_len; k = k + one_len){
                // 截取单个单词
                String substr = s_tmp.substring(k,k + one_len);
                // 放入到tmp_map中
                tmp_map.put(substr, tmp_map.getOrDefault(substr,0) + 1);
            }
            // 比较是否是一样的,如果是一样的，加入到结果集中
            if(map.equals(tmp_map)) res.add(i);
        }
        return res;
    }
}

2.复杂度分析

由于遍历和比较都是线性的，所有时间复杂度是：O（N^2）。

方法二：滑动窗口

1. 分析

从第一种朴素的暴力解法的到，上述过程每次都要反复的遍历s,即每次都只能移动一个单词，后继续判断。所以，我们可以利用滑动窗口来优化这个过程。

此时，我们不在从每个s字符串的索引开始。由于words中的word都是等长的，所以将word看成是一个基本单元。每次开始索引，只需要遍历一个单词的长度，后当遍历完成后所截取的就会截取到第一种方法中的所有情况。具体看代码实现：

我们一直在s维护这所有单词长度总和的一个长度队列！

class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> findSubstring(String s, String[] words) {
        int one_word_len = words[0].length(), word_len = words.length;
        Map<String, Integer> map = new HashMap<>();
        for(String w: words){
            map.put(w, map.getOrDefault(w,0) + 1);
        }
        for(int i = 0; i < one_word_len; i++){
        // 定义一个count表征当前窗口的size
            int left = i, right = i,count = 0;
            // 定义一个窗口 
            Map<String,Integer> window = new HashMap<>();
            while(right <= s.length() - one_word_len){
                String w = s.substring(right, right + one_word_len);
                window.put(w, window.getOrDefault(w,0) + 1);
                // right移动
                right += one_word_len;
                count++;
                // 当前窗口左移操作
                while(window.getOrDefault(w,0) > map.getOrDefault(w,0)){
                    String tmp_w = s.substring(left, left + one_word_len);
                    window.put(tmp_w, window.getOrDefault(tmp_w, 0) - 1);
                    count--;
                    // left移动
                    left += one_word_len;
                }
                if( count == word_len) res.add(left);
            }
        }
        return res;
    }
}

2. 复杂度分析

时间复杂度：O(N ) ，

准确的来说，应该是O(N*M)``M是单个单词的长度,但是，M最大值只有5000，我们近视忽略。

方法三：滑动窗口优化

1.分析

发现，对于上述的滑动窗口方法，如果是在窗口中出现了一个words中从来没出现的单词，方法二还是会继续的，缓慢的移动窗口。所以，在优化方面，我们就可以在碰到一个在words中从来没出现过的单词时，整个窗口都跳过当前的单词.

按照当前的分析，其实优化的代码也很简单。 代码如下：

class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> findSubstring(String s, String[] words) {
        Map<String, Integer> map = new HashMap<>();
        int len = words.length, one_len = words[0].length(), s_len = s.length();
        int total_len = one_len * len;
        for(String word : words){
            map.put(word, map.getOrDefault(word,0) + 1);
        }
        // 开始的索引
        for(int i = 0; i < s_len - total_len + 1; i++){
            // 将和words中等长的字符串截取出来
            String s_tmp = s.substring(i, i + total_len);
            // 比较的map
            Map<String,Integer> tmp_map = new HashMap<>();
            for(int k = 0; k < total_len; k = k + one_len){
                // 截取单个单词
                String substr = s_tmp.substring(k,k + one_len);
                // 放入到tmp_map中
                tmp_map.put(substr, tmp_map.getOrDefault(substr,0) + 1);
            }
            // 比较是否是一样的
            if(map.equals(tmp_map)) res.add(i);
        }
        return res;
    }
}

2.复杂度分析

时间复杂度和方法二一样，都认为是O(N).

三. 总结

还有许多其他的方法解决这道题，本篇文章的思路较为简单。