【算法优选】 滑动窗口专题——贰

文章目录

  • 前言
  • [水果成篮](https://leetcode.cn/problems/fruit-into-baskets/submissions/)
    • 题目描述
    • 算法思路:
    • 算法流程:
    • 代码实现:
  • [找到字符串中所有字母异位词](https://leetcode.cn/problems/find-all-anagrams-in-a-string/)
    • 题目描述
    • 算法思路:
    • 代码实现:
  • [串联所有单词的子串](https://leetcode.cn/problems/substring-with-concatenation-of-all-words/)
    • 题目描述
    • 算法思路:
    • 代码实现:
  • [最小覆盖子串](https://leetcode.cn/problems/minimum-window-substring/)
    • 算法思路:
    • 算法流程:
    • 代码实现:
  • ⭕总结

前言

基本概念

滑动窗口是一种基于双指针的一种思想,两个指针指向的元素之间形成一个窗口。

分类:窗口有两类,一种是固定大小类的窗口,一类是大小动态变化的窗口。

水果成篮

题目描述

你正在探访一家农场,农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示,其中 fruits[i] 是第 i 棵树上的水果 种类 。

你想要尽可能多地收集水果。然而,农场的主人设定了一些严格的规矩,你必须按照要求采摘水果:

你只有 两个 篮子,并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。你可以选择任意一棵树开始采摘,你必须从 每棵 树(包括开始采摘的树)上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次,你将会向右移动到下一棵树,并继续采摘。一旦你走到某棵树前,但水果不符合篮子的水果类型,那么就必须停止采摘。给你一个整数数组 fruits ,返回你可以收集的水果的 最大 目。

  • 示例 1:
    输入:fruits = [1,2,1]
    输出:3
    解释:可以采摘全部 3 棵树。

  • 示例 2:
    输入:fruits = [0,1,2,2]
    输出:3
    解释:可以采摘 [1,2,2] 这三棵树。
    如果从第一棵树开始采摘,则只能采摘 [0,1] 这两棵树。

  • 示例 3:
    输入:fruits = [1,2,3,2,2]
    输出:4
    解释:可以采摘 [2,3,2,2] 这四棵树。
    如果从第一棵树开始采摘,则只能采摘 [1,2] 这两棵树。

  • 示例 4:
    输入:fruits = [3,3,3,1,2,1,1,2,3,3,4]
    输出:5
    解释:可以采摘 [1,2,1,1,2] 这五棵树。

class Solution {
    public int totalFruit(int[] fruits) {

    }
}

算法思路:

研究的对象是⼀段连续的区间,可以使⽤「滑动窗⼝」思想来解决问题。

让滑动窗⼝满⾜:窗⼝内⽔果的种类只有两种。

做法:右端⽔果进⼊窗⼝的时候,⽤哈希表统计这个⽔果的频次。这个⽔果进来后,判断哈希表的
⼤⼩:

  • 如果⼤⼩超过2:说明窗⼝内⽔果种类超过了两种。那么就从左侧开始依次将⽔果划出窗⼝,直到哈希表的⼤⼩⼩于等于2,然后更新结果;

  • 如果没有超过2,说明当前窗⼝内⽔果的种类不超过两种,直接更新结果ret

算法流程:

  1. 初始化哈希表hash来统计窗⼝内⽔果的种类和数量;

  2. 初始化变量:左右指针left=0,right=0,记录结果的变量ret=0;

  3. 当right⼩于数组⼤⼩的时候,⼀直执⾏下列循环:

  • 将当前⽔果放⼊哈希表中;
  • 判断当前⽔果进来后,哈希表的⼤⼩:
    如果超过2: ◦ 将左侧元素滑出窗⼝,并且在哈希表中将该元素的频次减⼀;
    如果这个元素的频次减⼀之后变成了0,就把该元素从哈希表中删除;
    重复上述两个过程,直到哈希表中的⼤⼩不超过2;
  • 更新结果ret; iv. right++,让下⼀个元素进⼊窗⼝;
  1. 循环结束后,ret存的就是最终结果

代码实现:

使用容器版本:

class Solution {
    public int totalFruit(int[] f) {
        Map<Integer, Integer> hash = new HashMap<Integer, Integer>(); // 统计窗⼝内⽔果的种类
        int ret = 0;
        for(int left = 0, right = 0; right < f.length; right++) {
            int in = f[right];
            hash.put(in, hash.getOrDefault(in, 0) + 1); // 进窗⼝
            while(hash.size() > 2) {
                int out = f[left];
                hash.put(out, hash.get(out) - 1); // 出窗⼝
                if(hash.get(out) == 0) {
                    hash.remove(out);
                }
                left++;
            }
            // 更新结果
            ret = Math.max(ret, right - left + 1);
        }
        return ret;
    }
}

⽤数组模拟哈希表:

class Solution {
    public int totalFruit(int[] f) {
        int n = f.length;
        int[] hash = new int[n + 1]; // 统计窗⼝内⽔果的种类
        int ret = 0;
        for(int left = 0, right = 0, kinds = 0; right < n; right++) {
            int in = f[right];
            if(hash[in] == 0) kinds++; // 维护⽔果种类
            hash[in]++; // 进窗⼝
            while(kinds > 2) // 判断
            {
                int out = f[left];
                hash[out]--; // 出窗⼝
                if(hash[out] == 0) {
                    kinds--;
                }
                left++;
            }
// 更新结果
            ret = Math.max(ret, right - left + 1);
        }
        return ret;
    }
}

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

题目描述

给定两个字符串 s 和 p,找到 s 中所有 p 的 异位词 的子串,返回这些子串的起始索引。不考虑答案输出的顺序。

异位词 指由相同字母重排列形成的字符串(包括相同的字符串)。

  • 示例 1:
    输入: s = “cbaebabacd”, p = “abc”
    输出: [0,6]
    解释:
    起始索引等于 0 的子串是 “cba”, 它是 “abc” 的异位词。
    起始索引等于 6 的子串是 “bac”, 它是 “abc” 的异位词。

  • 示例 2:
    输入: s = “abab”, p = “ab”
    输出: [0,1,2]
    解释:
    起始索引等于 0 的子串是 “ab”, 它是 “ab” 的异位词。
    起始索引等于 1 的子串是 “ba”, 它是 “ab” 的异位词。
    起始索引等于 2 的子串是 “ab”, 它是 “ab” 的异位词。

算法思路:

  • 因为字符串 p 的异位词的⻓度⼀定与字符串 p 的⻓度相同,所以我们可以在字符串 s 中构造⼀个⻓度为与字符串 p 的⻓度相同的滑动窗⼝,并在滑动中维护窗⼝中每种字⺟的数量;

  • 当窗⼝中每种字⺟的数量与字符串 p 中每种字⺟的数量相同时,则说明当前窗⼝为字符串 p 的异位词;

  • 因此可以⽤两个⼤⼩为 26 的数组来模拟哈希表,⼀个来保存 s 中的⼦串每个字符出现的个数,另⼀个来保存 p 中每⼀个字符出现的个数。这样就能判断两个串是否是异位词。

代码实现:

   public List<Integer> findAnagrams(String ss, String pp) {
        List<Integer> ret = new ArrayList<Integer>();
        char[] s = ss.toCharArray();
        char[] p = pp.toCharArray();
        int[] hash1 = new int[26]; // 统计字符串 p 中每⼀个字符出现的个数
        for (char ch : p) {
            hash1[ch - 'a']++;
        }
        int[] hash2 = new int[26]; // 统计窗⼝中每⼀个字符出现的个数
        int m = p.length;
        for (int left = 0, right = 0, count = 0; right < s.length; right++) {
            char in = s[right];
            // 进窗⼝ + 维护 count
            if (++hash2[in - 'a'] <= hash1[in - 'a']) {
                count++;
            }
            // 判断
            if (right - left + 1 > m) {
                char out = s[left++];
                // 出窗⼝ + 维护 count
                if (hash2[out - 'a']-- <= hash1[out - 'a']) {
                    count--;

                }
            }
            // 更新结果
            if (count == m) {
                ret.add(left);
            }
        }
        return ret;
    }

串联所有单词的子串

题目描述

给定一个字符串 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] 也是可以的。

  • 示例 2:
    输入:s = “wordgoodgoodgoodbestword”, words = [“word”,“good”,“best”,“word”]
    输出:[]
    解释:因为 words.length == 4 并且 words[i].length == 4,所以串联子串的长度必须为 16。
    s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接。
    所以我们返回一个空数组。

  • 示例 3:
    输入:s = “barfoofoobarthefoobarman”, words = [“bar”,“foo”,“the”]
    输出:[6,9,12]
    解释:因为 words.length == 3 并且 words[i].length == 3,所以串联子串的长度必须为 9。
    子串 “foobarthe” 开始位置是 6。它是 words 中以 [“foo”,“bar”,“the”] 顺序排列的连接。
    子串 “barthefoo” 开始位置是 9。它是 words 中以 [“bar”,“the”,“foo”] 顺序排列的连接。
    子串 “thefoobar” 开始位置是 12。它是 words 中以 [“the”,“foo”,“bar”] 顺序排列的连接。

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

    }
}

算法思路:

如果我们把每⼀个单词看成⼀个⼀个字⺟,问题就变成了找到找到字符串中所有字母异位词。

⽆⾮就是之前处理的对象是⼀个⼀个的字符,我们这⾥处理的对象是⼀个⼀个的单词。

这里就不多做赘述了

代码实现:

class Solution {
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> ret = new ArrayList<Integer>();
        // 保存字典中所有单词的频次
        Map<String, Integer> hash1 = new HashMap<String, Integer>();
        for (String str : words) {
            hash1.put(str, hash1.getOrDefault(str, 0) + 1);
        }
        int len = words[0].length(), m = words.length;
        // 执⾏次数
        for (int i = 0; i < len; i++) {
            // 保存窗⼝内所有单词的频次
            Map<String, Integer> hash2 = new HashMap<String, Integer>();
            for (int left = i, right = i, count = 0; right + len <= s.length(); right += len) {
                // 进窗⼝ + 维护 count
                String in = s.substring(right, right + len);
                hash2.put(in, hash2.getOrDefault(in, 0) + 1);
                if (hash2.get(in) <= hash1.getOrDefault(in, 0)) {
                    count++;
                }
                // 判断
                if (right - left + 1 > len * m) {
                    // 出窗⼝ + 维护 count
                    String out = s.substring(left, left + len);
                    if (hash2.get(out) <= hash1.getOrDefault(out, 0)) {
                        count--;
                    }
                    hash2.put(out, hash2.get(out) - 1);
                    left += len;
                }
                // 更新结果
                if (count == m) {
                    ret.add(left);
                }
            }
        }
        return ret;
    }
}

最小覆盖子串

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串,则返回空字符串 “” 。

注意:
对于 t 中重复字符,我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
如果 s 中存在这样的子串,我们保证它是唯一的答案。

  • 示例 1:
    输入:s = “ADOBECODEBANC”, t = “ABC”
    输出:“BANC”
    解释:最小覆盖子串 “BANC” 包含来自字符串 t 的 ‘A’、‘B’ 和 ‘C’。

  • 示例 2:
    输入:s = “a”, t = “a”
    输出:“a”
    解释:整个字符串 s 是最小覆盖子串。

  • 示例 3:
    输入: s = “a”, t = “aa”
    输出: “”
    解释: t 中两个字符 ‘a’ 均应包含在 s 的子串中,
    因此没有符合条件的子字符串,返回空字符串。

class Solution {
    public String minWindow(String s, String t) {

    }
}

算法思路:

  • 研究对象是连续的区间,因此可以尝试使⽤滑动窗⼝的思想来解决。
  • 如何判断当前窗⼝内的所有字符是符合要求的呢?
    我们可以使⽤两个哈希表,其中⼀个将⽬标串的信息统计起来,另⼀个哈希表动态的维护窗⼝内字符串的信息。
    当动态哈希表中包含⽬标串中所有的字符,并且对应的个数都不⼩于⽬标串的哈希表中各个字符的个数,那么当前的窗⼝就是⼀种可⾏的⽅案

算法流程:

  1. 定义两个全局的哈希表: 1 号哈希表 hash1 ⽤来记录⼦串的信息, 2 号哈希表 hash2 ⽤来记录⽬标串 t 的信息;
  2. 实现⼀个接⼝函数,判断当前窗⼝是否满⾜要求:
    遍历两个哈希表中对应位置的元素:
    如果 t 中某个字符的数量⼤于窗⼝中字符的数量,也就是 2 号哈希表某个位置⼤于1 号哈希表。说明不匹配,返回 false ;
    如果全都匹配,返回 true

主函数中:

  1. 先将 t 的信息放⼊ 2 号哈希表中;
  2. 初始化⼀些变量:左右指针: left = 0,right = 0 ;⽬标⼦串的⻓度: len = INT_MAX ;⽬标⼦串的起始位置: retleft ;(通过⽬标⼦串的起始位置和⻓度,我们就能找到结果)
  3. 当 right ⼩于字符串 s 的⻓度时,⼀直下列循环:
    i. 将当前遍历到的元素扔进 1 号哈希表中;
    ii. 检测当前窗⼝是否满⾜条件:
  • 如果满⾜条件:
    ◦ 判断当前窗⼝是否变⼩。如果变⼩:更新⻓度len ,以及字符串的起始位置 retleft ;
    ◦ 判断完毕后,将左侧元素滑出窗⼝,顺便更新1 号哈希表;

重复上⾯两个过程,直到窗⼝不满⾜条件;
iii. right++ ,遍历下⼀个元素;

  1. 判断 len 的⻓度是否等于 INT_MAX :
    i. 如果相等,说明没有匹配,返回空串;
    ii. 如果不想等,说明匹配,返回 s 中从 retleft 位置往后 len ⻓度的字符串

代码实现:

class Solution {
    public String minWindow(String ss, String tt) {
        char[] s = ss.toCharArray();
        char[] t = tt.toCharArray();
        int[] hash1 = new int[128]; // 统计字符串 t 中每⼀个字符的频次
        int kinds = 0; // 统计有效字符有多少种
        for(char ch : t) {
            if(hash1[ch]++ == 0) {
                kinds++;
            }
        }
        int[] hash2 = new int[128]; // 统计窗⼝内每个字符的频次
        int minlen = Integer.MAX_VALUE;
        int begin = -1;
        for(int left = 0, right = 0, count = 0; right < s.length; right++) {
            char in = s[right];
            if(++hash2[in] == hash1[in]) {
                count++; // 进窗⼝ + 维护 count
            }
            // 判断条件
            while(count == kinds) {
                // 更新结果
                if(right - left + 1 < minlen) {
                    minlen = right - left + 1;
                    begin = left;
                }
                char out = s[left++];
                // 出窗⼝ + 维护 count
                if(hash2[out]-- == hash1[out]) {
                    count--;
                }
            }
        }
        if(begin == -1) {
            return new String();
        } else {
            return ss.substring(begin, begin + minlen);
        }
    }
}

⭕总结

关于《【算法优选】 滑动窗口专题——贰》就讲解到这儿,感谢大家的支持,欢迎各位留言交流以及批评指正,如果文章对您有帮助或者觉得作者写的还不错可以点一下关注,点赞,收藏支持一下!一起加油

你可能感兴趣的:(算法优选,算法,java,滑动窗口)