【力扣hot100】刷题笔记Day25

前言

这几天搞工作处理数据真是类似我也，还被老板打电话push压力有点大的，还好搞的差不多了，明天再汇报，赶紧偷闲再刷几道题（可恶，被打破连更记录了）
这几天刷的是动态规划，由于很成体系不适合零散刷，还是把代码随想录动态规划部分的题目快速再过一遍，代码简单但是思路也要记住

139. 单词拆分 - 力扣（LeetCode）

动态规划

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
        s_length = len(s)
        dp = [False] * (s_length + 1)   # dp[i]表示s[0:i]能否被拼接
        dp[0] = True                    # 初始化，空字符串可以
        for i in range(1, s_length+1):  # 遍历结束指针i
            for j in range(i):          # 遍历开始指针j
                if dp[j] and s[j:i] in wordDict:  # 如果j-1已经可拼，s[j:i]可再拼一个
                    dp[i] = True        # 整体就可以拼接
                    break               # 找到一组拼接，更新为True就退出
        return dp[s_length]

300. 最长递增子序列 - 力扣（LeetCode）

动态规划

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        n = len(nums)  # dp[i]表示以nums[i]结尾的最长递增子串长度
        dp = [1] * n   # 初始化为全1，子串至少为1个
        res = 1  # 结果先取1
        for i in range(1, n):
            for j in range(i):
                if nums[i] > nums[j]:  # 只要比前面的递增，子串长度＋1
                    dp[i] = max(dp[i], dp[j] + 1)
            res = max(res, dp[i])  # 更新最长值
        return res

152. 乘积最大子数组 - 力扣（LeetCode）

动态规划

class Solution:
    def maxProduct(self, nums: List[int]) -> int:
        n = len(nums)
        dp_max = [float('-inf')] * n  # 表示以nums[i]为底的连续子数组的最大乘积，也可以用pre_max一个变量表示
        dp_min = [float('inf')] * n  # 表示以nums[i]为底的连续子数组的最小乘积，也可以用pre_min一个变量表示
        dp_max[0] = dp_min[0] = res = nums[0]
        for i in range(1, n):
            # 由于当前可能正可能负，三种取最大/小：当前数，前最大×当前数，前最小×当前数
            dp_max[i] = max(nums[i], dp_max[i-1] * nums[i], dp_min[i-1] * nums[i])
            dp_min[i] = min(nums[i], dp_max[i-1] * nums[i], dp_min[i-1] * nums[i])
            res = max(res, dp_max[i])
        return res

符号个数

思路参考题解及评论区

class Solution:
    def maxProduct(self, nums: List[int]) -> int:
        reverse_nums = nums[::-1]
        # 先按照0分成多个数组，在不同数组里统计奇数个数
        # 负数个数为偶数，全部相乘，负数个数为奇数，某奇数的前缀乘积或后缀乘积为最大值
        for i in range(1, len(nums)):
            nums[i] *= nums[i - 1] or 1   # 前缀乘积（遇到0就重置）
            reverse_nums[i] *= reverse_nums[i - 1] or 1  # 后缀乘积（遇到0就重置）
        return max(nums + reverse_nums)  # 一定是前缀乘积和后缀乘积的最大值

416. 分割等和子集 - 力扣（LeetCode）

01背包

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        numSum = sum(nums)
        if numSum % 2 == 1: return False  # 总和为奇数无法等分
        target = numSum // 2  # 01背包大小
        dp = [0] * (target + 1)  # dp[j]表示以j为容量的背包装的最大价值
        for i in range(len(nums)):  # 遍历物品，从头到尾，重量和价值都为nums[i]
            for j in range(target, nums[i] - 1, -1):  # 遍历背包，从target到nums[i]倒序
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
        return dp[target] == target  # 如果target容量的背包刚好能装价值为target，找到分割方法

32. 最长有效括号 - 力扣（LeetCode）

辅助栈

参考题解

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        st = []  # 栈中存储的是到当前位置暂时不可以构成括号的索引
        res = 0
        for i in range(len(s)):
            # 可以构成括号：栈不空 and 当前字符为'(' and 栈顶字符为'('
            if st and s[i] == ')' and s[st[-1]] == '(':
                st.pop()   # 弹出栈顶'('
                # 与最远不能构成括号的下标计算距离，更新最大长度，注意越界
                res = max(res, i - (st[-1] if st else - 1)) 
            # 不可以构成括号：栈空 or 当前字符为')' or 栈顶字符为')'
            else:
                st.append(i)  # 存入下标
        return res

动态规划

参考题解

class Solution:
    def longestValidParentheses(self, s: str) -> int:
        n = len(s)
        if n <= 1: return 0
        dp = [0] * n  # dp[i]表示以s[i]结尾的最长有效括号子串
        res = 0   # 用于更新最大值
        for i in range(1, n):
            # ()，在dp[i-2]基础上直接延续2个
            if s[i] == ')' and s[i-1] == '(':           
                dp[i] = dp[i-2] + 2 if i >= 2 else 2    # 防止越界，dp[0]以前为0
            # ))，先看前一个)匹配多长，再看后一个)能否匹配上(，可以的话就+2
            elif s[i] == ')' and s[i-1] == ')':         
                sub_len = dp[i-1]  # 前一个)已经匹配的长度
                if i-sub_len-1 >= 0 and s[i-sub_len-1] == '(':  # 后一个)要找到(才能匹配上
                    last = dp[i-sub_len-2] if i-sub_len-2 >= 0 else 0  # 找到(之前已经匹配多长，防止越界，dp[0]以前为0
                    dp[i] = dp[i-1] + last + 2  # 前一个)匹配的长度 + 后一个)找到(之前已经匹配的长度 + 2
            res = max(res, dp[i])  # 更新最大值，没有以上情况dp[i]就是0
        return res