学习记录：js算法（二十二）：最小覆盖子串

最小覆盖子串

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “” 。
注意：
对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
如果 s 中存在这样的子串，我们保证它是唯一的答案。

示例 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 的子串中，
因此没有符合条件的子字符串，返回空字符串。

我的思路
老样子，循环
网上思路
滑动窗口+双指针

我的思路

var minWindow = function (s, t) {
    if (t.length === 0 || s.length === 0) return "";
    const tCount = {};
    const windowCount = {};
    for (let char of t) {
        tCount[char] = (tCount[char] || 0) + 1;
    }
    let required = Object.keys(tCount).length;
    let formed = 0;
    let left = 0;
    let minLength = Infinity;
    let minLeft = 0;
    for (let right = 0; right < s.length; right++) {
        const char = s[right];
        windowCount[char] = (windowCount[char] || 0) + 1;
        if (tCount[char] && windowCount[char] === tCount[char]) {
            formed++;
        }
        for (let tempLeft = left; tempLeft <= right && formed === required; tempLeft++) {
            const charLeft = s[tempLeft];
            if (right - tempLeft + 1 < minLength) {
                minLength = right - tempLeft + 1;
                minLeft = tempLeft;
            }
            windowCount[charLeft]--;
            if (tCount[charLeft] && windowCount[charLeft] < tCount[charLeft]) {
                formed--;
            }
            left = tempLeft + 1;
        }
    }
    return minLength === Infinity ? "" : s.slice(minLeft, minLeft + minLength);
}

讲解

1. 函数定义与边界情况处理:
   函数定义：minWindow 接受两个字符串 s 和 t，目的是找到 s 中最小的包含 t 所有字符的子串。
   边界情况：如果 t 或 s 的长度为 0，直接返回空字符串，因为在这种情况下没有有效的子串。
2. 统计字符频率
   tCount：用来记录字符串 t 中每个字符的出现频率。
   windowCount：用来记录当前窗口（即 s 的子串）中每个字符的出现频率。
   统计频率：通过 for 循环遍历 t 中的每个字符，将其频率存入 tCount 对象中。
3. 初始化变量
   required：记录 t 中不同字符的数量，用于判断当前窗口是否满足条件。
   formed：记录当前窗口中满足条件的字符数量。
   left：左指针，表示当前窗口的起始位置。
   minLength：记录找到的最小子串的长度，初始设为无穷大。
   minLeft：记录最小子串的起始位置。
4. 外层循环遍历字符串 s
   right：右指针，遍历字符串 s。
   当前字符：s 中的字符被添加到 windowCount 中。
   更新 formed：如果当前字符的数量与 tCount 中的数量相等，说明当前窗口满足该字符的条件，formed 加 1。
5. 收缩窗口的逻辑
   内层循环：当 formed 等于 required 时，尝试收缩窗口。
   更新最小子串：计算当前窗口的长度，如果小于 minLength，则更新 minLength 和 minLeft。
   收缩左指针：减少 windowCount 中左指针字符的数量。
   更新 formed：如果减少后的字符数量不再满足条件，formed 减 1。
   更新 left：将 left 更新为 tempLeft + 1，为下一次外层循环做准备。
6. 返回结果：如果 minLength 仍为无穷大，说明没有找到满足条件的子串，返回空字符串；否则返回 s 中从 minLeft 开始的子串。

网上思路

var minWindow = function (s, t) {
    if (t.length === 0 || s.length === 0) return "";
    const tCount = {};
    const windowCount = {};
    // 统计 t 中字符的频率
    for (let char of t) {
        tCount[char] = (tCount[char] || 0) + 1;
    }
    let required = Object.keys(tCount).length; // t 中不同字符的数量
    let formed = 0; // 当前窗口中满足条件的字符数量
    let left = 0, right = 0; // 左右指针
    let minLength = Infinity; // 最小子串长度
    let minLeft = 0; // 最小子串的起始位置

    while (right < s.length) {
        // 扩展右指针
        const char = s[right];
        windowCount[char] = (windowCount[char] || 0) + 1;
        // 如果当前字符的数量符合 t 的要求
        if (tCount[char] && windowCount[char] === tCount[char]) {
            formed++;
        }
        // 尝试收缩窗口
        while (left <= right && formed === required) {
            const charLeft = s[left];
            // 更新最小子串的信息
            if (right - left + 1 < minLength) {
                minLength = right - left + 1;
                minLeft = left;
            }
            // 收缩左指针
            windowCount[charLeft]--;
            if (tCount[charLeft] && windowCount[charLeft] < tCount[charLeft]) {
                formed--;
            }
            left++;
        }
        // 移动右指针
        right++;
    }
    return minLength === Infinity ? "" : s.slice(minLeft, minLeft + minLength);
}

讲解
具体的解题思路：

1. 字符频率统计：我们需要统计字符串 t 中每个字符的出现次数。这可以帮助我们判断当前窗口是否包含了 t 中所有字符。
2. 设置滑动窗口：使用两个指针 （left 和 right） 来表示当前窗口的边界。right 用于扩展窗口，而 left 用于收缩窗口。
3. 检查覆盖条件：每次移动 right 指针后，我们需要检查当前窗口是否包含了 t 中所有字符。如果是，则尝试收缩窗口以找到更小的子串。
4. 更新最小子串：每次找到符合条件的窗口时，检查并更新当前最小子串的长度和起始位置。

逐步解析：

1. 边界条件：如果 t 或 s 为空，直接返回空字符串。
2. 字符频率统计：这里我们使用一个对象 tCount 来统计 t 中每个字符的频率。这是通过遍历 t 的每个字符实现的。
3. 初始化变量：
   required 记录 t 中不同字符的数量。
   formed 记录当前窗口中满足条件的字符数量。
   minLength 和 minLeft 用于记录找到的最小子串的长度和起始位置。
4. 扩展右指针：
   使用 while 循环遍历字符串 s，每次将 right 指针向右移动。
   更新 windowCount，记录当前窗口中字符的频率。
   如果当前字符的频率满足 t 中的要求，则增加 formed 的计数。
5. 收缩窗口：
   当当前窗口满足条件时，使用内部 while 循环收缩左指针 left。
   更新最小子串的信息，如果当前窗口的长度小于 minLength，则更新 minLength 和 minLeft。
   收缩左指针后，更新 windowCount，如果某个字符的数量不再满足 t 的要求，则减少 formed。
6. 返回结果：如果 minLength 仍为无穷大，表示没有找到符合条件的子串，返回空字符串。否则返回找到的最小子串。

总结

这个好难，我没做出来，写的时候完全没思路，还得看网上的写法才明白是怎么一回事。。。