基础算法之滑动窗口--Java实现(下)--LeetCode题解:水果成篮-找到字符串中所有字母异位词-串联所有单词的子串-最小覆盖子串

这里是Thembefue

水果成篮

        题目解析

数组对应的元素表示水果的种类，假设1表示苹果，那么2只能是其他水果，不可能是苹果。

你带的篮子只能摘两种水果，但是数量不限，且得按顺序摘，到了这个果树就必须摘，不能跳过。

         算法讲解

· 根据题意，其本质就是获取一个最长的符合题意的子数组，这个题意就是这个子数组只能存在两种数字，比如0和1，1和2，2和4。

· 我们继续进行滑动窗口的套路。

· 首先是进窗口，这里我们创建一个哈希表和一个kinds（种类）变量，用来维护目前窗口中的某个种类水果的数量和窗口中水果的种类。

· 那么进窗口时，如果此时该种类的水果没有出现在篮子里，则kinds++，且该水果的数量固定增加。

· 判断kinds是否大于 2。

· 接下来就是出窗口，left在移动时，同时必须将窗口里该水果的种类的数量减到0为止，此时kinds才算是减小了一。

        编写代码

class Solution {
    public int totalFruit(int[] fruits) {
       int left = 0, right = 0;
       int[] hash = new int[fruits.length + 1];
       int len = 0;
       int kinds = 0; // 水果种类
       while (right < fruits.length) {
            // 进窗口
            if (hash[fruits[right]]++ == 0) kinds++;
            // 判断条件
            while (kinds > 2) {
                // 将元素移除哈希表，出窗口
                if (--hash[fruits[left++]] == 0) kinds--; 
            }
            len = Math.max(len, right - left + 1);
            right++;
        }
        return len;
    }
}

找到字符串中所有字母异位词

         题目解析

本题找出所有s中的p的异位词，异位词就是 => 字母异位词是通过重新排列不同单词或短语的字母而形成的单词或短语，并使用所有原字母一次。找到所有s中该异位词的初始下标索引

        算法讲解 

· 如果单纯地将p的异位词都枚举出来再去找的话，会非常麻烦，其实你会发现只要当前子串里的字符种类数量与p的字符种类数量相同就行，此时就是p的异位词。

· 利用这个思路，我们借助两个哈希表解决，进窗口，判断条件，出窗口，但在添加结果时，我们需要同时遍历两个哈希表，查看其字符种类数量是否相同。否则不能添加结果。

· 优化细节：

        1. 如果p的长度都大于s的长度的话，这样是s不可能是出现p的异位词的，直接返回即可。

        2. 我们会发现，如果每次都遍历两个哈希表的话，会大大增加时间复杂度。所以我们引入了一个变量（count），这个变量的含义就是统计窗口中 "有效字符" 的个数，何为 "有效字符" ? 有效字符决定不可能随着窗口的增大或缩小而变化，它是和 p 中的字符种类数量对应的。比如：此时 p的字符 'c' 的数量是1个，如果此时窗口中 s 的字符 'c' 的数量也是 1，那么此时窗口 'c'的字符就是一个有效字符，所以count++，如果此时窗口中 s 的字符 'c' 的数量是 2，就超过 p中的字符 'c' 的数量了，这时窗口的该字符 'c' 就不是有效字符，所以count不能++。同时，出窗口的逻辑也一样，出窗口的这个字符一定是有效字符才可以让 count--

        3. 有了这个优化，那么添加结果的条件就是，当count的数量等于p的长度时，就可以添加结果，此时窗口就是p的异位词。

        编写代码 

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> ret = new ArrayList<>();
        if (s.length() < p.length()) return ret;

        int[] hash1 = new int[26];
        int[] hash2 = new int[26];
        for (char ch: p.toCharArray()) hash1[ch - 'a']++;

        // 统计窗口中 “有效字符” 的个数
        int count = 0;
        for (int left = 0, right = 0; right < s.length(); right++) {
            char in = s.charAt(right);
            // 进窗口
            // 判断其是否为有效字符
            if (++hash2[in - 'a'] <= hash1[in - 'a']) count++;
            // 判断条件
            if ((right - left + 1) > p.length()) {
                char out = s.charAt(left);
                // 判断其是否为有效字符
                if (hash2[out - 'a']-- <= hash1[out - 'a']) count--;
                // 出窗口
                left++;
            }
            if (count == p.length()) ret.add(left);
        }
        return ret;
    }
}

串联所有单词的子串

        题目解析

 本题与上题类似，就是字符变成了字符串。有一点细节很重要 -> words中所有字符串长度相同。

        算法讲解

· 既然和上题类似的话，那么思路其实也就是差不多的，既然提到words中所有字符串长度相同，那么利用这一特点，我们可以把words数组中的每个字符串看出是字符，我们移动窗口时，也应该移动这般大小的距离，这样问题便又转化成了和上一题一样的解法。

· 优化细节：

        · 本题同样增加一个变量（count）用来维护 "有效子串" 的个数，其思路是一样的。

但是，本题不能不只进行一次滑动窗口，因为滑动窗口的初始点不同的话，所选取的整个子串是不一样的，因为它不是真正的字符。比如：以上述题目例子来看，如果初始选择 ‘b’作为开头，那么三个三个选，就是bar foo foo bar ...... ，如果初始选择 ‘a’ 作为开头，那么就是 arf ood oob ...所以本次滑动窗口得进行三次，也就是words中字符串的长度。

        编写代码 

class Solution {
    public List<Integer> findSubstring(String ss, String[] words) {
        List<Integer> ret = new ArrayList<>();
        Map<String, Integer> hash1 = new HashMap<>();
        Map<String, Integer> hash2 = new HashMap<>();

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

        for (String s: words) {
            hash1.put(s, hash1.getOrDefault(s, 0) + 1);
        }

        int left = 0, right = 0;
        // 窗口执行次数
        int i = 0;
        while (i < len) {
            left = right = i;
            hash2.clear();
            // count -> 记录 "有效子串" 的个数
            for (int count = 0; right < ss.length(); right += len) {
                if (right + len > ss.length()) break;
                // 进窗口
                String in = ss.substring(right, right + len);
                hash2.put(in, hash2.getOrDefault(in, 0) + 1);

                // 维护count
                if (hash2.get(in) <= hash1.getOrDefault(in, 0)) {
                    count++;
                }
                // 判断条件
                while ((right - left + 1) > wordsLen) {
                    if (left + len > ss.length()) break;
                    String out = ss.substring(left, left + len);
                    // 出窗口 维护count
                    if (hash2.get(out) <= hash1.getOrDefault(out, 0)) {
                        count--;
                    } 
                    hash2.put(out, hash2.get(out) - 1);
                    left += len; 
                }
                // 更新结果
                if (count == words.length) ret.add(left);
            }
            i++;
        }
        return ret;
    }
}

最小覆盖子串

        题目解析

所选取的子串中一定得包含 t 中所有字符 ，且返回最小的那个子串

        算法讲解 

同样借助两个哈希表，如果是这么顺着看过来的，其实思路和上两题都是差不多，没什么太大的差别，也是通过 count变量维护 “有效字符” 的个数。不过这里是求得最小的子串！

 

        编写代码 

class Solution {
    public String minWindow(String s, String t) {
        if (s.length() < t.length()) return "";
        String ans = s;
        Map<Character, Integer> hash1 = new HashMap<>();
        for (char ch: t.toCharArray()) hash1.put(ch, hash1.getOrDefault(ch, 0) + 1);

        Map<Character, Integer> hash2 = new HashMap<>();

        for (int left = 0, right = 0, count = 0; right < s.length(); right++) {
            char in = s.charAt(right);
            hash2.put(in, hash2.getOrDefault(in, 0) + 1);

            if (hash2.get(in) <= hash1.getOrDefault(in, 0)) count++;

            if ((right - left + 1) > t.length() + 1) {
                char out = s.charAt(left);
                if (hash2.get(out) <= hash1.getOrDefault(out, 0)) count--;
                hash2.put(out, hash2.get(out) - 1);
                left++;
            }

            if (count == t.length()) {
                if ((right - left + 1) > ans.length()) break;
                ans = s.substring(left, right + 1);
            }
        }
        return ans;
    }
}

好了，以上就是今天内容的全部讲解，如果有不懂的地方，随时私聊😘

我们下一章节见 -> 二分查找😁