滑动窗口题目：最小覆盖子串

题目

标题和出处

标题：最小覆盖子串

出处：76. 最小覆盖子串

难度

6 级

题目描述

要求

给定两个字符串 $\text{s}$ 和 $\text{t}$，长度分别是 $\text{m}$ 和 $\text{n}$，返回 $\text{s}$ 中覆盖 $\text{t}$ 中的每个字符（包括重复字符）的最小子串。如果没有这样的子串，返回空字符串 $\text{""}$。

题目确保答案唯一。

子串是字符串中的连续字符序列。

示例

示例 1：

输入：$\text{s = "ADOBECODEBANC", t = "ABC"}$
输出：$\text{"BANC"}$
解释：最小子串 $\text{"BANC"}$ 包含字符串 $\text{t}$ 的 $\text{‘A’}$、$\text{‘B’}$ 和 $\text{‘C’}$。

示例 2：

输入：$\text{s = "a", t = "a"}$
输出：$\text{"a"}$
解释：整个字符串 $\text{s}$ 是最小子串。

示例 3：

输入：$\text{s = "a", t = "aa"}$
输出：$\text{""}$
解释：字符串 $\text{t}$ 中的两个 $\text{‘a’}$ 都必须包含在子串中。由于 $\text{s}$ 的最大子串只有一个 $\text{‘a’}$，返回空字符串。

数据范围

• $\text{m}=\text{s.length}$
• $\text{n}=\text{t.length}$
• $\text{1}\le \text{m, n}\le {\text{10}}^{\text{5}}$
• $\text{s}$ 和 $\text{t}$ 由大写和小写英语字母组成

进阶

你可以想出一个时间复杂度 $\text{O(m + n)}$ 的算法吗？

解法一

思路和算法

如果字符串 $s$ 的下标范围 $[\text{start},\text{end}]$ 的子串覆盖字符串 $t$ 中的每个字符，则将子串的左端点向左移动或将子串的右端点向右移动之后，得到更长的子串，同样覆盖字符串 $t$ 中的每个字符。考虑两个不同下标 ${\text{end}}_1$ 和 ${\text{end}}_2$，其中 ${\text{end}}_1<{\text{end}}_2$，分别以这两个下标作为结束下标，寻找最小覆盖子串，将这两个最小覆盖子串的开始下标分别记为 ${\text{start}}_1$ 和 ${\text{start}}_2$，则必有 ${\text{start}}_1\le {\text{start}}_2$。因此，需要对每个下标寻找以该下标作为结束下标的最小覆盖子串。以下将覆盖字符串 $t$ 中的每个字符的子串称为「覆盖子串」。

可以使用变长滑动窗口寻找字符串 $s$ 中的以每个下标作为结束下标的最小覆盖子串。用 $[\text{start},\text{end}]$ 表示滑动窗口，初始时 $\text{start}=\text{end}=0$。将滑动窗口的右端点 $\text{end}$ 向右移动，移动过程中维护滑动窗口的左端点 $\text{start}$，对于每个 $\text{end}$ 寻找最小覆盖子串。

判断一个子串是否为覆盖子串的方法是，使用哈希表记录每个字符在子串中的出现次数与在 $t$ 中的出现次数之差，哈希表只记录在 $t$ 中出现的字符，如果每个字符的出现次数之差都非负则子串是覆盖子串，否则子串不是覆盖子串。

初始时，最小覆盖字串的开始下标为 $-1$，长度为 $+\infty$。

首先遍历字符串 $t$，将 $t$ 中的每个字符在哈希表中的出现次数减 $1$，然后使用滑动窗口遍历字符串 $s$。对于每个右端点 $\text{end}$，执行如下操作。

1. 如果 $s[\text{end}]$ 在哈希表中，则将该字符在哈希表中的次数加 $1$。

2. 如果滑动窗口 $[\text{start},\text{end}]$ 中的子串是覆盖子串，执行如下操作，直到滑动窗口 $[\text{start},\text{end}]$ 中的子串不是覆盖子串。

   1. 如果当前子串的长度小于最小覆盖子串的长度，则将最小覆盖子串的开始下标更新为 $\text{start}$，长度更新为 $\text{end}-\text{start}+1$。

   2. 如果 $s[\text{start}]$ 在哈希表中，则将该字符在哈希表中的次数减 $1$。

   3. 将 $\text{start}$ 向右移动一位。

3. 此时的滑动窗口 $[\text{start},\text{end}]$ 中的子串为以 $\text{end}$ 作为结束下标的最大非覆盖子串。如果 $\text{start}>0$，则以 $\text{end}$ 作为结束下标的最小覆盖子串为下标范围 $[\text{start}-1,\text{end}]$ 的子串，该子串已经被遍历到。

遍历结束之后，即可得到字符串 $s$ 中的最小覆盖子串。

特别地，如果遍历结束之后，最小覆盖字串的开始下标为 $-1$，则字符串 $s$ 中不存在覆盖子串，返回空字符串。

证明

为了证明上述解法的正确性，需要证明对于每个 $\text{start}$，其对应的 $\text{end}$ 满足下标范围 $[\text{start},\text{end}]$ 中的子串为以 $\text{start}$ 作为开始下标的最小覆盖子串。这里的对应表示当结束下标位于 $\text{end}$ 时，开始下标会经过 $\text{start}$。

假设以 $\text{start}$ 作为开始下标的最小覆盖子串的下标范围不是 $[\text{start},\text{end}]$，则存在下标 ${\text{end}}^{\prime }<\text{end}$ 使得下标范围 $[\text{start},{\text{end}}^{\prime }]$ 中的子串为以 $\text{start}$ 作为开始下标的最小覆盖子串。当结束下标位于 ${\text{end}}^{\prime }$ 时，对于所有 ${\text{start}}^{\prime }\le \text{start}$，下标范围 $[{\text{start}}^{\prime },{\text{end}}^{\prime }]$ 中的子串都是覆盖子串，因此开始下标会向右移动到 $\text{start}$ 右边。当结束下标位于 $\text{end}$ 时，开始下标已经大于 $\text{start}$，与 $\text{start}$ 对应 $\text{end}$ 矛盾。

因此，以 $\text{start}$ 作为开始下标的最小覆盖子串的下标范围是 $[\text{start},\text{end}]$。

代码

class Solution {public String minWindow(String s, String t) {int minStart = -1;int minLength = Integer.MAX_VALUE;Map<Character, Integer> counts = new HashMap<Character, Integer>();int m = s.length(), n = t.length();for (int i = 0; i < n; i++) {char c = t.charAt(i);counts.put(c, counts.getOrDefault(c, 0) - 1);}int start = 0, end = 0;while (end < m) {char curr = s.charAt(end);if (counts.containsKey(curr)) {counts.put(curr, counts.getOrDefault(curr, 0) + 1);}while (allIncluded(counts)) {if (end - start + 1 < minLength) {minStart = start;minLength = end - start + 1;}char prev = s.charAt(start);if (counts.containsKey(prev)) {counts.put(prev, counts.get(prev) - 1);}start++;}end++;}return minStart < 0 ? "" : s.substring(minStart, minStart + minLength);}public boolean allIncluded(Map<Character, Integer> counts) {Set<Map.Entry<Character, Integer>> entries = counts.entrySet();for (Map.Entry<Character, Integer> entry : entries) {if (entry.getValue() < 0) {return false;}}return true;}
}

复杂度分析

• 时间复杂度：$O(m\times |\Sigma |+n)$，其中 $m$ 和 $n$ 分别是字符串 $s$ 和 $t$ 的长度，$\Sigma$ 是字符集，这道题中 $\Sigma$ 是全部大写和小写英语字母，$|\Sigma |=52$。需要首先遍历字符串 $t$ 计算每个字符的次数，然后使用滑动窗口遍历字符串 $s$，滑动窗口的左右端点最多各遍历字符串 $s$ 一次，每次移动需要 $O(|\Sigma |)$ 的时间判断当前子串是否为覆盖子串，因此时间复杂度是 $O(m\times |\Sigma |+n)$。

• 空间复杂度：$O(|\Sigma |)$，其中 $\Sigma$ 是字符集，这道题中 $\Sigma$ 是全部大写和小写英语字母，$|\Sigma |=52$。哈希表需要 $O(|\Sigma |)$ 的空间。

解法二

思路和算法

解法一判断每个子串是否为覆盖子串需要遍历字符串 $t$ 中的每个不同字符。由于每次移动时，只会有一个字符的出现次数有变化，因此可以将每个子串的判断时间降低到 $O(1)$。

遍历字符串 $t$ 并更新哈希表之后，哈希表中的字符个数即为字符串 $t$ 中的不同字符个数。维护一个计数器统计出现次数之差非负的字符个数，则可根据计数器的值判断当前子串是否为覆盖子串。

初始时，计数器的值为 $0$。对于每个在字符串 $t$ 中出现的字符，每次更新字符在哈希表中的次数之后，需要更新计数器的值，更新方法如下。

• 当一个字符在哈希表中的次数加 $1$ 之后，如果次数变成 $0$，则将计数器的值加 $1$。

• 当一个字符在哈希表中的次数减 $1$ 之后，如果次数变成 $-1$，则将计数器的值减 $1$。

根据计数器的值即可快速判断当前子串是否为覆盖子串。当计数器的值等于字符串 $t$ 中的不同字符个数时，当前子串为覆盖子串，否则当前子串不为覆盖子串。由此可以不需要遍历哈希表，在 $O(1)$ 时间内判断每个子串是否为覆盖子串。

代码

class Solution {public String minWindow(String s, String t) {int minStart = -1;int minLength = Integer.MAX_VALUE;Map<Character, Integer> counts = new HashMap<Character, Integer>();int m = s.length(), n = t.length();for (int i = 0; i < n; i++) {char c = t.charAt(i);counts.put(c, counts.getOrDefault(c, 0) - 1);}int total = counts.size();int meets = 0;int start = 0, end = 0;while (end < m) {char curr = s.charAt(end);if (counts.containsKey(curr)) {counts.put(curr, counts.getOrDefault(curr, 0) + 1);if (counts.get(curr) == 0) {meets++;}}while (meets == total) {if (end - start + 1 < minLength) {minStart = start;minLength = end - start + 1;}char prev = s.charAt(start);if (counts.containsKey(prev)) {counts.put(prev, counts.get(prev) - 1);if (counts.get(prev) < 0) {meets--;}}start++;}end++;}return minStart < 0 ? "" : s.substring(minStart, minStart + minLength);}
}

复杂度分析

• 时间复杂度：$O(m+n)$，其中 $m$ 和 $n$ 分别是字符串 $s$ 和 $t$ 的长度。需要首先遍历字符串 $t$ 计算每个字符的次数，然后使用滑动窗口遍历字符串 $s$，滑动窗口的左右端点最多各遍历字符串 $s$ 一次，每次移动需要 $O(1)$ 的时间判断当前子串是否为覆盖子串，因此时间复杂度是 $O(m+n)$。

• 空间复杂度：$O(|\Sigma |)$，其中 $\Sigma$ 是字符集，这道题中 $\Sigma$ 是全部大写和小写英语字母，$|\Sigma |=52$。哈希表需要 $O(|\Sigma |)$ 的空间。