Leetcode Day16 定长滑动窗口

模版三部曲

我总结成三步：入-更新-出。

入：下标为 i 的元素进入窗口，更新相关统计量。如果 i<k−1 则重复第一步。
更新：更新答案。一般是更新最大值/最小值。
出：下标为 i−k+1 的元素离开窗口，更新相关统计量。

1456 定长子串中最多元音个数

给你字符串 s 和整数 k 。

请返回字符串 s 中长度为 k 的单个子字符串中可能包含的最大元音字母数。

英文中的 元音字母 为（a, e, i, o, u）。

输入：s = “abciiidef”, k = 3
输出：3
解释：子字符串 “iii” 包含 3 个元音字母。

class Solution:
    def maxVowels(self, s: str, k: int) -> int:
        ans = vowel = 0
        for i, c in enumerate(s):
            # 1. 进入窗口
            if c in "aeiou":
                vowel += 1
            if i < k - 1:  # 窗口大小不足 k
                continue
            # 2. 更新答案
            ans = max(ans, vowel)
            # 3. 离开窗口
            if s[i - k + 1] in "aeiou":
                vowel -= 1
        return ans

2379 得到 K 个黑块的最少涂色次数

给你一个长度为 n 下标从 0 开始的字符串 blocks ，blocks[i] 要么是 ‘W’ 要么是 ‘B’ ，表示第 i 块的颜色。字符 ‘W’ 和 ‘B’ 分别表示白色和黑色。

给你一个整数 k ，表示想要 连续 黑色块的数目。

每一次操作中，你可以选择一个白色块将它 涂成 黑色块。

请你返回至少出现 一次 连续 k 个黑色块的 最少 操作次数。
输入：blocks = “WBBWWBBWBW”, k = 7
输出：3
解释：
一种得到 7 个连续黑色块的方法是把第 0 ，3 和 4 个块涂成黑色。
得到 blocks = “BBBBBBBWBW” 。

class Solution:
    def minimumRecolors(self, blocks: str, k: int) -> int:
        W_count = 0
        B_count = 0
        ans = inf
        for i in range(len(blocks)):
            c = blocks[i]
            if c == "W":
                W_count += 1
            if i < k - 1:
                continue
            ans = min(ans, W_count)
            if blocks[i - k + 1] == "W":
                W_count -= 1
        return ans         

1052

示例 1：

输入：customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], minutes = 3
输出：16
解释：书店老板在最后 3 分钟保持冷静。
感到满意的最大客户数量 = 1 + 1 + 1 + 1 + 7 + 5 = 16.

主要是翻译题目, 转换成熟悉的题
https://leetcode.cn/problems/grumpy-bookstore-owner/solutions/616238/yong-mi-mi-ji-qiao-wan-liu-zhu-zui-duo-d-py41/

class Solution:
    def maxSatisfied(self, customers: List[int], grumpy: List[int], minutes: int) -> int:
        always_satisfied = sum(c for c, g in zip(customers, grumpy) if g == 0)
        current_extra = 0
        max_extra = 0
        for i in range(len(customers)):
            if grumpy[i] == 1:
                current_extra += customers[i]
            if i < minutes - 1:
                continue
            max_extra = max(max_extra, current_extra)
            if grumpy[i - minutes + 1] == 1:
                current_extra -= customers[i - minutes + 1]
            print(i, current_extra)
        return always_satisfied + max_extra

2841. 几乎唯一子数组的最大和

给你一个整数数组 nums 和两个正整数 m 和 k 。

请你返回 nums 中长度为 k 的 几乎唯一 子数组的 最大和 ，如果不存在几乎唯一子数组，请你返回 0 。

如果 nums 的一个子数组有至少 m 个互不相同的元素，我们称它是 几乎唯一 子数组。

子数组指的是一个数组中一段连续 非空 的元素序列。

class Solution:
    def maxSum(self, nums: List[int], m: int, k: int) -> int:
        ans = 0 
        cur_sum = 0
        count = {}
        for i in range(len(nums)):
            count[nums[i]] = count.get(nums[i], 0) + 1
            cur_sum += nums[i]
            if i < k - 1:
                continue
            if len(count) >= m:
                ans = max(ans, cur_sum)
            cur_sum -= nums[i - k + 1]
            count[nums[i - k +1]] -= 1
            if count[nums[i - k + 1]] == 0:
                count.pop(nums[i - k + 1])
        return ans

1297 子串的最大出现次数

给你一个字符串 s ，请你返回满足以下条件且出现次数最大的 任意 子串的出现次数：

子串中不同字母的数目必须小于等于 maxLetters 。
子串的长度必须大于等于 minSize 且小于等于 maxSize 。