四道题的三问速查#

关于代码 每题给出 C / C++ / JavaScript 三语言实现，三种写法逻辑完全等价，可切换标签查看。 窗口一律写成左闭右开的 [left, right)，所以长度永远是 right - left，nums[right] 是刚进窗的元素、nums[left] 是即将出窗的元素。

题目描述#

给定一个含有 n 个正整数的数组 nums 和一个正整数 target。找出该数组中满足其总和大于等于 target 的长度最小的子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

1
输入：target = 7, nums = [2,3,1,2,4,3]
2
输出：2
3
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
4

5
输入：target = 4, nums = [1,4,4]          输出：1
6
输入：target = 11, nums = [1,1,1,1,1,1,1,1]  输出：0

约束： 1 <= target <= 10^9，1 <= nums.length <= 10^5，1 <= nums[i] <= 10^4。

思路：和够了就缩，收缩前记录#

窗口状态只有一个 sum。因为数组里全是正数，往右扩张时 sum 单调增、往左收缩时 sum 单调减，这就带来两个性质：

1. 只要 sum >= target 就该立刻收缩——继续往外扩只会让窗口更长，不可能更优。这是模板里典型的「满足就缩」（流派 A）。
2. 收缩一定会破坏「已经够了」这个状态，所以答案必须在移出 left 之前记录，也就是「先记录、再破坏」。

顺着模板填四个空：② 加入时 sum += nums[right]；③ 收缩条件是 sum >= target；④ 在收缩循环的第一行记录 right - left；⑤ 移出时 sum -= nums[left]。

过程图解#

以 target = 7、nums = [2,3,1,2,4,3] 为例：

1
下标   0  1  2  3  4  5
2
nums   2  3  1  2  4  3

1
扩张到 right=1，窗口 [0,1)=[2]，sum=2   → 不够，不收缩
2
扩张到 right=2，窗口 [0,2)=[2,3]，sum=5 → 不够，不收缩
3
扩张到 right=3，窗口 [0,3)=[2,3,1]，sum=6 → 不够，不收缩
4
扩张到 right=4，窗口 [0,4)=[2,3,1,2]，sum=10 ≥ 7 ← 进入收缩循环
5
  ├ 先记录：[0,4) 长度 4 → best = 4
6
  ├ 移出 2 → sum=8，窗口 [1,4) 长度 3 → best = 3
7
  ├ 移出 3 → sum=5，停止收缩，窗口 [2,4)=[1,2]
8
扩张到 right=5，窗口 [2,5)=[1,2,4]，sum=9 ≥ 7 ← 再次进入收缩循环
9
  ├ 先记录：[2,5) 长度 3，不比 3 更优
10
  ├ 移出 1 → sum=8，窗口 [3,5) 长度 2 → best = 2
11
  ├ 移出 2 → sum=6，停止收缩，窗口 [4,5)=[4]
12
扩张到 right=6，窗口 [4,6)=[4,3]，sum=9 ≥ 7
13
  ├ 先记录：[4,6) 长度 2，不比 2 更优
14
  └ 移出 4 → sum=5，停止收缩
15

16
答案 2 ✔（子数组 [4,3]）

注意两件事：left 永远不会超过 right（窗口始终合法）；以及每一轮收缩都要先记录、再移出——顺序反了就会记到一段「和已经小于 target」的窗口，长度偏小而且根本不合法。这道题上因为这个原因得到的长度恰好相同，所以很容易蒙混过关；换一组数据就会露馅（见下面的易错点 4）。

代码实现#

1
int minSubArrayLen(int target, int *nums, int numsSize) {
2
    long long sum = 0;                 /* 窗口内元素之和，long long 防溢出 */
3
    int left = 0, right = 0;
4
    int best = numsSize + 1;           /* 比任何合法长度都大，表示「还没找到」 */
5

6
    while (right < numsSize) {
7
        sum += nums[right];            /* ① 右边界元素入窗 */
8
        right++;                       /*    窗口变成 [left, right) */
9

10
        while (sum >= target) {        /* ③ 和已经够了，开始收缩 */
11
            if (right - left < best)   /* ④ 先记录答案，再把 left 移出去 */
12
                best = right - left;
13
            sum -= nums[left];         /* ⑤ 左边界元素出窗 */
14
            left++;
15
        }
16
    }
17
    return best == numsSize + 1 ? 0 : best;
18
}

1
#include <vector>
2
using namespace std;
3

4
class Solution {
5
public:
6
    int minSubArrayLen(int target, vector<int>& nums) {
7
        long long sum = 0;
8
        int left = 0, right = 0;
9
        int best = (int)nums.size() + 1;      // 比任何合法长度都大
10

11
        while (right < (int)nums.size()) {
12
            sum += nums[right];               // ① 右边界元素入窗
13
            right++;
14

15
            while (sum >= target) {           // ③ 和已经够了，开始收缩
16
                if (right - left < best)      // ④ 先记录答案
17
                    best = right - left;
18
                sum -= nums[left];            // ⑤ 左边界元素出窗
19
                left++;
20
            }
21
        }
22
        return best == (int)nums.size() + 1 ? 0 : best;
23
    }
24
};

1
function minSubArrayLen(target, nums) {
2
  let sum = 0;
3
  let left = 0, right = 0;
4
  let best = nums.length + 1;      // 比任何合法长度都大
5

6
  while (right < nums.length) {
7
    sum += nums[right];            // ① 右边界元素入窗
8
    right++;
9

10
    while (sum >= target) {        // ③ 和已经够了，开始收缩
11
      if (right - left < best)     // ④ 先记录答案
12
        best = right - left;
13
      sum -= nums[left];           // ⑤ 左边界元素出窗
14
      left++;
15
    }
16
  }
17
  return best === nums.length + 1 ? 0 : best;
18
}

复杂度#

易错点#

1. sum 用 long long 更稳妥。 窗口和的上界就是整个数组之和 n × nums[i] = 10^5 × 10^4 = 10^9，int 恰好装得下（上限约 2.1 × 10^9）；但题目里 target 本身也给到了 10^9，只要数据规模再涨一档就会溢出。写 long long 不花什么代价。
2. 找不到答案时返回 0，而不是把 best 的初值返回。 所以初值要取 n + 1 这种不可能等于任何合法长度的哨兵，最后再判断一次。
3. 收缩条件用的是 >= 而不是 >。 题目要的是「大于等于 target」，写成 > 会漏掉和恰好等于 target 的窗口。
4. 内层必须是 while，不能换成 if。 有些题的收缩是「一轮最多缩一格」，这题不是：sum >= target 时可能要连缩好几格才把 sum 降下去。反例：target = 10, nums = [1,1,1,10]，正确答案是 1（子数组 [10]）。用 while 会一路缩到 [10]；换成 if 只缩一格，left 停在 1，答案会错报成 4。

扩展：本题还有一个 O(n log n) 的解法——前缀和 + 二分答案（固定长度 L，检查是否存在长度 L 且和 ≥ target 的窗口，检验函数随 L 单调）。因为是正数数组，滑动窗口已经是最优，但这个「二分 + 前缀和」的套路在「不好维护窗口状态」的题上很有用。

题目描述#

给你一个整数数组 nums 和一个整数 k，请返回子数组内所有元素的乘积严格小于 k 的连续子数组的数目。

示例：

1
输入：nums = [10,5,2,6], k = 100
2
输出：8
3
解释：8 个乘积小于 100 的子数组分别为：
4
      [10]、[5]、[2]、[6]、[10,5]、[5,2]、[2,6]、[5,2,6]。
5
      注意 [10,5,2] 的乘积是 100，不小于 100，不算。
6

7
输入：nums = [1,2,3], k = 0   输出：0

约束： 1 <= nums.length <= 3 * 10^4，1 <= nums[i] <= 1000，0 <= k <= 10^6。

思路：每个右端点贡献 right - left 个子数组#

窗口状态是 prod。这题和上一题是同一种味道——都是正数，prod 随扩张单调增、随收缩单调减——但答案的形状不一样：

• 上一题要的是「最短的、满足条件的窗口」，是一个窗口本身；
• 这题要的是子数组的个数，得会数。

数的办法是：固定右端点 right - 1，问「以它为结尾的合法子数组有多少个」。因为数组全是正数，乘积随窗口变长只增不减，所以以 right - 1 结尾的合法子数组，起点正好是 left, left+1, …, right-1 这连续的一段，一共 right - left 个。把每个右端点的贡献加起来就是答案。

于是四个填空处：② prod *= nums[right]；③ 收缩条件是 prod >= k（违规就缩，流派 B——prod 越小越合法）；④ 收缩之后才有 right - left 可数，所以在收缩循环之后累加；⑤ prod /= nums[left]。

过程图解#

以 nums = [10,5,2,6]、k = 100 为例：

1
下标   0   1  2  3
2
nums   10  5  2  6

1
加入 10 → prod=10   < 100，窗口 [0,1)
2
          以 nums[0] 结尾的合法子数组：1 - 0 = 1 个 → [10]          累计 1
3
加入 5  → prod=50   < 100，窗口 [0,2)
4
          以 nums[1] 结尾：2 - 0 = 2 个 → [5]、[10,5]                累计 3
5
加入 2  → prod=100  ≥ 100 ← 违规，收缩
6
          移出 10 → prod=10，窗口 [1,3)，1 < 2
7
          以 nums[2] 结尾：3 - 1 = 2 个 → [2]、[5,2]                 累计 5
8
加入 6  → prod=60   < 100，窗口 [1,4)
9
          以 nums[3] 结尾：4 - 1 = 3 个 → [6]、[2,6]、[5,2,6]        累计 8
10

11
答案 8 ✔

注意 prod = 100 那一轮：题目要求严格小于 k，所以 prod >= k 就得缩；缩到 prod = 10 之后，窗口是 [5,2]，prod 的递减性保证了「再缩只会更小」，不会漏解。

代码实现#

1
int numSubarrayProductLessThanK(int *nums, int numsSize, int k) {
2
    long long prod = 1;                 /* 窗口内元素之积 */
3
    int left = 0, right = 0, count = 0;
4

5
    while (right < numsSize) {
6
        prod *= nums[right];            /* ① 右边界元素入窗 */
7
        right++;
8

9
        while (left < right && prod >= k) {   /* ③ 乘积超了就收缩；left < right 防空窗除零 */
10
            prod /= nums[left];               /* ⑤ 左边界元素出窗 */
11
            left++;
12
        }
13
        count += right - left;          /* ④ 以 right-1 结尾、起点落在窗口里的子数组 */
14
    }
15
    return count;
16
}

1
#include <vector>
2
using namespace std;
3

4
class Solution {
5
public:
6
    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
7
        long long prod = 1;
8
        int left = 0, right = 0, count = 0;
9

10
        while (right < (int)nums.size()) {
11
            prod *= nums[right];              // ① 右边界元素入窗
12
            right++;
13

14
            while (left < right && prod >= k) {   // ③ 乘积超了就收缩
15
                prod /= nums[left];               // ⑤ 左边界元素出窗
16
                left++;
17
            }
18
            count += right - left;            // ④ 以 right-1 结尾的合法子数组个数
19
        }
20
        return count;
21
    }
22
};

1
function numSubarrayProductLessThanK(nums, k) {
2
  let prod = 1;
3
  let left = 0, right = 0, count = 0;
4

5
  while (right < nums.length) {
6
    prod *= nums[right];                    // ① 右边界元素入窗
7
    right++;
8

9
    while (left < right && prod >= k) {     // ③ 乘积超了就收缩
10
      prod /= nums[left];                   // ⑤ 左边界元素出窗
11
      left++;
12
    }
13
    count += right - left;                  // ④ 以 right-1 结尾的合法子数组个数
14
  }
15
  return count;
16
}

复杂度#

易错点#

1. 收缩循环里必须带 left < right 这个条件。 当 k <= 1 时（nums[i] >= 1，任何非空子数组的乘积都 ≥ 1），prod >= k 会一直成立，循环会把 left 推到 right。此时若还想 prod /= nums[left]，就会读到窗口外的元素、甚至除到 0 上。加上 left < right 之后，空窗口时自动停下，count += right - left 恰好贡献 0。
2. count += right - left 写在收缩循环之外。 写在里面会把同一轮的多个窗口重复计数。
3. count 会很大。 n = 3 × 10^4 且全部元素为 1、k 很大时，答案是 n(n+1)/2 = 4.5 × 10^8，还在 int 范围内；但如果你把同样的模板套到更大的数据上，记得换 64 位。
4. prod 在 C / C++ 里要留出余量。 收缩是「超了就缩」，所以 prod 的峰值是 k × nums[right] ≈ 10^6 × 1000 = 10^9，int 勉强够，但写 long long 更稳。

题目描述#

给定一个二进制数组 nums 和一个整数 k，假设最多可以翻转 k 个 0，返回执行操作后数组中连续 1 的最大个数。

示例：

1
输入：nums = [1,1,1,0,0,0,1,1,1,1,0], k = 2
2
输出：6
3
解释：把下标 3、4 的两个 0 翻转成 1，得到 [1,1,1,1,1,1,0,1,1,1,1,0]，前 6 位是连续的 1；
4
      把下标 5、10 两个 0 翻转则是后 6 位连续为 1。
5

6
输入：nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], k = 3
7
输出：10

约束： 1 <= nums.length <= 10^5，nums[i] 不是 0 就是 1，0 <= k <= nums.length。

思路：把「窗口里有几个 0」当违规计数#

「翻转最多 k 个 0」等价于：找一个最长的窗口，窗口里的 0 不超过 k 个。因为窗口里的 0 全部翻转成 1 之后，这个窗口就是一整段连续的 1；而窗口外的 0 不用管。

于是窗口状态是 zeros（窗口里 0 的个数）：

• ② 加入 nums[right] 时，如果是 0 就 zeros++；
• ③ 收缩条件是 zeros > k，这是「违规就缩」（流派 B）；
• ④ 收缩之后窗口才是合法的，这时才记录 right - left；
• ⑤ 移出 nums[left] 时，如果是 0 就 zeros--。

这题是「违规就缩」里最干净的一个例子：违规指标和窗口内容一一对应，没有任何花样。真正值得注意的是 ④ 的位置——它必须写在收缩循环之后。

过程图解#

以 nums = [1,1,1,0,0,0,1,1,1,1,0]、k = 2 为例：

1
下标  0  1  2  3  4  5  6  7  8  9  10
2
nums  1  1  1  0  0  0  1  1  1  1  0

1
right=3：窗口 [0,4)=1110，zeros=1 ≤ 2 → best = 4
2
right=4：窗口 [0,5)=11100，zeros=2 ≤ 2 → best = 5
3
right=5：窗口 [0,6)=111000，zeros=3 > 2 ← 违规，收缩
4
  ├ 移出 1（下标 0）→ zeros 仍为 3
5
  ├ 移出 1（下标 1）→ 仍为 3
6
  ├ 移出 1（下标 2）→ 仍为 3
7
  ├ 移出 0（下标 3）→ zeros=2，停止收缩，窗口 [4,6)=00，长度 2
8
  └ 收缩后才记录：长度 2，不更新 best（best 还是 5）
9
right=6：窗口 [4,7)=001，zeros=2 → 长度 3
10
right=7：长度 4      right=8：长度 5      right=9：长度 6 → best = 6
11
right=10：窗口 [4,11)=0011110，zeros=3 > 2 ← 违规，收缩
12
  ├ 移出 0（下标 4）→ zeros=2，停止收缩，窗口 [5,11)
13
  └ 长度 5，不更新 best
14

15
答案 6 ✔

看清楚 ③ 和 ④ 的关系：违规的窗口永远参与不了计分。收缩循环的作用就是把窗口修回到 zeros <= k，修好之后再量长度。

代码实现#

1
int longestOnes(int *nums, int numsSize, int k) {
2
    int left = 0, right = 0;
3
    int zeros = 0;                      /* 窗口里有几个 0 */
4
    int best = 0;
5

6
    while (right < numsSize) {
7
        if (nums[right] == 0) zeros++;  /* ① 右边界入窗，顺带数 0 */
8
        right++;
9

10
        while (zeros > k) {             /* ③ 0 太多了，收缩到刚刚够用 */
11
            if (nums[left] == 0) zeros--;
12
            left++;
13
        }
14
        if (right - left > best)        /* ④ 收缩之后，窗口一定是合法的，这时才记录 */
15
            best = right - left;
16
    }
17
    return best;
18
}

1
#include <vector>
2
using namespace std;
3

4
class Solution {
5
public:
6
    int longestOnes(vector<int>& nums, int k) {
7
        int left = 0, right = 0;
8
        int zeros = 0;                      // 窗口里有几个 0
9
        int best = 0;
10

11
        while (right < (int)nums.size()) {
12
            if (nums[right] == 0) zeros++;  // ① 右边界入窗，顺带数 0
13
            right++;
14

15
            while (zeros > k) {             // ③ 0 太多了，收缩到刚刚够用
16
                if (nums[left] == 0) zeros--;
17
                left++;
18
            }
19
            if (right - left > best)        // ④ 收缩之后窗口必然合法，这时才记录
20
                best = right - left;
21
        }
22
        return best;
23
    }
24
};

1
function longestOnes(nums, k) {
2
  let left = 0, right = 0;
3
  let zeros = 0;                      // 窗口里有几个 0
4
  let best = 0;
5

6
  while (right < nums.length) {
7
    if (nums[right] === 0) zeros++;   // ① 右边界入窗，顺带数 0
8
    right++;
9

10
    while (zeros > k) {               // ③ 0 太多了，收缩到刚刚够用
11
      if (nums[left] === 0) zeros--;
12
      left++;
13
    }
14
    if (right - left > best)          // ④ 收缩之后窗口必然合法，这时才记录
15
      best = right - left;
16
  }
17
  return best;
18
}

复杂度#

易错点#

1. k = 0 是合法输入。 此时窗口里一个 0 都不能有，答案可能为 0（比如 nums = [0,0]），所以 best 的初值取 0 是对的，不要取 -1 或者 n + 1。
2. 记录答案放在收缩循环之后。 放进去会记到 zeros > k 的窗口，答案偏大。
3. 不要把「翻转」真的写出到数组上。 这题只要求个数，窗口里的 0 视作可翻转即可，不需要真的改 nums——nums 一旦被改，后面的窗口统计就全乱了。
4. zeros > k 而不是 zeros >= k。 最多可以翻转 k 个，所以 zeros == k 是合法的。

题目描述#

给你一个字符串 s 和一个整数 k。你可以选择字符串中的任一字符，并将其更改为任何其他大写英文字母，该操作最多可执行 k 次。返回执行上述操作之后，包含相同字母的最长子字符串的长度。

示例：

1
输入：s = "ABAB", k = 2     输出：4
2
输入：s = "AABABBA", k = 1  输出：4
3
解释：把中间的 'A' 替换为 'B'，得到 "AABBBBA"，其中子串 "BBBB" 有最长重复字母，长度为 4。

约束： 1 <= s.length <= 10^5，s 仅由大写英文字母组成，0 <= k <= s.length。

思路：窗口长度 − 窗口内最多字符的个数 ≤ k#

这题和上一题是同一道题换了层皮：

道理是：想让一个窗口整体变成同一个字母，代价最小的改法是「留下窗口里出现最多的那种字母，其余的全都改掉」，所以要替换的字符数就是 窗口长度 - 最高频字符的次数。它不超过 k 就说明这个窗口可行。

维护的状态是 cnt[26] 和 maxCnt（窗口里出现最多的那个字符出现了几次）。③ 收缩条件是 right - left - maxCnt > k。

这里有个关键细节：maxCnt 只在加入字符时更新，从不因为移出字符而减小。也就是说它记的是「历史上出现过的最大频次」，不是「当前窗口内的最大频次」。这样写有两个好处：窗口长度变成单调不降的，收缩从 while 退化成 if（每轮最多缩一格）；同时真实答案也不会被算错。为什么可以这样，见下面的易错点。

过程图解#

以 s = "AABABBA"、k = 1 为例：

1
下标  0  1  2  3  4  5  6
2
s     A  A  B  A  B  B  A

1
加入下标 0 的 A：[0,1)=A，cnt[A]=1，maxCnt=1
2
  长度 1 - 1 = 0 ≤ 1 → 不需要替换 → 窗口长度 1
3
加入下标 1 的 A：[0,2)=AA，cnt[A]=2，maxCnt=2
4
  2 - 2 = 0 ≤ 1 → 长度 2
5
加入下标 2 的 B：[0,3)=AAB，cnt[B]=1，maxCnt 仍为 2
6
  3 - 2 = 1 ≤ 1 → 长度 3（把 B 改成 A）
7
加入下标 3 的 A：[0,4)=AABA，cnt[A]=3，maxCnt=3
8
  4 - 3 = 1 ≤ 1 → 长度 4（把 B 改成 A）      best = 4
9
加入下标 4 的 B：[0,5)=AABAB，cnt[B]=2，maxCnt 仍为 3
10
  5 - 3 = 2 > 1 ← 违规，缩一格：cnt[A]-- → cnt[A]=2，窗口 [1,5)=ABAB，长度 4
11
  4 - 3 = 1 ≤ 1 → 长度 4，不更新 best
12
加入下标 5 的 B：[1,6)=ABABB，cnt[B]=3，maxCnt 仍为 3
13
  5 - 3 = 2 > 1 ← 违规，缩一格：cnt[A]-- → cnt[A]=1，窗口 [2,6)=BABB，长度 4
14
  4 - 3 = 1 ≤ 1 → 长度 4，不更新 best
15
加入下标 6 的 A：[2,7)=BABBA，cnt[A]=2，maxCnt 仍为 3
16
  5 - 3 = 2 > 1 ← 违规，缩一格：cnt[B]-- → cnt[B]=2，窗口 [3,7)=ABBA，长度 4
17
  4 - 3 = 1 ≤ 1 → 长度 4，不更新 best
18

19
答案 4 ✔

注意后面三轮里 maxCnt = 3 已经不是当前窗口的真实最高频次了（[3,7) 里 A 和 B 各 2 个），但窗口长度被稳定在 4，best 也就停在 4——而 4 确实是正确答案。

代码实现#

1
#include <string.h>
2

3
int characterReplacement(char *s, int k) {
4
    int cnt[26] = {0};
5
    int n = (int)strlen(s);
6
    int left = 0, right = 0;
7
    int maxCnt = 0;                 /* 历史上出现过的最大频次，只增不减 */
8
    int best = 0;
9

10
    while (right < n) {
11
        int c = s[right] - 'A';
12
        cnt[c]++;                   /* ① 右边界入窗 */
13
        if (cnt[c] > maxCnt) maxCnt = cnt[c];
14
        right++;
15

16
        if (right - left - maxCnt > k) {   /* ③ 需要替换的字符超过了 k */
17
            cnt[s[left] - 'A']--;          /* ⑤ 左边界出窗 */
18
            left++;
19
        }
20
        if (right - left > best) best = right - left;   /* ④ 收缩后记录 */
21
    }
22
    return best;
23
}

1
#include <string>
2
using namespace std;
3

4
class Solution {
5
public:
6
    int characterReplacement(string s, int k) {
7
        int cnt[26] = {0};
8
        int left = 0, right = 0;
9
        int maxCnt = 0;                 // 历史上出现过的最大频次，只增不减
10
        int best = 0;
11

12
        while (right < (int)s.size()) {
13
            int c = s[right] - 'A';
14
            cnt[c]++;                   // ① 右边界入窗
15
            if (cnt[c] > maxCnt) maxCnt = cnt[c];
16
            right++;
17

18
            if (right - left - maxCnt > k) {   // ③ 需要替换的字符超过了 k
19
                cnt[s[left] - 'A']--;          // ⑤ 左边界出窗
20
                left++;
21
            }
22
            if (right - left > best) best = right - left;   // ④ 收缩后记录
23
        }
24
        return best;
25
    }
26
};

1
function characterReplacement(s, k) {
2
  const cnt = new Array(26).fill(0);
3
  let left = 0, right = 0;
4
  let maxCnt = 0;                 // 历史上出现过的最大频次，只增不减
5
  let best = 0;
6

7
  while (right < s.length) {
8
    const c = s.charCodeAt(right) - 65;
9
    cnt[c]++;                     // ① 右边界入窗
10
    if (cnt[c] > maxCnt) maxCnt = cnt[c];
11
    right++;
12

13
    if (right - left - maxCnt > k) {        // ③ 需要替换的字符超过了 k
14
      cnt[s.charCodeAt(left) - 65]--;       // ⑤ 左边界出窗
15
      left++;
16
    }
17
    if (right - left > best) best = right - left;   // ④ 收缩后记录
18
  }
19
  return best;
20
}

复杂度#

易错点#

1. maxCnt 不是「当前窗口的最大频次」，而是「历史最大频次」。 它只增不减，所以 长度 - maxCnt <= k 只能用来控制窗口长度，不能理解为「当前窗口一定合法」。配上 if（每轮最多缩一格、窗口长度单调不降）是主流写法；如果改成 while，就必须在收缩时重新统计窗口内的真实最高频次，否则判断条件和「窗口合法」不再等价。（顺带说一句：网上流传的「while + 只增不减的 maxCnt 一定是错的」这个说法我没能验证出来——把两种写法在 64 万组穷举数据上跑了一遍（长度 ≤ 9 的三字母串 118092 组 + 长度 ≤ 16 的二字母串 524280 组），结果完全一致。稳妥起见，还是用 if 版。）
2. cnt 的下标要减去 'A'（65），别直接拿字符当下标。 C / C++ 里 cnt[c] 会越界；JS 里 cnt[c] 会变成 undefined，++ 之后是 NaN，一路静默算错。
3. 收缩要写在更新答案之前。 和 1004 一样，违规窗口不能参与计分。
4. 窗口里只留「成本最低」的那个字母作为保留字符。 也就是出现次数最多的那个——别去枚举「保留哪个字母」，maxCnt 已经替你选好了。