LeetCode之串联所有单词的子串 --- 滑动窗口

https://leetcode.cn/problems/substring-with-concatenation-of-all-words/

题目描述

给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。

s 中的 串联子串 是指一个包含 words 中所有字符串以任意顺序排列连接起来的子串。

• 例如，如果 words = ["ab","cd","ef"]， 那么 "abcdef"， "abefcd"，"cdabef"， "cdefab"，"efabcd"， 和 "efcdab" 都是串联子串。 "acdbef" 不是串联子串，因为他不是任何 words 排列的连接。

返回所有串联子串在 s 中的开始索引。你可以以 任意顺序 返回答案。

示例 1：

输入：s = "barfoothefoobarman", words = ["foo","bar"]
输出：[0,9]
解释：因为 words.length == 2 同时 words[i].length == 3，连接的子字符串的长度必须为 6。
子串 "barfoo" 开始位置是 0。它是 words 中以 ["bar","foo"] 顺序排列的连接。
子串 "foobar" 开始位置是 9。它是 words 中以 ["foo","bar"] 顺序排列的连接。
输出顺序无关紧要。返回 [9,0] 也是可以的。

解题思路

这道题可以看做下面这种情况，将words中的每一个字符串看成一个字符，将 s 中每三个连续字符串看做成一个字符，然后在 s 中找words 的异位词

此时解题思路可参考以下链接LeetCode之找到字符串中所有字母异位词 -- 滑动窗口_jzhbz的博客-CSDN博客

 

有了上面的铺垫，可以看这道题的解法

1.使用滑动窗口求解

定义left right 指针，初始值都为-1

定义hash1，hash2两个哈希表，用于存放每三个连续字符组成的字符串出现的个数，hash1 用于s，hash2 用于words中

定义count，表示有效字符串的个数

滑动窗口的固定长度为words中的一个字符串的长度，窗口从左滑向右，因为 words 里面每个字符串长度不一定为1，所以滑动窗口要滑动的次数应该也是 words 中每个字符串的长度

 

2.right 和 left 一次移动3个下标，也就是words中一个字符串的长度

right移动前要先判断有效字符串的个数count：当hash1[tmp] <= hash2[tmp]，表示当前字符串是有效字符串，count++

 

 

3.之后继续移动right，移动过程中重复步骤2，直到窗口的长度等于words中所有字符之和，此时窗口长度已经固定。

然后判断当前count是否等于words的长度：如果相等，表示当前窗口符合题意，将left+1存入list

 

4.然后 right 和 left 同时向右移动，每次移动的长度为 words[0].length()

移动left时也要判断，当left扫过的字符串是有效字符时，count需要减1，并且对应hash1中的value也需要减1，如果value减到0时，从hash1中remove，直到right == s.length()

 

5.当right+words[0].length() > s.length()时 ，进行下一次的滑动窗口，重复2-4步，直到滑动窗口次数到达words中随意一个字符串的长度

 

代码

//串联所有单词的子串
public static List<Integer> findSubstring(String s, String[] words) {
    int left=-1,right=-1;
    int count = 0;//记录有效字符串
    List<Integer> list = new ArrayList<>();
    //hash表
    HashMap<String,Integer> hash1 = new HashMap<>();
    HashMap<String,Integer> hash2 = new HashMap<>();

    //每个字符串的长度
    int len = words[0].length();

    //现将words存入hash2中
    for (String a:words){
        if (hash2.containsKey(a)){
            int old = hash2.get(a);
            hash2.put(a,old+1);
        }else {
            hash2.put(a,1);
        }
    }

    //滑动窗口一共滑动多少次
    for(int i=-1;i<len-1;i++){
        //每滑动一次，left 和 right都有重置
        left = i;right=i;
        count = 0;
        hash1 = new HashMap<>();
        //开始一次的滑动窗口
        while (right+len < s.length() && right-left < len * words.length){
            //right一次走len格
            char[] tmp1 = new char[len]; // 暂时存储right扫过的字符
            for(int j = 0;j<len;j++){
                right++;
                tmp1[j] = s.charAt(right);
            }
            //right没扫过一个字符串，判断是否是有效字符
            String str1 = String.valueOf(tmp1);
            if (hash1.containsKey(str1)){ //如果存在str1
                int old = hash1.get(str1);
                hash1.put(str1,old+1);
            }else {
                hash1.put(str1,1); //不存在则加入
            }
            if (hash2.containsKey(str1) && hash1.get(str1)<=hash2.get(str1)){
                //如果hash2中有此key，并且hash1中的value 小于 等于hash2中的value
                count++;
            }
        }
        //判断是否符合条件
        if (count == words.length){
            list.add(left+1);
        }

        //窗口已经到达固定长度
        while (right+len < s.length()){
            //到固定长度后，right和left同时向右移动

            //right一次走len格
            char[] tmp1 = new char[len]; // 暂时存储right扫过的字符
            for(int j = 0;j<len;j++){
                right++;
                tmp1[j] = s.charAt(right);
            }
            //right没扫过一个字符串，判断是否是有效字符
            String str1 = String.valueOf(tmp1);
            if (hash1.containsKey(str1)){ //如果存在str1
                int old = hash1.get(str1);
                hash1.put(str1,old+1);
            }else {
                hash1.put(str1,1); //不存在则加入
            }
            if (hash2.containsKey(str1) && hash1.get(str1)<=hash2.get(str1)){
                //如果hash2中有此key，并且hash1中的value 小于 等于hash2中的value
                count++;
            }

            //left一次走len格
            char[] tmp2 = new char[len]; // 暂时存储right扫过的字符
            for(int j = 0;j<len;j++){
                left++;
                tmp2[j] = s.charAt(left);
            }
            //right没扫过一个字符串，判断是否是有效字符
            String str2 = String.valueOf(tmp2);
            if (hash2.containsKey(str2) && hash1.get(str2) <= hash2.get(str2)){
                //如果hash2中有此key，并且hash1中的value 小于 等于hash2中的value
                count--;
            }
            if (hash1.containsKey(str2)){ //如果存在str2
                int old = hash1.get(str2);
                hash1.put(str2,old-1);
            }
            if(hash1.containsKey(str2) && hash1.get(str2) == 0){
                hash1.remove(str2);
            }
            //判断是否符合条件
            if (count == words.length){
                list.add(left+1);
            }
        }
    }
    return list;
}