76. 最小覆盖子串

3,  滑动窗口
public String minWindow1(String s, String t) {
        int [] map = new int[128];

        // 关于t字符串上的字符 初始都是加上1的
        for (int i = 0; i < t.length(); i++) {
            map[t.charAt(i)]++;
        }

        int lo = 0, hi = 0;
        int resLo = 0, minLen = Integer.MAX_VALUE;
        // counter初始值是t字符串的长度
        int counter = t.length();

        while (hi < s.length()) {
            char c1 = s.charAt(hi);
            // map[c1] > 0 表示 c1是t字符串中的字符
            if (map[c1] > 0) counter--;
            map[c1]--;
            hi++;

            // counter == 0 表示lo到hi之间的字符串（s.charAt(h)是t中的一个字符） 刚好拥有 t的所有字符
            while (counter == 0) {
            	// 更新开始位置和最小长度
                if (hi - lo < minLen) {
                    minLen = hi - lo;
                    resLo = lo;
                }
                
                // 开始收敛lo
                // lo到hi位置的字符之前都是 减过1的  map[c1]--
                char c2 = s.charAt(lo);
                // 现在又都开始 加上1
                map[c2]++;
                // t上字符，map初始值都是1
                // map[c2] > 0 说明c2是t上的字符，然后counter++
                if (map[c2] > 0 ) counter++;
                lo++;
            }
            
            // counter > 0 就开始增加hi，直到找到下一个满足条件的
        }
        if (minLen == Integer.MAX_VALUE) return  "";
        return s.substring(resLo, resLo + minLen);
    }


1,
public String minWindow(String s, String t) {
        Map<Character, Integer> map = new HashMap<>();
        Map<Character, Integer> map2 = new HashMap<>();

        for (int i = 0; i < t.length(); i++) {
            char c = t.charAt(i);
            if (map2.containsKey(c)) {
                map2.put(c, map2.get(c) + 1);
            } else {
                map2.put(c, 1);
            }
        }

        int minLen = Integer.MAX_VALUE;
        int lo = 0;
        int n = s.length();
        String res = "";

        for (int i = 0; i < n; i++) {
            char c1 = s.charAt(i);

            if (map.containsKey(c1)) {
                map.put(c1, map.get(c1)+1);
            } else {
                map.put(c1, 1);
            }


            while (canShrink(map, map2)) {
                if (i - lo + 1 < minLen) {
                    res = s.substring(lo, i+1);
                    minLen = i - lo + 1;
                }

                Integer integer = map.get(s.charAt(lo));

                if (integer > 1) {
                    map.put(s.charAt(lo), integer-1);
                } else {
                    map.remove(s.charAt(lo));
                }

                lo++;
            }
        }

        return res;
    }

    private boolean canShrink(Map<Character, Integer> map1, Map<Character, Integer> map2) {
        for (char c :  map2.keySet()) {
            if (!map1.containsKey(c)) return false;
            if (map2.get(c).intValue() > map1.get(c)) {
                return false;
            }
        }
        return true;
    }
2,
public String minWindow(String s, String t) {
        int[] map1 = new int[128];
        int[] map2 = new int[128];

        for (int i = 0; i < t.length(); i++) {
            char c = t.charAt(i);
            map2[c]++;
        }

        int n = s.length();
        int lo = 0;
        int resLo = -1;
        int minLen = Integer.MAX_VALUE;
        String res = "";

        for (int i = 0; i < s.length(); i++) {
            char c1 = s.charAt(i);
            map1[c1]++;

            while (lo < n && canShrink(map1, map2)) {
                if (i - lo + 1 < minLen) {
                    minLen = i - lo + 1;
                    resLo = lo;
                }

                map1[s.charAt(lo)]--;
                lo++;
            }
        }

        if (resLo != -1) {
            res = s.substring(resLo, resLo + minLen);
        }

        return res;

    }

    private boolean canShrink(int[] map1, int[] map2) {
        for (int i = 0; i < 128; i++) {
            if (map2[i] > 0) {
                if (map1[i] < map2[i])
                    return false;
            }
        }
        return true;
    }