1. 76 最小覆盖子串（hard）

一、题目

Given two strings s and t of lengths m and n respectively, return the minimum window substring of s such that every character in t (including duplicates) is included in the window. If there is no such substring, return the empty string "".

The testcases will be generated such that the answer is unique.

A substring is a contiguous sequence of characters within the string.

 

Example 1:

Input: s = "ADOBECODEBANC", t = "ABC"
Output: "BANC"
Explanation: The minimum window substring "BANC" includes 'A', 'B', and 'C' from string t.
Example 2:

Input: s = "a", t = "a"
Output: "a"
Explanation: The entire string s is the minimum window.
Example 3:

Input: s = "a", t = "aa"
Output: ""
Explanation: Both 'a's from t must be included in the window.
Since the largest window of s only has one 'a', return empty string.
 

Constraints:

m == s.length
n == t.length
1 <= m, n <= 105
s and t consist of uppercase and lowercase English letters.
 

Follow up: Could you find an algorithm that runs in O(m + n) time?

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-window-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、 思路

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

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

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

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

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

变量的定义和意义都在code里面注释了

只需要考虑下面四个问题：
1、当移动 right 扩大窗口，即加入字符时，应该更新哪些数据？
答：如果一个字符进入窗口，应该增加 window 计数器；且当window计数器对应字符的数量等于need计数器对应字符的数量时候，valid要++。

2、什么条件下，窗口应该暂停扩大，开始移动 left 缩小窗口？
当valid等于need.size的时候，就说明当前字符串满足需求了，开始缩小字符串找最优解。

3、当移动 left 缩小窗口，即移出字符时，应该更新哪些数据？
如果一个字符将移出窗口的时候，先看window计数器对应的字符数量等不等于need计数器对应字符的数量，如果等于，则valid–，然后应该减少 window 计数器对应数量；如果不等于，那就只减少window计数器对应数量

4、我们要的结果应该在扩大窗口时还是缩小窗口时进行更新？
要在缩小窗口的时候更新len和start，找最小的。

二、自己写的

1.代码

第一次写

class Solution {
    public String minWindow(String s, String t) {
        //定义HashMap,need和window，need记录t中字符出现的次数，window表示窗口里面相应的字符出现的次数
        //定义一个窗口left=right=0左闭右开[left,right)
        //定义valid表示window中满足need条件的字符个数，如果valid与need.size()相等，则说明window已经覆盖了t

        //定义两个hashmap存need和window
        HashMap<Character,Integer> need = new HashMap<Character,Integer>();
        HashMap<Character,Integer> window = new HashMap<Character,Integer>();

        //toCharArray()是把字符串t转换为新的字符数组
        //这toCharArray()就相当于把字符串t变成了一个字符数组，比如说t[0] = 'a', t[0] = 'b'
        //然后for(char c : t.toCharArray())就相当于从数组第一个元素开始遍历，0的时候是'a'，1的时候是'b'
        for (char c : t.toCharArray())
            //getOrDefault()返回与指定键关联的值。如果找不到键，则返回指定的默认值。
            //getOrDefault(c, 0)，找到c就返回其对应的integer，找不到就返回0
            //其实就是对每一个字符进行计数，假如t="aa"，也就是说第一次循环c=第一个a，此时need里面没有a的个数，所以getOrDefault返回0，加上1以后调用put HashMap里面得到'a'=1；到第二个a的时候，此时need里面'a'=1，所以getOrDefault返回1，加上1以后以后调用put HashMap里面得到'a'=2
            need.put(c, need.getOrDefault(c, 0) + 1);

        //for的这一段也可以这么写
        //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;

        //start表示符合最优解的substring的起始位序
        int start = 0;
        //len用来记录最终窗口的长度，并且以len作比较，淘汰选出最小的substring的len
        int len = Integer.MAX_VALUE;

        while (right < s.length()) {
            //更新window
            char c = s.charAt(right);
            right++;
            //如果这个字符是need中出现的，那么要存进window
            if (need.containsKey(c)) {
                window.put(c, window.getOrDefault(c, 0) + 1);
                if (need.get(c).equals(window.get(c)))
                    valid++;
            }

            //s的substring包含了t以后，开始缩小
            while (valid == need.size()) {
                //不断“打擂”找满足条件的len最短值,并记录最短的子串的起始位序start
                if (right - left < len) {
                    len = right - left;
                    start = left;
                }
                char d = s.charAt(left);
                left++;
                if (need.containsKey(d)) {
                    if (need.get(d).equals(window.get(d))){
                        valid--;
                    }
                    window.put(d, window.get(d) - 1);
                }
            }
        }
        return len ==  Integer.MAX_VALUE ? "" : s.substring(start,start+len); 
    }
}



//正确

三、标准答案

1.滑动窗口

class Solution {
    public String minWindow(String s, String t) {
        //定义HashMap,need和window，need记录t中字符出现的次数，window表示窗口里面相应的字符出现的次数
        //定义一个窗口left=right=0左闭右开[left,right)
        //定义valid表示window中满足need条件的字符个数，如果valid与need.size()相等，则说明window已经覆盖了t

        //定义两个hashmap存need和window
        HashMap<Character,Integer> need = new HashMap<Character,Integer>();
        HashMap<Character,Integer> window = new HashMap<Character,Integer>();

        //toCharArray()是把字符串t转换为新的字符数组
        //这toCharArray()就相当于把字符串t变成了一个字符数组，比如说t[0] = 'a', t[0] = 'b'
        //然后for(char c : t.toCharArray())就相当于从数组第一个元素开始遍历，0的时候是'a'，1的时候是'b'
        for (char c : t.toCharArray())
            //getOrDefault()返回与指定键关联的值。如果找不到键，则返回指定的默认值。
            //getOrDefault(c, 0)，找到c就返回其对应的integer，找不到就返回0
            //其实就是对每一个字符进行计数，假如t="aa"，也就是说第一次循环c=第一个a，此时need里面没有a的个数，所以getOrDefault返回0，加上1以后调用put HashMap里面得到'a'=1；到第二个a的时候，此时need里面'a'=1，所以getOrDefault返回1，加上1以后以后调用put HashMap里面得到'a'=2
            need.put(c, need.getOrDefault(c, 0) + 1);

        //for的这一段也可以这么写
        //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;

        //start表示符合最优解的substring的起始位序
        int start = 0;
        //len用来记录最终窗口的长度，并且以len作比较，淘汰选出最小的substring的len
        int len = Integer.MAX_VALUE;

        while (right < s.length()) {
            //更新window
            char c = s.charAt(right);
            right++;
            //如果这个字符是need中出现的，那么要存进window
            if (need.containsKey(c)) {
                window.put(c, window.getOrDefault(c, 0) + 1);
                if (need.get(c).equals(window.get(c)))
                    valid++;
            }

            //s的substring包含了t以后，开始缩小
            while (valid == need.size()) {
                //不断“打擂”找满足条件的len最短值,并记录最短的子串的起始位序start
                if (right - left < len) {
                    len = right - left;
                    start = left;
                }
                char d = s.charAt(left);
                left++;
                if (need.containsKey(d)) {
                    if (need.get(d).equals(window.get(d))){
                        valid--;
                    }
                    window.put(d, window.get(d) - 1);
                }
            }
        }
        return len ==  Integer.MAX_VALUE ? "" : s.substring(start,start+len); 
    }
}

2.总结

多写，逻辑明白了，但是细节太多了。