LeetCode热题100--76. 最小覆盖子串--困难

题目

给定两个字符串 s 和 t，长度分别是 m 和 n，返回 s 中的最短窗口子串，使得该子串包含 t 中的每一个字符（包括重复字符）。如果没有这样的子串，返回空字符串 ""。

测试用例保证答案唯一。

示例 1：

输入：s = "ADOBECODEBANC", t = "ABC"

输出："BANC"

解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。

示例 2：

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

输出："a"

解释：整个字符串 s 是最小覆盖子串。

示例 3:

输入: s = "a", t = "aa"

输出: ""

解释: t 中两个字符 'a' 均应包含在 s 的子串中，

因此没有符合条件的子字符串，返回空字符串。

题解

java 复制代码

class Solution {
    public String minWindow(String S, String t) {
        int[] cnt = new int[128];
        int less = 0;
        for (char c : t.toCharArray()) {
            if (cnt[c] == 0) {
                less++; 
            }
            cnt[c]++;
        }

        char[] s = S.toCharArray();
        int m = s.length;
        int ansLeft = -1;
        int ansRight = m;

        int left = 0;
        for (int right = 0; right < m; right++) { 
            char c = s[right]; 
            cnt[c]--;
            if (cnt[c] == 0) { 
                less--;
            }
            while (less == 0) { 
                if (right - left < ansRight - ansLeft) { 
                    ansLeft = left; 
                    ansRight = right;
                }
                char x = s[left]; 
                if (cnt[x] == 0) {
                    less++;
                }
                cnt[x]++; 
                left++;
            }
        }

        return ansLeft < 0 ? "" : S.substring(ansLeft, ansRight + 1);
    }
}

解析

出自：两种方法：从 O(52m+n) 到 O(m+n)，附题单（Python/Java/C++/C/Go/JS/Rust）

java 复制代码

class Solution {
    public String minWindow(String S, String t) {
        // cnt 数组用于记录字符频次需求：
        // 对于 ASCII 字符（0~127），cnt[c] 表示：t 中 c 的出现次数 - 当前窗口中 c 的出现次数
        // 初始时，cnt[c] = t 中 c 的出现次数（正数表示"还缺多少"）
        int[] cnt = new int[128];

        // less 表示：当前还有多少种字符的"需求未满足"
        // 即：有多少种字符在窗口中的数量 < t 中的数量
        int less = 0;

        // 遍历字符串 t，初始化 cnt 和 less
        for (char c : t.toCharArray()) {
            // 如果 cnt[c] == 0，说明这是第一次遇到该字符
            // 此时即将增加它的需求，所以"未满足种类数"加 1
            if (cnt[c] == 0) {
                less++; // 有 less 种字母的出现次数 < t 中的字母出现次数
            }
            cnt[c]++;   // 增加该字符在 t 中的需求量（即"目标数量"）
        }

        // 将字符串 S 转为字符数组，便于访问
        char[] s = S.toCharArray();
        int m = s.length;               // S 的长度

        // 初始化答案区间 [ansLeft, ansRight]，初始为无效区间（长度 = m+1）
        int ansLeft = -1;
        int ansRight = m;               // 这样 ansRight - ansLeft = m+1 > 任何合法子串

        int left = 0;                   // 滑动窗口左指针

        // 右指针 right 从 0 到 m-1，逐步扩展窗口
        for (int right = 0; right < m; right++) {
            char c = s[right];          // 当前右端点字符

            cnt[c]--;                   // 将 c 加入窗口 → 需求减少 1
                                        // （因为 cnt[c] = 需求 - 窗口内数量，加入后窗口数量+1 → 差值-1）

            // 如果 cnt[c] == 0，说明窗口中 c 的数量刚好等于 t 中的数量
            // 之前是"不足"，现在"刚好满足"，所以未满足种类数减 1
            if (cnt[c] == 0) {
                less--;
            }

            // 当 less == 0 时，说明窗口已包含 t 的所有字符（且数量足够）→ 是一个有效覆盖
            while (less == 0) {
                // 如果当前窗口 [left, right] 比已知最短窗口更短，则更新答案
                if (right - left < ansRight - ansLeft) {
                    ansLeft = left;
                    ansRight = right;
                }

                // 尝试收缩左边界：移除 s[left]
                char x = s[left];

                // 在移除前检查：如果 cnt[x] == 0，说明窗口中 x 的数量刚好等于 t 中的数量
                // 移除后就会"不足"，所以未满足种类数要加 1
                if (cnt[x] == 0) {
                    less++;
                }

                cnt[x]++;               // 将 x 移出窗口 → 需求增加 1（窗口内数量-1 → 差值+1）
                left++;                 // 左指针右移
            }
        }

        // 如果 ansLeft 仍为 -1，说明没找到有效窗口，返回空串
        // 否则返回 S 中 [ansLeft, ansRight] 的子串（substring 是左闭右开，所以 +1）
        return ansLeft < 0 ? "" : S.substring(ansLeft, ansRight + 1);
    }
}