LeetCode：串联所有单词的字串

题目：

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

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

示例 1：

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

输入：
  s = "wordgoodgoodgoodbestword",
  words = ["word","good","best","word"]
输出：[]

我的答案：

想法比较简单，就是一点一点直接比对，一开始没有加

if(s.length()<len*words.length)

这句判断，导致超时，没有通过，加了之后虽然过了，但是效率也低，代码如下：

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {

        List<Integer> list = new ArrayList<Integer>();
        if(s==null||words==null||s.length()==0||words.length==0){
            return list;
        }

        int len = words[0].length();
        for(int i =0;i<s.length();i++){
            if(s.length()<len*words.length){
                return list;
            }
            ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(words));
            int j=i;
            while(j+len<=s.length()){
              
                String s1 = s.substring(j,j+len);
                if(arrayList.contains(s1)){
                    j = j+len;
                    arrayList.remove(s1);
                }else{
                    break;
                }
                if(arrayList.size()==0){
                    list.add(i);
                    break;
                }
            }

        }
        return list;
    }
}

题解：

别人的代码：https://blog.csdn.net/liuzuoping/article/details/103763572 

看完别人的代码自己又敲了一下：

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> res = new ArrayList<>();
        if (s == null || s.length() == 0 || words == null || words.length == 0) return res;
        HashMap<String,Integer> map = new HashMap<String,Integer>();
        //将所有单词加入hashmap并计数
        for(String word:words){
            map.put(word,map.getOrDefault(word,0)+1);
        }

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

        for(int i=0;i<len;i++){////错位循环
            HashMap<String,Integer> temp = new HashMap<String,Integer>();
            int left = i;
            int right = i;
            int count = 0;
            while(right+len<=s.length()){
                String s1 = s.substring(right,right+len);
                right = right + len;
                //map中不含w，窗口右移一个单词的长度
                if(!map.containsKey(s1)){
                    left = right;
                    count = 0;
                    temp.clear();
                }else{
                    temp.put(s1,temp.getOrDefault(s1,0)+1);
                    count++;
                    //当w的匹配次数多于words数组中的个数时
                    while(temp.getOrDefault(s1,0)>map.getOrDefault(s1,0)){
                        count--;
                        String s2 = s.substring(left,left+len);
                        temp.put(s2,temp.getOrDefault(s2,0)-1);
                        left = left + len;
                    }
                }
                //当匹配成功单词数等于总单词数
                if(count==words.length){
                    res.add(left);
                }
            }
        }
        return res;
    }
}

总结：

我的代码的结果：

别人优化的结果;

别人的代码果然效率很高，简直快了近两个数量级……

重点：滑动窗口，hashmap的用法