滑动窗口题集

最小覆盖子串
https://leetcode-cn.com/problems/minimum-window-substring/

class Solution {
    //原则：左开右闭
    public String minWindow(String s, String t) {
        //t的字典
        Map<Character,Integer> need = new HashMap<>();
        //窗口字典
        Map<Character,Integer> window = new HashMap<>();
        //初始化t的字典
        char[] arr = t.toCharArray();
        for(int i = 0;i < t.length();i++) {
            if(!need.containsKey(arr[i])) {
                need.put(arr[i],0);
            }
            need.replace(arr[i],need.get(arr[i]) + 1);
        }
        //初始化左右指针（用于控制窗口大小）
        int left = 0, right = 0;
        //窗口含t中字符的个数
        int valid = 0;
        // 记录最小覆盖子串的起始索引及长度
        int start = 0;
        int len = Integer.MAX_VALUE;
        //结束条件——s的长度
        while (right < s.length()) {
            // c 是将移入窗口的字符
            char c = s.charAt(right);
            // 右移窗口
            right++;
            // 进行窗口内数据的一系列更新
            if (need.containsKey(c)) {
                //更新窗口字典
                if(!window.containsKey(c)) {
                    window.put(c,0);
                }
                window.replace(c,window.get(c) + 1);
                //判断该字符数量是否已经满足条件
                if (window.get(c).equals(need.get(c))) {
                    valid++;
                }
            }

            // 判断左侧窗口是否要收缩(如果窗口中所有字符不管是数量还是种类都已经满足条件（t）了，则开始进行优化——缩小窗口)
            while (valid == need.size()) {
                // 在这里更新最小覆盖子串
                if (right - left < len) {
                    start = left;
                    len = right - left;
                }
                // d 是将移出窗口的字符
                char d = s.charAt(left);
                //收缩窗口
                left++;
                // 进行窗口内数据的一系列更新
                if (need.containsKey(d)) {
                    if (window.get(d).equals(need.get(d))) {
                        valid--;
                    }
                    window.replace(d,window.get(d) - 1);
                }                    
            }
        }
        // 返回最小覆盖子串
        return (len == Integer.MAX_VALUE) ?
            "" : s.substring(start, start + len);
    }
}

字符串的排列
https://leetcode-cn.com/problems/permutation-in-string/

class Solution {
    public boolean checkInclusion(String s1, String s2) {
        //窗口字典
        Map<Character,Integer> window = new HashMap<>();
        //s2字典
        Map<Character,Integer> need = new HashMap<>();
        //初始化s1字典
        char[] arr = s1.toCharArray();
        for(int i = 0;i < arr.length;i++) {
            if(!need.containsKey(arr[i])) {
                need.put(arr[i],0);
            }
            need.replace(arr[i],need.get(arr[i]) + 1);
        }
        //初始化窗边
        int left = 0;
        int right = 0;
        //窗口内有效数
        int vaild = 0;
        //最终结束条件：right滑到最后去了
        while(right < s2.length()) {
            //待加入窗口字符
            char c = s2.charAt(right);
            //如果遇到目标字符，更新窗口信息
            if(need.containsKey(c)) {
                //维护窗口字典
                if(!window.containsKey(c)) {
                    window.put(c,0);
                }
                window.replace(c,window.get(c) + 1);
                //判断该种字符数量是否已经满足条件
                if(window.get(c).equals(need.get(c))) {
                    vaild++;
                }
            }
            //右滑
            right++;
            //当窗口大小大于s1时就需要收缩了
            while(right - left >= s1.length()) {
                //当条件类型的字符和数量已经满足
                if(vaild == need.size()) {
                    return true;
                }
                //滑出的字符
                char d = s2.charAt(left);
                //收缩窗口
                left++;
                //更新窗口信息
                if(need.containsKey(d)) {
                    if(window.get(d).equals(need.get(d))) {
                        vaild--;
                    }
                    window.replace(d,window.get(d) - 1);
                }
            }
        }
        return false;
    }
}