秋招 hot 100 刷题记录【10】

最新推荐文章于 2024-09-09 23:28:21 发布

菜鸟赚大钱

最新推荐文章于 2024-09-09 23:28:21 发布

阅读量148

点赞数 5

分类专栏：算法拼搏100天！文章标签： python 算法数据结构

本文链接：https://blog.csdn.net/ZLInbao/article/details/141021859

版权

算法拼搏100天！专栏收录该内容

14 篇文章 0 订阅

订阅专栏

口诀

01背包 dp[j] 代表物品[i]可以装入的物品最大价值先物品后背包背包从大到小
完全背包 dp[j]
- 求组合数先物品后背包背包从小到大
- 求排列数先背包后物品从小到大

1.完全平方数

做题前发现有点遗忘问题的定义以及解法今天先回顾背包的问题
完全背包：有N件物品放入背包重量为W中，此时每个物品可以放入背包多次，求将哪些物品放入背包中价值总和最大
- 物品可重复装入且背包容量为n —— 完全背包问题
- 求的是最少数量因此不要求求组合或者排列数因此遍历顺序均可以
  - 组合数：外层遍历物品内层遍历背包
  - 排列数：外层遍历背包内层遍历物品
代码链接

class Solution(object):
    def numSquares(self, n):
        """
        :type n: int
        :rtype: int
        """
        # 完全平方数 
        # 找组成n的最少数量 商品价值为1
        # 物品可重复装入 且 背包容量为n —— 完全背包问题
        # 求的是最少数量 因此不要求求组合或者排列数 因此遍历顺序均可以
        # 组合数：外层遍历物品 内层遍历背包
        # 排列数：外层遍历背包 内层遍历物品
        # dp[j] 物品i装入容量j的背包中 所装的最少数量
        # 
        # 1.初始化 因为求最小值 初始化为最大值 且dp[n]有值
        dp = [float("inf")] * (n + 1)
        dp[0] = 0
        dp[1] = 1
        # 完全背包 先物品后背包 背包从小到大
        # 注意这里的物品的取值和背包的取值
        for i in range(1, int(n ** 0.5) + 1):
            for j in range(i * i, n + 1):
                # 凑足j- i*i 的最少数量为dp[j-i*i],只要再加上1个（i的平方数）就可以凑成j
                dp[j] = min(dp[j], dp[j - i*i] + 1)
            #print(i, dp)
        return dp[n]

2.零钱兑换

代码链接

class Solution(object):
    def coinChange(self, coins, amount):
        """
        :type coins: List[int]
        :type amount: int
        :rtype: int
        """
        # 硬币数量是无限 —— 完全背包问题
        # 求组合数 先物品后背包 背包从小到大
        if amount == 0:
            return 0
        dp = [float("inf")] * (amount + 1)
        dp[0] = 0
        for i in range(len(coins)):
            for j in range(coins[i], amount + 1):
                dp[j] = min(dp[j], dp[j - coins[i]] + 1)
        
        if dp[amount] == float("inf"):
            return -1
        else :
            return dp[amount]

3.单词拆分

代码链接

class Solution(object):
    def wordBreak(self, s, wordDict):
        """
        :type s: str
        :type wordDict: List[str]
        :rtype: bool
        """
        # 单词重复出现 - 完全背包问题
        # 单词拆分 有先后顺序为排列数
        # 排列数 先背包后物品
        # dp[j] 指的是s[:j]能否被拼接
        dp = [ False ] * (len(s) + 1)
        # dp[0]就是递推的根基，dp[0]一定要为true，否则递推下去后面都都是false了
        dp[0] = True # 这里的dp[0]只是为了推导公式因为题目说了为非空子串
        for j in range(0,len(s) + 1):
            for i in range(0,j): # 物品相当于组成j的字符串
                # 只有当i：j的字符串位于字典 且0:i-1的字符可以被拼接 这个j才可以被拼接
                if s[i:j] in wordDict and dp[i]:
                    dp[j] = True
        return dp[-1]

4.最长递增子序列

代码链接

class Solution(object):
    def lengthOfLIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # dp[i] 以nums[i]结尾的时候最长的递增子序列长度
        if len(nums) == 1: return 1
        dp = [1] * len(nums)
        # 注意这里要找的是非连续的
        for i in range(0,len(nums)):
            for j in range(0, i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i], dp[j] + 1)
        # 注意返回的值是整个数组中最大的，因为最长子序列并不一定是以nums[-1]结尾的
        return max(dp)
        
        # for i in range(len(nums)-1):
        #     if nums[i + 1] > nums[i]:
        #         dp[i+1] = dp[i]+1 这是找连续的
        # return max(dp)

5.乘积最大的子数组

代码链接

class Solution(object):
    def maxProduct(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # 由于乘积会因为数字本身的正负影响 因此不仅需要最大的dp 还需要最小的dp
        # dp[i] 为包含第nums[i]结尾的最大子数组乘积
        if len(nums) == 1: return nums[0]
        dp_max = nums[:]
        dp_min = nums[:]
        for i in range(1, len(nums)):
            # 要想到比较的值应该是3个
            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])

        return max(dp_max)

6.分割等和子集

代码链接

class Solution(object):
    def canPartition(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        # 思路：其实找到子数组和为sum/2就行
        # 相当于0-1背包 每个物品只能装一次 背包容量为 sum/ 2
        if sum(nums) % 2 != 0 or len(nums) <= 1:
            return False
        bag = sum(nums) / 2
        # dp[0] = nums[0] 这是错误的 考虑到dp[j]的定义
        # dp[0] 是背包容量为0的时候装入的物品价值
        # 指的是背包容量为j的时候 装入物品0到i的最大价值
        # 01背包 先物品 后背包 背包从大到小
        dp = [0] * (bag + 1)
        for i in nums:
            for j in range(bag, i - 1, -1):
                # 是否要装入该物品
                dp[j] = max(dp[j], dp[j - i] + i)
        return dp[bag] == bag

7.最长有效括号

思路：最重要的是dp[j] 指代的是有效括号以i结尾的字符中最长的有效括号长度
代码链接

class Solution(object):
    def longestValidParentheses(self, s):
        """
        :type s: str
        :rtype: int
        """
        # dp[i] 指的是有效括号结尾为i的字符中 最长的有效括号长度
        if len(s) <= 1 : return 0
        dp = [0] * len(s)
        dp[0] = 0
        if s[0] == "(" and s[1] == ")":
            dp[1] = 2
        for i in range(2, len(s)):
            if s[i] == "(":
                #此时字符串一定不有效
                dp[i] = 0
            elif s[i] == ")" and s[i - 1] == "(":
                dp[i] = dp[i-2] + 2 # 匹配的字符为上一个字符
            # 下一次则寻找最近的上一个匹配的括号在哪里
            elif s[i] == ")" and i - dp[i-1] - 1 >= 0 and s[i - dp[i-1] - 1] == "(":
            # 首先 明确 s[i-1]s[i] = "))" 
            # 因此dp[i-1]为 以s[i-1]结尾的的最长有效括号长度 那么最近的这个"(", 下标为 i - (dp[i-1]) -1
            # 那么当前的长度 两部分 dp[i-1]的最长括号 +  dp[i - dp[i-1] - 2]前的长度+2
                dp[i] = dp[i - dp[i-1] - 2] + 2 + dp[i - 1]
        return max(dp)

8.不同路径

代码链接

class Solution(object):
    def uniquePaths(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """
        # 思路：动态规划
        # dp[i][j] 指的是到达（i，j）位置的路径数目
        if m == 1 or n==1: return 1
        dp = [[0] * n for _ in range(m)] # 初始化方法明确
        # 对于行列初始化为1
        for i in range(m):
            dp[i][0] = 1
        for j in range(n):
            dp[0][j] = 1

        for i in range(1, m):
            for j in range(1, n):
                dp[i][j] = dp[i][j-1] + dp[i-1][j]
        return dp[-1][-1]

9.最小路径和

代码链接

class Solution(object):
    def minPathSum(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        m = len(grid)
        n = len(grid[0])
        dp = [[0] * n for _ in range(m)] # 初始化方法明确
        # 对于行列初始化为1
        dp[0][0] = grid[0][0]
        for i in range(1, m):
            dp[i][0] = dp[i-1][0] + grid[i][0]
        for j in range(1, n):
            dp[0][j] = dp[0][j - 1] + grid[0][j]

        for i in range(1, m):
            for j in range(1, n):
                dp[i][j] = min(dp[i][j-1]+grid[i][j], grid[i][j] + dp[i-1][j])
        return dp[-1][-1]

10.最长回文子串

代码链接

class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        # 思路 中心扩展法
        # 从两边往中间看
        # 返回的是 l和r区间范围内两端相同的字符串
        def palidrome(s, l, r):
            while l >= 0 and r < len(s) and s[l] == s[r]:
                l -= 1
                r += 1
            return s[l+1:r]
        max_str = ""
        max_num = 0
        for i in range(len(s)):
            dan_str = palidrome(s, i, i) #  取出单子符串
            print(dan_str)
            if len(dan_str) > max_num:
                max_num = len(dan_str)
                max_str = dan_str
            ou_str = palidrome(s, i, i + 1)
            if len(ou_str) > max_num:
                max_num = len(ou_str)
                max_str = ou_str
        return max_str