剑指 Offer II 017. 含有所有字符的最短字符串

给定两个字符串 s 和 t 。返回 s 中包含 t 的所有字符的最短子字符串。如果 s 中不存在符合条件的子字符串，则返回空字符串 “” 。

如果 s 中存在多个符合条件的子字符串，返回任意一个。

注意： 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。

示例 1：

输入：s = “ADOBECODEBANC”, t = “ABC”
输出：“BANC”
解释：最短子字符串 “BANC” 包含了字符串 t 的所有字符 ‘A’、‘B’、‘C’
示例 2：

输入：s = “a”, t = “a”
输出：“a”
示例 3：

输入：s = “a”, t = “aa”
输出：""
解释：t 中两个字符 ‘a’ 均应包含在 s 的子串中，因此没有符合条件的子字符串，返回空字符串。

提示：

1 <= s.length, t.length <= 105
s 和 t 由英文字母组成

进阶：你能设计一个在 o(n) 时间内解决此问题的算法吗？

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

O(n) 时间内找出 包含所有字符的最短子串，一看就需要使用 哈希表 来存放字符出现的次数，本题思路：

首先，定义一个 hash 表，然后遍历 t 字符串，将字符放入 hash 表中，记录 t 字符都出现的个数。

然后，从 0 开始遍历 s 字符，左指针 start，右指针 end，end 不断往后加，count 等于 map 的大小，也就是 t 中不重复字符的个数，当 count 大于 0 时，说明此时 在 s 中还没有全出现 t 包含的字符，此时继续往右遍历，每遍历到一个字符，就–，直到减到 0 为止，说明 t 中该字符都出现过了。

当 count 缩短到 0 的时候，说明此时 t 的字符在 双指针当前位置都出现过了，此时记录下 start 和 end 的位置，然后缩短左边界，每当左边界往右移动一个位置，该位置的字符在 map 中的记录就加一，如果此时等于 1，说明双指针指向的字符，相比 t 的字符来说就又少了一个，所以此时继续扩大右边界。

举个例子：
s：ADBCA
t：ABC
首先，map 中 ABC 的位置都是 1，此时 count 等于 3，然后遍历 s，当遍历到 C 位置的时候，count 缩短到 0，此时缩短左边界，A 加上 1，等于 1，此时左边界指向 D，右边界指向 C，count 等于 1，继续扩大右边界，此时 count 又等于 0 了，缩短左边界 D 不在 t 中，所以继续，最后指针：start 指向 B，end 指向 A，结果是 BCA。

较难题目，建议复盘

class Solution {
    public String minWindow(String s, String t) {
        Map<Character, Integer> map = new HashMap<>();
        int left = 0, minLength = Integer.MAX_VALUE;
        for (char ch : t.toCharArray()) {
            map.put(ch, map.getOrDefault(ch, 0) + 1);
        }
        int count = map.size();
        int start = 0, end = 0, minStart = 0, minEnd = 0;
        while (end < s.length() || (end == s.length() && count == 0)) {
            if (count > 0) {
                if (map.containsKey(s.charAt(end))) {
                    map.put(s.charAt(end), map.get(s.charAt(end)) - 1);
                    if (map.get(s.charAt(end)) == 0) {
                        count--;
                    }
                }
                end++;
            } else {
                if (minLength > end - start) {
                    minLength = end - start;
                    minStart = start;
                    minEnd = end;
                }
                if (map.containsKey(s.charAt(start))) {
                    map.put(s.charAt(start), map.get(s.charAt(start)) + 1);
                    if (map.get(s.charAt(start)) == 1) {
                        count++;
                    }
                }
                start++;
            }
        }
        return minLength == Integer.MAX_VALUE ? "" : s.substring(minStart, minEnd);
    }
}