力扣 76 、最小覆盖子串

一、最小覆盖子串

就是说要在 S(source) 中找到包含 T(target) 中全部字母的一个子串，且这个子串一定是所有可能子串中最短的。

滑动窗口算法的思路是这样：

1、我们在字符串 S 中使用双指针中的左右指针技巧，初始化 left = right = 0，把索引左闭右开区间 [left, right) 称为一个「窗口」。

PS：理论上你可以设计两端都开或者两端都闭的区间，但设计为左闭右开区间是最方便处理的。因为这样初始化 left = right = 0 时区间 [0, 0) 中没有元素，但只要让 right 向右移动（扩大）一位，区间 [0, 1) 就包含一个元素 0 了。如果你设置为两端都开的区间，那么让 right 向右移动一位后开区间 (0, 1) 仍然没有元素；如果你设置为两端都闭的区间，那么初始区间 [0, 0] 就包含了一个元素。这两种情况都会给边界处理带来不必要的麻烦。

2、我们先不断地增加 right 指针扩大窗口 [left, right)，直到窗口中的字符串符合要求（包含了 T 中的所有字符）。

3、此时，我们停止增加 right，转而不断增加 left 指针缩小窗口 [left, right)，直到窗口中的字符串不再符合要求（不包含 T 中的所有字符了）。同时，每次增加 left，我们都要更新一轮结果。

4、重复第 2 和第 3 步，直到 right 到达字符串 S 的尽头。

这个思路其实也不难，第 2 步相当于在寻找一个「可行解」，然后第 3 步在优化这个「可行解」，最终找到最优解，也就是最短的覆盖子串。左右指针轮流前进，窗口大小增增减减，窗口不断向右滑动，这就是「滑动窗口」这个名字的来历。

下面画图理解一下，needs 和 window 相当于计数器，分别记录 T 中字符出现次数和「窗口」中的相应字符的出现次数。

初始状态：

增加 right，直到窗口 [left, right) 包含了 T 中所有字符：

现在开始增加 left，缩小窗口 [left, right)：

直到窗口中的字符串不再符合要求，left 不再继续移动：

之后重复上述过程，先移动 right，再移动 left…… 直到 right 指针到达字符串 S 的末端，算法结束。

如果你能够理解上述过程，恭喜，你已经完全掌握了滑动窗口算法思想。现在我们来看看这个滑动窗口代码框架怎么用：

首先，初始化 window 和 need 两个哈希表，记录窗口中的字符和需要凑齐的字符：

//定义存放目标字符need 和 滑动窗口中含有目标字符的window
        HashMap<Character,Integer> window = new HashMap<>(),need = new HashMap<>();

        //把目标字符存在 need 中，并记录需要的个数
        for(char x : target){
            need.put(x , need.getOrDefault(x,0) + 1);//存在对应的key则加1，没有则设置key默认value为0
        }

然后，使用 left 和 right 变量初始化窗口的两端，不要忘了，区间 [left, right) 是左闭右开的，所以初始情况下窗口没有包含任何元素：

int left = 0, right = 0;
int valid = 0; 
while (right < s.size()) {
    // 开始滑动
}

其中 valid 变量表示窗口中满足 need 条件的字符个数，如果 valid 和 need.size 的大小相同，则说明窗口已满足条件，已经完全覆盖了串 T。

现在开始套模板，只需要思考以下几个问题：

1、什么时候应该移动 right 扩大窗口？窗口加入字符时，应该更新哪些数据？

2、什么时候窗口应该暂停扩大，开始移动 left 缩小窗口？从窗口移出字符时，应该更新哪些数据？

3、我们要的结果应该在扩大窗口时还是缩小窗口时进行更新？

如果一个字符进入窗口，应该增加 window 计数器；如果一个字符将移出窗口的时候，应该减少 window 计数器；当 valid 满足 need 时应该收缩窗口；应该在收缩窗口的时候更新最终结果。

下面是完整代码：

class Solution {
    //思路，一般对子串的操作都是要用到滑动窗口的，最后目标是得到子串，则只要知道其起始索引和长度就可以了
    public String minWindow(String s, String t) {
        //把原来的主串和目标串转为字符数组
        char []original = s.toCharArray();
        char []target = t.toCharArray();
        //定义记录need中key的个数
        int valid = 0;
        //定义起始索引和长度
        int start = 0,len = Integer.MAX_VALUE;
        //定义滑动窗口的左右
        int right = 0 ,left = 0;
        //定义存放目标字符need 和 滑动窗口中含有目标字符的window
        HashMap<Character,Integer> window = new HashMap<>(),need = new HashMap<>();

        //把目标字符存在 need 中，并记录需要的个数
        for(char x : target){
            need.put(x , need.getOrDefault(x,0) + 1);//存在对应的key则加1，没有则设置key默认value为0
        }

        //右窗口
        while(right < original.length){
            //c 是要移入窗口的字符
            char c = original[right];
            //扩大窗口
            right++;
            //判断是不是目标字符
            if(need.containsKey(c)){ 
                //判断滑动窗口有没有c这个目标字符，有加1，没有就加入key，value为1
                window.put(c , window.getOrDefault(c,0)+1);
                //判断滑动窗口中对应字符c的数量有没有满足
                if(window.get(c).equals(need.get(c))){
                    //满足  valid就++
                    valid++;
                }
            }
            //判断左窗口是否要收缩
            //当 valid == need.size() 时，说明 window 中所有字符已经被覆盖，已经得到一个可行的覆盖子串，现在应该开始收缩窗口了，以便得到「最小覆盖子串」。
            while(valid == need.size()){
                //注：这里是先确定start和len的，然后再取left对应的字符判断的，所以判断不通过直接退出循环，通过就在下一次循环把窗口中的最左个拿掉
                //更新最小覆盖子串
                if(right - left < len){
                    start = left; //起始位置为左指针
                    len = right - left;//目标子串的长度
                }
                //x是要移除出窗口的字符
                char x = original[left];
                //缩小窗口
                left ++;
                //判断移除的是不是当前目标字符中的
                if(need.containsKey(x)){
                    
                    //判断窗口中的目标字符的数量还满不满足need中的数量
                    if(window.get(x).equals(need.get(x))){
                        //满足就退出当前循环
                        valid--;
                    }
                    //移除窗口中的一个目标字符
                    window.put(x,window.get(x)-1);
                    
                }
            }
        }

    //长度没变，说明valid 不满足
    return len == Integer.MAX_VALUE ? "" : s.substring(start,start+len);

    }
}