【LeetCode-76】76.最小覆盖子串（滑动窗口+哈希+双指针）

最小覆盖子串

题目描述

给你一个字符串 S、一个字符串 T，请在字符串 S 里面找出：包含 T 所有字符的最小子串。

示例：

输入: S = “ADOBECODEBANC”, T = “ABC”
输出: “BANC”
说明：

如果 S 中不存这样的子串，则返回空字符串 “”。
如果 S 中存在这样的子串，我们保证它是唯一的答案。

滑动窗口+哈希+双指针法

class Solution {
    public String minWindow(String s, String t) {
        if(t.length() == 0 || s.length() < t.length()) {
            return "";
        }
        //定义t的各个元素hash存储
        Map<Character,Integer> need = new HashMap<>();
        //窗口hash存储
        Map<Character,Integer> window = new HashMap<>();
        
        for(int i = 0; i < t.length(); i++) {
            char c = t.charAt(i);
            need.put(c,need.getOrDefault(c, 0) + 1);
            
        }

        int left = 0, right = 0;
        int valid = 0;
         // 记录最小覆盖子串的起始索引及长度
        int start = 0, len = Integer.MAX_VALUE;
        
        while(right < s.length()) {
            // c 是将移入窗口的字符
            char c = s.charAt(right);
            //右移窗口
            right++;
            // 进行窗口内数据的一系列更新
            if(need.containsKey(c)) {
                window.put(c,window.getOrDefault(c, 0) + 1);
                //注意：Integer要比较的话必须用.equals方法
                //或者window.get(c).intValue
                if(need.get(c).equals(window.get(c)) ) {
                    valid++;
                }
            }
            
            // 判断左侧窗口是否要收缩
            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.put(d,window.get(d) - 1);
                }
            }
        }
        return len == Integer.MAX_VALUE ? "" : s.substring(start,start + len);
    }
}

分析：

需要注意的是，当我们发现某个字符在 window 的数量满足了 need 的需要，就要更新 valid，表示有一个字符已经满足要求。而且，你能发现，两次对窗口内数据的更新操作是完全对称的。

当 valid == need.size() 时，说明 T 中所有字符已经被覆盖，已经得到一个可行的覆盖子串，现在应该开始收缩窗口了，以便得到「最小覆盖子串」。

移动 left 收缩窗口时，窗口内的字符都是可行解，所以应该在收缩窗口的阶段进行最小覆盖子串的更新，以便从可行解中找到长度最短的最终结果。

必看参考：滑动窗口解题套路框架

/* 滑动窗口算法框架 */
void slidingWindow(string s, string t) {
    unordered_map<char, int> need, window;
    for (char c : t) need[c]++;

    int left = 0, right = 0;
    int valid = 0; 
    while (right < s.size()) {
        // c 是将移入窗口的字符
        char c = s[right];
        // 右移窗口
        right++;
        // 进行窗口内数据的一系列更新
        ...

        /*** debug 输出的位置 ***/
        printf("window: [%d, %d)\n", left, right);
        /********************/

        // 判断左侧窗口是否要收缩
        while (window needs shrink) {
            // d 是将移出窗口的字符
            char d = s[left];
            // 左移窗口
            left++;
            // 进行窗口内数据的一系列更新
            ...
        }
    }
}