Leetcode_3-09

---

91. 解码方法

一条包含字母 A-Z 的消息通过以下映射进行了 编码 ：

"1" -> 'A' "2" -> 'B' ... "25" -> 'Y' "26" -> 'Z'

然而，在 解码 已编码的消息时，你意识到有许多不同的方式来解码，因为有些编码被包含在其它编码当中（"2" 和 "5" 与 "25"）。

例如，"11106" 可以映射为：

• "AAJF" ，将消息分组为 (1, 1, 10, 6)
• "KJF" ，将消息分组为 (11, 10, 6)
• 消息不能分组为 (1, 11, 06) ，因为 "06" 不是一个合法编码（只有 "6" 是合法的）。

注意，可能存在无法解码的字符串。

给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。如果没有合法的方式解码整个字符串，返回 0。

题目数据保证答案肯定是一个 32 位 的整数。

示例 1：

输入：s = "12"
输出：2
解释：它可以解码为 "AB"（1 2）或者 "L"（12）。

示例 2：

输入：s = "226"
输出：3
解释：它可以解码为 "BZ" (2 26), "VF" (22 6), 或者 "BBF" (2 2 6) 。

示例 3：

输入：s = "06"
输出：0
解释："06" 无法映射到 "F" ，因为存在前导零（"6" 和 "06" 并不等价）。

提示：

• 1 <= s.length <= 100
• s 只包含数字，并且可能包含前导零。

动态规划

class Solution:
    def numDecodings(self, s: str) -> int:
        n = len(s)
        dp = [0 for _ in range(len(s)+1)]
        dp[0] = 1

        def legal(s):
            if s[0] == "0":
                return False
            elif len(s) > 1 and (s[0] >= "3" or (s[0] == "2" and s[1] >= "7")):
                return False
            
            return True
            

        for i in range(1,n+1):
            for k in range(1,2+1):
                if i >= k and legal(s[i-k:i]):
                    dp[i] += dp[i-k]

        return dp[-1]

---

---

100. 相同的树

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1：

输入：p = [1,2,3], q = [1,2,3]
输出：true

示例 2：

输入：p = [1,2], q = [1,null,2]
输出：false

示例 3：

输入：p = [1,2,1], q = [1,1,2]
输出：false

提示：

• 两棵树上的节点数目都在范围 [0, 100] 内
• -104 <= Node.val <= 104

递归法

0ms 击败100.00%

from typing import Optional

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
        # 如果两者都为空，则相同
        if not p and not q:
            return True
        # 如果其中一个为空，则不同
        if not p or not q:
            return False
        # 如果当前节点的值不同，则树不同
        if p.val != q.val:
            return False
        # 递归检查左子树和右子树
        return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)

队列法

3ms 击败2.57%

class Solution:
    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
        p_queue = []
        q_queue = []

        if p:
            p_queue.append(p)
        if q:
            q_queue.append(q)

        while p_queue and q_queue:
            tmp1 = p_queue.pop()
            tmp2 = q_queue.pop()

            if tmp1.val == tmp2.val:
                if not((tmp1.left != None) ^ (tmp2.left != None)):
                    if tmp1.left != None:
                        p_queue.append(tmp1.left)
                        q_queue.append(tmp2.left)
                else:
                    return False

                if not((tmp1.right != None) ^ (tmp2.right != None)):
                    if tmp1.right != None:
                        p_queue.append(tmp1.right)
                        q_queue.append(tmp2.right)
                else:
                    return False

            else:
                return False
        
        if p_queue or q_queue:
            # 如果同时遍历结束依然有其中一棵树不为空,说明长度不一致
            return False
        
        return True



        

---

198. 打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。

示例 2：

输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
     偷窃到的最高金额 = 2 + 9 + 1 = 12 。

提示：

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 400

动态规划

class Solution:
    def rob(self, nums: List[int]) -> int:
        dp = [0 for _ in range(len(nums))]

        if len(nums) == 0:
            return 0
        if len(nums) <= 2:
            return max(nums)

        dp[0] = nums[0]
        dp[1] = max(dp[0],nums[1])

        for i in range(2,len(nums)):
            dp[i] = max(nums[i] + dp[i-2], dp[i-1])

        return dp[-1]

---

213. 打家劫舍 II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

示例 1：

输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

示例 2：

输入：nums = [1,2,3,1]
输出：4
解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
     偷窃到的最高金额 = 1 + 3 = 4 。

示例 3：

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

提示：

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 1000

动态规划

class Solution:
    def rob(self, nums: List[int]) -> int:

        def rob2(nums):
            dp = [0 for _ in range(len(nums))]

            if len(nums) == 0:
                return 0
            if len(nums) <= 2:
                return max(nums)

            dp[0] = nums[0]
            dp[1] = max(dp[0],nums[1])

            for i in range(2,len(nums)):
                dp[i] = max(nums[i] + dp[i-2], dp[i-1])

            return dp[-1]

        
        if len(nums) < 2:
            return nums[0]

        return max(rob2(nums[1:]), rob2(nums[:-1]))

---

279. 完全平方数

给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。

完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。

示例 1：

输入：n = 12
输出：3 
解释：12 = 4 + 4 + 4

示例 2：

输入：n = 13
输出：2
解释：13 = 4 + 9

提示：

• 1 <= n <= 104

动态规划

class Solution:
    def numSquares(self, n: int) -> int:
        # coin为前100个平方数的零钱兑换问题
        coins = [i**2 for i in range(1,101)]

        dp = [float("inf") for _ in range(n+1)]
        dp[0] = 0

        for coin in coins:
            for j in range(coin,n+1):
                dp[j] = min(dp[j],dp[j-coin]+1)

        return dp[-1]

记忆化搜索

# 写在外面，多个测试数据之间可以共享，减少计算量
@cache  # 缓存装饰器，避免重复计算 dfs 的结果（记忆化）
def dfs(i: int, j: int) -> int:
    if i == 0:
        return inf if j else 0
    if j < i * i:
        return dfs(i - 1, j)  # 只能不选
    return min(dfs(i - 1, j), dfs(i, j - i * i) + 1)  # 不选 vs 选

class Solution:
    def numSquares(self, n: int) -> int:
        return dfs(isqrt(n), n)

---

322. 零钱兑换

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的。

示例 1：

输入：coins = [1, 2, 5], amount = 11
输出：3 
解释：11 = 5 + 5 + 1

示例 2：

输入：coins = [2], amount = 3
输出：-1

示例 3：

输入：coins = [1], amount = 0
输出：0

提示：

• 1 <= coins.length <= 12
• 1 <= coins[i] <= 231 - 1
• 0 <= amount <= 104

完全背包问题解法

855ms 击败56.24%

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        n = len(coins)
        dp = [float("inf") for _ in range(amount+1)]
        dp[0] = 0

        for coin in coins:
            for j in range(coin, amount+1):
                dp[j] = min(dp[j],dp[j-coin] + 1)

        return dp[-1] if dp[-1] != float("inf") else -1

---

337. 打家劫舍 III

小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。

除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。

给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。

示例 1:

输入: root = [3,2,3,null,3,null,1]
输出: 7 
解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7

示例 2:

输入: root = [3,4,5,1,3,null,1]
输出: 9
解释: 小偷一晚能够盗取的最高金额 4 + 5 = 9

提示：

• 树的节点数在 [1, 104] 范围内
• 0 <= Node.val <= 104

记忆化递归

11ms 击败11.38%

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def rob(self, root: Optional[TreeNode]) -> int:
        
        @cache
        def rob_handler(root):
            if root == None:
                return 0

            ans1 = rob_handler(root.left) + rob_handler(root.right)
            ans2 = root.val + (rob_handler(root.left.left) + rob_handler(root.left.right) if root.left != None else 0) + (rob_handler(root.right.left) + rob_handler(root.right.right) if root.right != None else 0)

            return max(ans1, ans2)

        return rob_handler(root)

递归解法

超出时间限制

class Solution:
    def rob(self, root: Optional[TreeNode]) -> int:
        
        def rob_handler(root):
            if root == None:
                return 0

            ans1 = rob_handler(root.left) + rob_handler(root.right)
            ans2 = root.val + (rob_handler(root.left.left) + rob_handler(root.left.right) if root.left != None else 0) + (rob_handler(root.right.left) + rob_handler(root.right.right) if root.right != None else 0)

            return max(ans1, ans2)

        return rob_handler(root)

---

377. 组合总和 Ⅳ

给你一个由 不同 整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。

题目数据保证答案符合 32 位整数范围。

示例 1：

输入：nums = [1,2,3], target = 4
输出：7
解释：
所有可能的组合为：
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)
请注意，顺序不同的序列被视作不同的组合。

示例 2：

输入：nums = [9], target = 3
输出：0

提示：

• 1 <= nums.length <= 200
• 1 <= nums[i] <= 1000
• nums 中的所有元素 互不相同
• 1 <= target <= 1000

**进阶：**如果给定的数组中含有负数会发生什么？问题会产生何种变化？如果允许负数出现，需要向题目中添加哪些限制条件？

动态规划

from typing import List

class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        # 背包问题

        dp = [0 for _ in range(target + 1)]
        dp[0] = 1
        
        for j in range(1, target+1):
            for i in range(len(nums)):
                if j >= nums[i]:
                    dp[j] += dp[j-nums[i]]

        return dp[-1]
    

---

474. 一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

示例 1：

输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。
其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。

示例 2：

输入：strs = ["10", "0", "1"], m = 1, n = 1
输出：2
解释：最大的子集是 {"0", "1"} ，所以答案是 2 。

提示：

• 1 <= strs.length <= 600
• 1 <= strs[i].length <= 100
• strs[i] 仅由 '0' 和 '1' 组成
• 1 <= m, n <= 100

动态规划(单层迭代：需要倒序遍历来维护)

class Solution:
    def findMaxForm(self, strs, m: int, n: int) -> int:
        k = len(strs)
        dp = [[0 for _ in range(n+1)] for _ in range(m+1)]

        strs_hash = []
        for s in strs:
            strs_hash.append([s.count("0"),s.count("1")])
        weight_i = lambda x:strs_hash[x][0]
        weight_j = lambda x:strs_hash[x][1]

        # 遍历
        for k in range(len(strs)):
            for i in range(m, weight_i(k)-1, -1):
                for j in range(n, weight_j(k)-1, -1):
                    dp[i][j] = max(dp[i-weight_i(k)][j-weight_j(k)] + 1,dp[i][j])

        return dp[-1][-1]

动态规划(加一层维度)

class Solution:
    def findMaxForm(self, strs, m: int, n: int) -> int:
        k = len(strs)
        dp = [[[0 for _ in range(n+1)] for _ in range(m+1)] for _ in range(k)]

        strs_hash = []
        for s in strs:
            strs_hash.append([s.count("0"),s.count("1")])

        # 遍历
        for i in range(m+1):
            for j in range(n+1):
                if i == 0 and j == 0:
                    pass
                if i-strs_hash[0][0] >= 0 and j-strs_hash[0][1] >= 0:
                    dp[0][i][j] = 1
                else:
                    dp[0][i][j] = 0

        for k in range(1,len(strs)):
            for i in range(m+1):
                for j in range(n+1):
                    if i == 0 and j == 0:
                        pass
                    if i-strs_hash[k][0] >= 0 and j-strs_hash[k][1] >= 0:
                        dp[k][i][j] = max(dp[k-1][i-strs_hash[k][0]][j-strs_hash[k][1]] + 1,dp[k-1][i][j])
                    else:
                        dp[k][i][j] = dp[k-1][i][j]
                
        return dp[-1][-1][-1]

sol = Solution()
sol.findMaxForm(strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3)

---

494. 目标和

给你一个非负整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：

• 例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。

返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

示例 1：

输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3

示例 2：

输入：nums = [1], target = 1
输出：1

提示：

• 1 <= nums.length <= 20
• 0 <= nums[i] <= 1000
• 0 <= sum(nums[i]) <= 1000
• -1000 <= target <= 1000

动态规划(0-1背包用法三)

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        total_sum = sum(nums)
        if total_sum < abs(target) or (total_sum + target) % 2 != 0:
            return 0
        
        target_sum = (total_sum + target) // 2
        dp = [0] * (target_sum + 1)
        dp[0] = 1
        
        for num in nums:
            for j in range(target_sum, num - 1, -1):
                dp[j] += dp[j - num]
        
        return dp[target_sum]

---

518. 零钱兑换 II

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

假设每一种面额的硬币有无限个。

题目数据保证结果符合 32 位带符号整数。

示例 1：

输入：amount = 5, coins = [1, 2, 5]
输出：4
解释：有四种方式可以凑成总金额：
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1

示例 2：

输入：amount = 3, coins = [2]
输出：0
解释：只用面额 2 的硬币不能凑成总金额 3 。

示例 3：

输入：amount = 10, coins = [10] 
输出：1

提示：

• 1 <= coins.length <= 300
• 1 <= coins[i] <= 5000
• coins 中的所有值 互不相同
• 0 <= amount <= 5000

完全背包问题解法

115ms 击败84.46%

from typing import List

class Solution:
    def change(self, amount: int, coins: List[int]) -> int:
        dp = [0 for _ in range(amount+1)]

        # 初始化
        dp[0] = 1
        
        # 对于每一个硬币
        for coin in coins:
            # 更新从coin到amount的每一个值
            for i in range(coin, amount + 1):
                dp[i] += dp[i - coin]

        return dp[amount]

---

2012. 数组美丽值求和

给你一个下标从 0 开始的整数数组 nums 。对于每个下标 i（1 <= i <= nums.length - 2），nums[i] 的 美丽值 等于：

• 2，对于所有 0 <= j < i 且 i < k <= nums.length - 1 ，满足 nums[j] < nums[i] < nums[k]
• 1，如果满足 nums[i - 1] < nums[i] < nums[i + 1] ，且不满足前面的条件
• 0，如果上述条件全部不满足

返回符合 1 <= i <= nums.length - 2 的所有 nums[i] 的 美丽值的总和 。

示例 1：

输入：nums = [1,2,3]
输出：2
解释：对于每个符合范围 1 <= i <= 1 的下标 i :
- nums[1] 的美丽值等于 2

示例 2：

输入：nums = [2,4,6,4]
输出：1
解释：对于每个符合范围 1 <= i <= 2 的下标 i :
- nums[1] 的美丽值等于 1
- nums[2] 的美丽值等于 0

示例 3：

输入：nums = [3,2,1]
输出：0
解释：对于每个符合范围 1 <= i <= 1 的下标 i :
- nums[1] 的美丽值等于 0

提示：

• 3 <= nums.length <= 105
• 1 <= nums[i] <= 105

维护前缀最大值和后缀最小值法

class Solution:
    def sumOfBeauties(self, nums: List[int]) -> int:
        # 方法一 利用map自定义函数(超时)
        # n = len(nums)
        # ans = 0

        # for i in range(1,(n-2)+1):
        #     if all(map(lambda x:x > nums[i],nums[i+1:])) and all(map(lambda x:x < nums[i],nums[:i])):
        #         # 该方式效率低
        #         # 后续改为维护[前缀最大值pre_max]和[后缀最小值suf_min]
        #         ans += 2
        #     elif nums[i-1] < nums[i] < nums[i+1]:
        #         ans += 1
            
        # return ans
            
        # 方法二 维护前缀max和后缀min
        n = len(nums)
        ans = 0
        pre_max = [0 for _ in range(n)]
        suf_min = [0 for _ in range(n)]
        pre_max[0] = nums[0]
        suf_min[-1] = nums[-1]

        for i in range(1,n):
            pre_max[i] = max(pre_max[i-1],nums[i])
            suf_min[(n-1)-i] = min(suf_min[(n-1)-(i-1)],nums[(n-1)-i])

        for i in range(1,(n-2)+1):
            if pre_max[i-1] < nums[i] < suf_min[i+1]:
                # 维护[前缀最大值pre_max]和[后缀最小值suf_min]
                ans += 2
            elif nums[i-1] < nums[i] < nums[i+1]:
                ans += 1
            
        return ans

---

2269. 找到一个数字的 K 美丽值

一个整数 num 的 k 美丽值定义为 num 中符合以下条件的 子字符串 数目：

• 子字符串长度为 k 。
• 子字符串能整除 num 。

给你整数 num 和 k ，请你返回 num 的 k 美丽值。

注意：

• 允许有 前缀 0 。
• 0 不能整除任何值。

一个 子字符串 是一个字符串里的连续一段字符序列。

示例 1：

输入：num = 240, k = 2
输出：2
解释：以下是 num 里长度为 k 的子字符串：
- "240" 中的 "24" ：24 能整除 240 。
- "240" 中的 "40" ：40 能整除 240 。
所以，k 美丽值为 2 。

示例 2：

输入：num = 430043, k = 2
输出：2
解释：以下是 num 里长度为 k 的子字符串：
- "430043" 中的 "43" ：43 能整除 430043 。
- "430043" 中的 "30" ：30 不能整除 430043 。
- "430043" 中的 "00" ：0 不能整除 430043 。
- "430043" 中的 "04" ：4 不能整除 430043 。
- "430043" 中的 "43" ：43 能整除 430043 。
所以，k 美丽值为 2 。

提示：

• 1 <= num <= 109
• 1 <= k <= num.length （将 num 视为字符串）

简单循环遍历

class Solution:
    def divisorSubstrings(self, num: int, k: int) -> int:
        
        num_str = str(num)
        n = len(num_str)
        ans = 0

        for i in range(n-(k-1)):
            tmp_divider = int(num_str[i:i+k])
            if tmp_divider != 0:
                ans += not bool(num % tmp_divider)

        return ans

        

---

3305. 元音辅音字符串计数 I

• 给你一个字符串 word 和一个 非负 整数 k。

  返回 word 的 子字符串 中，每个元音字母（'a'、'e'、'i'、'o'、'u'）至少 出现一次，并且 恰好 包含 k 个辅音字母的子字符串的总数。

  示例 1：

  **输入：**word = "aeioqq", k = 1

  **输出：**0

  解释：

  不存在包含所有元音字母的子字符串。

  示例 2：

  **输入：**word = "aeiou", k = 0

  **输出：**1

  解释：

  唯一一个包含所有元音字母且不含辅音字母的子字符串是 word[0..4]，即 "aeiou"。

  示例 3：

  **输入：**word = "ieaouqqieaouqq", k = 1

  **输出：**3

  解释：

  包含所有元音字母并且恰好含有一个辅音字母的子字符串有：

  • word[0..5]，即 "ieaouq"。
  • word[6..11]，即 "qieaou"。
  • word[7..12]，即 "ieaouq"。

  提示：

  • 5 <= word.length <= 250
  • word 仅由小写英文字母组成。
  • 0 <= k <= word.length - 5

双循环指针遍历法(有点慢)

由于题目中元音的数量不固定,所以left指针也需要遍历

class Solution:
    def countOfSubstrings(self, word: str, k: int) -> int:
        vowels = set(['a', 'e', 'i', 'o', 'u'])
        n = len(word)
        ans = 0
        
        for left in range(n):
            vowel_count = 0
            consonant_count = 0
            seen_vowels = set()
            
            for right in range(left, n):
                if word[right] in vowels:
                    seen_vowels.add(word[right])
                else:
                    consonant_count += 1
                
                # Check if we have all the vowels and exactly k consonants
                if len(seen_vowels) == 5 and consonant_count == k:
                    ans += 1
                elif consonant_count > k or len(seen_vowels) > 5:
                    break
        
        return ans

我的写法(错了)

class Solution:
    def countOfSubstrings(self, word: str, k: int) -> int:
         
        aeiou_set = set(["a","e","i","o","u"])

        aeiou_count_set = set()
        not_aeiou_count = 0

        left = 0
        ans = 0
        for right in range(len(word)):

            if word[right] in aeiou_set:
                aeiou_count_set.add(word[right])
            else:
                not_aeiou_count += 1

            while not_aeiou_count > k:
                if word[left] in aeiou_set:
                    aeiou_count_set.remove(word[left])
                else:
                    not_aeiou_count -= 1

                left += 1

            if len(aeiou_count_set) == 5 and not_aeiou_count == k:
                ans += 1

        return ans