不定长滑动窗口（基础）

noruta

于 2025-05-03 16:25:18 发布

阅读量620

点赞数 19

分类专栏： python # 算法文章标签： python 力扣算法

本文链接：https://blog.csdn.net/2301_82051744/article/details/147684652

版权

python 同时被 2 个专栏收录

80 篇文章

订阅专栏

算法

69 篇文章

订阅专栏

选自灵神题单，不定长滑动窗口 2.1.1 基础。

3. 无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的最长子串的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        from collections import defaultdict

        win = defaultdict(int)  # 滑动窗口内的字符统计
        left = 0
        ans = 0
        for right, x in enumerate(s):
            win[x] += 1  # 元素进入窗口

            while win[x] > 1:
                win[s[left]] -= 1  # 元素出窗口
                left += 1

            ans = max(ans, right - left + 1)  # 记录答案
        return ans

3090. 每个字符最多出现两次的最长子字符串

给你一个字符串 s ，请找出满足每个字符最多出现两次的最长子字符串，并返回该子字符串的最大长度。

示例 1：

输入： s = “bcbbbcba”

输出： 4

解释：

以下子字符串长度为 4，并且每个字符最多出现两次："bcbbbcba"。

示例 2：

输入： s = “aaaa”

输出： 2

解释：

以下子字符串长度为 2，并且每个字符最多出现两次："aaaa"。

class Solution:
    def maximumLengthSubstring(self, s: str) -> int:
        from collections import defaultdict

        win = defaultdict(int)
        left = 0
        ans = 0
        for right, x in enumerate(s):
            win[x] += 1

            while win[x] > 2:
                win[s[left]] -= 1
                left += 1

            ans = max(ans, right - left + 1)
        return ans

1493. 删掉一个元素以后全为 1 的最长子数组

给你一个二进制数组 nums ，你需要从中删掉一个元素。

请你在删掉元素的结果数组中，返回最长的且只包含 1 的非空子数组的长度。

如果不存在这样的子数组，请返回 0 。

提示 1：

输入：nums = [1,1,0,1]
输出：3
解释：删掉位置 2 的数后，[1,1,1] 包含 3 个 1 。

示例 2：

输入：nums = [0,1,1,1,0,1,1,0,1]
输出：5
解释：删掉位置 4 的数字后，[0,1,1,1,1,1,0,1] 的最长全 1 子数组为 [1,1,1,1,1] 。

示例 3：

输入：nums = [1,1,1]
输出：2
解释：你必须要删除一个元素。

class Solution:
    def longestSubarray(self, nums: List[int]) -> int:
        ans = 0
        left = 0
        t = 1  # 可供删除的次数
        for right, x in enumerate(nums):
            if x == 0:
                t -= 1

            while t < 0:  # 说明当前元素为0，且滑动窗口内前面的元素也存在为0的元素
                if nums[left] == 0:
                    t += 1
                left += 1

            ans = max(ans, right - left)  # 不加1是因为没有加上删除的那个0，抵消了
        return ans

1208. 尽可能使字符串相等

给你两个长度相同的字符串，s 和 t。

将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销（开销可能为 0），也就是两个字符的 ASCII 码值的差的绝对值。

用于变更字符串的最大预算是 maxCost。在转化字符串时，总开销应当小于等于该预算，这也意味着字符串的转化可能是不完全的。

如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串，则返回可以转化的最大长度。

如果 s 中没有子字符串可以转化成 t 中对应的子字符串，则返回 0。

示例 1：

输入：s = "abcd", t = "bcdf", maxCost = 3
输出：3
解释：s 中的 "abc" 可以变为 "bcd"。开销为 3，所以最大长度为 3。

示例 2：

输入：s = "abcd", t = "cdef", maxCost = 3
输出：1
解释：s 中的任一字符要想变成 t 中对应的字符，其开销都是 2。因此，最大长度为 1。

示例 3：

输入：s = "abcd", t = "acde", maxCost = 0
输出：1
解释：a -> a, cost = 0，字符串未发生变化，所以最大长度为 1。

class Solution:
    def equalSubstring(self, s: str, t: str, maxCost: int) -> int:
        ans = 0
        left = 0
        for right in range(len(s)):
            maxCost -= abs(ord(s[right]) - ord(t[right]))

            while maxCost < 0:
                maxCost += abs(ord(s[left]) - ord(t[left]))
                left += 1
                
            ans = max(ans, right - left + 1)
        return ans

904. 水果成篮

你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果种类。

你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：

你只有两个篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
你可以选择任意一棵树开始采摘，你必须从每棵树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。

给你一个整数数组 fruits ，返回你可以收集的水果的最大数目。

示例 1：

输入：fruits = [1,2,1]
输出：3
解释：可以采摘全部 3 棵树。

示例 2：

输入：fruits = [0,1,2,2]
输出：3
解释：可以采摘 [1,2,2] 这三棵树。
如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。

示例 3：

输入：fruits = [1,2,3,2,2]
输出：4
解释：可以采摘 [2,3,2,2] 这四棵树。
如果从第一棵树开始采摘，则只能采摘 [1,2] 这两棵树。

示例 4：

输入：fruits = [3,3,3,1,2,1,1,2,3,3,4]
输出：5
解释：可以采摘 [1,2,1,1,2] 这五棵树。

class Solution:
    def totalFruit(self, fruits: List[int]) -> int:
        from collections import defaultdict

        win = defaultdict(int)
        left = 0
        ans = 0
        for right, x in enumerate(fruits):
            win[x] += 1

            while len(win) > 2:
                win[fruits[left]] -= 1
                if win[fruits[left]] == 0:
                    del win[fruits[left]]  # 删除这个水果的种类
                left += 1

            ans = max(ans, right - left + 1)
        return ans

1695. 删除子数组的最大得分

给你一个正整数数组 nums ，请你从中删除一个含有 若干不同元素 的子数组**。**删除子数组的得分就是子数组各元素之和。

返回 只删除一个 子数组可获得的 最大得分 。

如果数组 b 是数组 a 的一个连续子序列，即如果它等于 a[l],a[l+1],...,a[r] ，那么它就是 a 的一个子数组。

示例 1：

输入：nums = [4,2,4,5,6]
输出：17
解释：最优子数组是 [2,4,5,6]

示例 2：

输入：nums = [5,2,1,2,5,2,1,2,5]
输出：8
解释：最优子数组是 [5,2,1] 或 [1,2,5]

class Solution:
    def maximumUniqueSubarray(self, nums: List[int]) -> int:
        from collections import defaultdict

        win = defaultdict(int)      # 统计滑动窗口内元素个数
        left = ans = 0
        tmp = 0     # 记录滑动窗口内元素总和
        for right, x in enumerate(nums):
            win[x] += 1
            tmp += x

            while win[x] > 1:
                win[nums[left]] -= 1
                tmp -= nums[left]
                left += 1

            ans = max(ans, tmp)
        return ans

2958. 最多 K 个重复元素的最长子数组

给你一个整数数组 nums 和一个整数 k 。

一个元素 x 在数组中的频率指的是它在数组中的出现次数。

如果一个数组中所有元素的频率都 小于等于 k ，那么我们称这个数组是好数组。

请你返回 nums 中 最长好 子数组的长度。

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

示例 1：

输入：nums = [1,2,3,1,2,3,1,2], k = 2
输出：6
解释：最长好子数组是 [1,2,3,1,2,3] ，值 1 ，2 和 3 在子数组中的频率都没有超过 k = 2 。[2,3,1,2,3,1] 和 [3,1,2,3,1,2] 也是好子数组。
最长好子数组的长度为 6 。

示例 2：

输入：nums = [1,2,1,2,1,2,1,2], k = 1
输出：2
解释：最长好子数组是 [1,2] ，值 1 和 2 在子数组中的频率都没有超过 k = 1 。[2,1] 也是好子数组。
最长好子数组的长度为 2 。

示例 3：

输入：nums = [5,5,5,5,5,5,5], k = 4
输出：4
解释：最长好子数组是 [5,5,5,5] ，值 5 在子数组中的频率没有超过 k = 4 。
最长好子数组的长度为 4 。

class Solution:
    def maxSubarrayLength(self, nums: List[int], k: int) -> int:
        from collections import defaultdict

        win = defaultdict(int)      # 统计滑动窗口内元素个数
        left = ans = 0
        for right, x in enumerate(nums):
            win[x] += 1

            while win[x] > k:
                win[nums[left]] -= 1
                left += 1

            ans = max(ans, right-left+1)
        return ans

2024. 考试的最大困扰度

一位老师正在出一场由 n 道判断题构成的考试，每道题的答案为 true （用 'T' 表示）或者 false （用 'F' 表示）。老师想增加学生对自己做出答案的不确定性，方法是 最大化 有 连续相同 结果的题数。（也就是连续出现 true 或者连续出现 false）。

给你一个字符串 answerKey ，其中 answerKey[i] 是第 i 个问题的正确结果。除此以外，还给你一个整数 k ，表示你能进行以下操作的最多次数：

每次操作中，将问题的正确答案改为 'T' 或者 'F' （也就是将 answerKey[i] 改为 'T' 或者 'F' ）。

请你返回在不超过 k 次操作的情况下，最大连续 'T' 或者 'F' 的数目。

示例 1：

输入：answerKey = "TTFF", k = 2
输出：4
解释：我们可以将两个 'F' 都变为 'T' ，得到 answerKey = "TTTT" 。
总共有四个连续的 'T' 。

示例 2：

输入：answerKey = "TFFT", k = 1
输出：3
解释：我们可以将最前面的 'T' 换成 'F' ，得到 answerKey = "FFFT" 。
或者，我们可以将第二个 'T' 换成 'F' ，得到 answerKey = "TFFF" 。
两种情况下，都有三个连续的 'F' 。

示例 3：

输入：answerKey = "TTFTTFTT", k = 1
输出：5
解释：我们可以将第一个 'F' 换成 'T' ，得到 answerKey = "TTTTTFTT" 。
或者我们可以将第二个 'F' 换成 'T' ，得到 answerKey = "TTFTTTTT" 。
两种情况下，都有五个连续的 'T' 。

class Solution:
    def maxConsecutiveAnswers(self, answerKey: str, k: int) -> int:
        # 求滑动窗口内T和F的个数最多为k时的最大长度，如果两个同时都超过k，则满足不了要求
        win = {"T": 0, "F": 0}
        left = ans = 0
        for right, x in enumerate(answerKey):
            win[x] += 1

            while win["T"] > k and win["F"] > k:
                win[answerKey[left]] -= 1
                left += 1

            ans = max(ans, right - left + 1)
        return ans

1004. 最大连续1的个数 III

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

示例 1：

输入：nums = [1,1,1,0,0,0,1,1,1,1,0], K = 2
输出：6
解释：[1,1,1,0,0,1,1,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 6。

示例 2：

输入：nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
输出：10
解释：[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
粗体数字从 0 翻转到 1，最长的子数组长度为 10。

class Solution:
    def longestOnes(self, nums: List[int], k: int) -> int:
        left = ans = 0
        for right, x in enumerate(nums):
            if x == 0:
                k -= 1
            while k < 0:
                if nums[left] == 0:
                    k += 1
                left += 1
            ans = max(ans, right - left + 1)
        return ans

1658. 将 x 减到 0 的最小操作数

给你一个整数数组 nums 和一个整数 x 。每一次操作时，你应当移除数组 nums 最左边或最右边的元素，然后从 x 中减去该元素的值。请注意，需要修改数组以供接下来的操作使用。

如果可以将 x 恰好减到 0 ，返回 最小操作数 ；否则，返回 -1 。

示例 1：

输入：nums = [1,1,4,2,3], x = 5
输出：2
解释：最佳解决方案是移除后两个元素，将 x 减到 0 。

示例 2：

输入：nums = [5,6,7,8,9], x = 4
输出：-1

示例 3：

输入：nums = [3,2,20,1,1,3], x = 10
输出：5
解释：最佳解决方案是移除后三个元素和前两个元素（总共 5 次操作），将 x 减到 0 。

class Solution:
    def minOperations(self, nums: List[int], x: int) -> int:
        # 本质是求总和为sum(nums)-x的最长滑动窗口长度
        left = 0
        ans = -1
        sum_ = sum(nums) - x
        if sum_ < 0:
            return -1   # 由于数组元素都为正数，一定找不出元素总和为负数的子数组
            
        for right, x in enumerate(nums):
            sum_ -= x

            while sum_ < 0:
                sum_ += nums[left]
                left += 1

            if sum_ == 0:
                ans = max(ans, right - left + 1)
        return len(nums) - ans if ans != -1 else -1