Leetcode刷题76. 最小覆盖子串

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

注意：如果 s 中存在这样的子串，我们保证它是唯一的答案。

示例 1：

输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
示例 2：

输入：s = "a", t = "a"
输出："a"

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

感谢labuladong大神，传送门我写了套框架，把滑动窗口算法变成了默写题。

class Solution {
    public String minWindow(String s, String t) {
//		return minWindowI(s, t);
		return minWindowII(s, t);
	}

	//方法二：使用数组保存
	//时间复杂度O(s+t)，空间复杂度O(1)
	private String minWindowII(String s, String t) {
		if (s.length() == 0 || t.length() == 0) {
			return "";
		}
		//字符本质上是ASCII码（纯英文字符），所以这里用的是该字符的ASCII码作为下标索引
		int[] need = new int[256];
		int[] window = new int[256];
		int uniqueC = 0;
		for (char c : t.toCharArray()) {
			if (need[c] == 0) {
				uniqueC++;
			}
			need[c]++;
		}
		int left = 0;
		int right = 0;
		//start为涵盖t中所有字符的子串在s中开始的位置，len为子串的长度
		int start = 0;
		int minLen = Integer.MAX_VALUE;
		//统计目前窗口中已经找到了多少个字符
		int valid = 0;
		while (right < s.length()) {
			char c = s.charAt(right);
			right++;
			//need[c]>0表示遇到t中字符，当window[c]满足t中字符出现的次数时，更新valid
			if (need[c] > 0) {
				window[c]++;
				if (need[c] == window[c]) {
					valid++;
				}
			}
			//这里应该检查的是t中不同字符的数量
			while (valid == uniqueC) {
				if (right - left < minLen) {
					start = left;
					minLen = right - left;
				}
				char d = s.charAt(left);
				left++;
				if (need[d] > 0) {
					if (need[d] == window[d]) {
						valid--;
					}
					window[d]--;
				}
			}
		}
		return minLen == Integer.MAX_VALUE ? "" : s.substring(start, start + minLen);
	}

	//方法一：滑动窗口
	//1.定义hashmap保存字符串t中每个字符出现的次数，使用两个指针left和right表示滑动窗口的边界，
	//2.移动right扩大窗口，直到窗口中包含了t中所有的字符
	//3.一旦找到一个有效的窗口，开始移动left指针，缩小窗口，直到窗口不再包含t的所有字符
	//4.在每次移动left之后，如果当前窗口依然包含t的所有字符，则更新最小子串的长度和起始位置
	//重复第2和第3步，直到right指针到达s的末尾
	//时间复杂度O(s+t)，m为t的长度，n为s的长度；空间复杂度O(m)，m是字符串t中不同字符的数量
	private String minWindowI(String s, String t) {
		if (s.length() == 0 || t.length() == 0) {
			return "";
		}
		Map<Character, Integer> tCount = new HashMap<>();
		Map<Character, Integer> windowCount = new HashMap<>();
		for (int i = 0; i < t.length(); i++) {
			char c = t.charAt(i);
			tCount.put(c, tCount.getOrDefault(c, 0) + 1);
		}
		int left = 0;
		int right = 0;
		//当valid=need.size()时，需要收缩窗口
		int valid = 0;
		int start = 0;
		int minLen = Integer.MAX_VALUE;
		while (right < s.length()) {
			char c = s.charAt(right);
			right++;
			//更新窗口数据
			if (tCount.containsKey(c)) {
				windowCount.put(c, windowCount.getOrDefault(c, 0) + 1);
				//窗口中字符的个数满足字符串t中字符的个数
				if (windowCount.get(c).equals(tCount.get(c))) {
					valid++;
				}
			}

			//尝试缩小窗口
			while (valid == tCount.size()) {
				if (right - left < minLen) {
					start = left;
					minLen = right - left;
				}
				char d = s.charAt(left);
				//向左移动
				left++;
				if (tCount.containsKey(d)) {
					if (windowCount.get(d).equals(tCount.get(d))) {
						valid--;
					}
					windowCount.put(d, windowCount.get(d) - 1);
				}
			}
		}
		return minLen == Integer.MAX_VALUE ? "" : s.substring(start, start + minLen);
	}
}