Leetcode刷题记录-动态规划Ⅰ

已于 2023-04-24 20:12:05 修改
阅读量525 收藏
点赞数 1
分类专栏： Diary 文章标签： leetcode 动态规划 算法
于 2023-03-16 16:09:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46570364/article/details/129569028
版权

Leetcode刷题记录-动态规划Ⅰ

思路需要复习
参考link1 代码随想录
参考link2 github
参考link3 blibli

基础：

一、 509. 斐波那契数（简单）

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给定 n ，请计算 F(n) 。

在这里插入图片描述

class Solution:
    def fib(self, n: int) -> int:
        if n <= 1:
            return n
        dp = [0] * 2
        dp[0] , dp[1] = 0 , 1
        # 
        for i in range(2, n + 1):
        # for i in range(n - 1):
            sum = dp[0] + dp[1]
            dp[0] = dp[1]
            dp[1] = sum
        return dp[1]

示例代码：

# 状态压缩，直接维护前两个值
class Solution:
    def fib(self, n: int) -> int:
        if n <= 1:
            return n
        a, b, c = 0, 1, 0
        for i in range(2, n + 1):
        # for i in range(n - 1):
            c = a + b
            a, b = b, c       
        return c

二、 爬楼梯及变形

70. 爬楼梯（简单）

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
在这里插入图片描述

# 跟斐波那契一样，只初始化值不同，且忽略dp[0]
class Solution:
    def climbStairs(self, n: int) -> int:
        if n <= 2:
            return n
        a, b, c = 1, 2, 0
        for i in range(3, n + 1):
            c = a + b
            a, b = b, c
        return b

示例代码：
来自代码随想录

# 空间复杂度为O(n)版本
class Solution:
    def climbStairs(self, n: int) -> int:
        # dp[i] 为第 i 阶楼梯有多少种方法爬到楼顶
        dp = [0]*(n+1)
        dp[0] = 1
        dp[1] = 1
        for i in range(2, n+1):
            dp[i] = dp[i-1] + dp[i-2]
        return dp[n]

# 空间复杂度为O(1)版本
class Solution:
    def climbStairs(self, n: int) -> int:
        dp = [0]*(n+1)
        dp[0] = 1
        dp[1] = 1
        for i in range(2,n+1):
            tmp = dp[0] + dp[1]
            dp[0] = dp[1]
            dp[1] = tmp
        return dp[1]

746. 使用最小花费爬楼梯（简单）

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。
请你计算并返回达到楼梯顶部的最低花费。

在这里插入图片描述

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:   
    	# 也可以不需要一个新数组
        n = len(cost)
        dp = [0] * n
        dp[0] = cost[0]
        dp[1] = cost[1]

        for i in range(2, n):
            dp[i] = min(dp[i - 1],dp[i - 2]) + cost[i]
            print(dp[i])
        # 最后一步花费一样不用算
        return min(dp[n - 1],dp[n - 2])

示例代码：

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        h = len(cost)
        for i in range(h-3, -1, -1):
            cost[i] = min(cost[i]+cost[i+1], cost[i]+cost[i+2])

        return min(cost[0], cost[1])

三、 不同路径及其变形

62.不同路径原型

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？
在这里插入图片描述

# 方法一：动态规划
# 二维数组
class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        dp = [[1 for i in range(n)] for j in range(m)]
        for i in range(1, n):
            for j in range(1, m):
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
                print(dp)
        return dp[n - 1][m - 1]   


# 一维数组
class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        dp = [1]*n
        for j in range(1, m):
            for i in range(1, n):
                dp[i] += dp[i - 1]
                print(dp)
        return dp[n - 1]

方法二： 数论 排列组合
在这里插入图片描述

63.不同路径Ⅱ

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？网格中的障碍物和空位置分别用 1 和 0 来表示。
在这里插入图片描述

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        m = len(obstacleGrid)         # 行数
        n = len(obstacleGrid[0])      # 列数
        dp = [[0 for i in range(n)] for j in range(m)]
        if obstacleGrid[0][0] == 1:
            dp[0][0] = 0
        else:
            dp[0][0] = 1

        if dp[0][0] == 0: return 0

        for i in range(1, n):
            if obstacleGrid[0][i] == 1:
                break
            dp[0][i] = 1

        for j in range (1, m):
            if obstacleGrid[j][0] == 1:
                break
            dp[j][0] = 1

        for i in range(1, m):
            for j in range(1, n):
                if obstacleGrid[i][j] == 0:
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
                    # print(dp)
        return dp[-1][-1]

示例代码：
代码随想录

# 一维数组
class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        obs = obstacleGrid
        m = len(obs)
        n = len(obs[0])
   
        dp = [0]*n
        for i in range(n):
            if obs[0][i] == 1:
                break
            dp[i] = 1

        for i in range(1, m):
            for j in range(n):
                if obs[i][j] == 1:
                    dp[j] = 0
                elif j > 0:
                    dp[j] += dp[j - 1]
                else:
                    pass

        return dp[-1]

四、 343. 整数拆分(中等)

给定一个正整数 n ，将其拆分为 k 个 正整数 的和（ k >= 2 ），并使这些整数的乘积最大化。返回 你可以获得的最大乘积 。

在这里插入图片描述

class Solution:
    def integerBreak(self, n: int) -> int:
        dp = [0]*(n + 1)
        dp[2] = 1
        for i in range(3, n + 1):
            for j in range(1,(i//2) + 1):
                dp[i] = max(dp[i], j*(i - j),j*dp[i - j])

        return dp[n]

五、 二叉搜索树及其变形

700. 二叉搜索树

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。

# 迭代法
class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
            while root is not None:
                if val > root.val : root = root.right
                elif val < root.val : root = root.left
                else: return root
            return None


# 递归
class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
 		if not root or root.val == val: 
            return root

        if root.val > val: 
            return self.searchBST(root.left, val)

        if root.val < val: 
            return self.searchBST(root.right, val)

96.⭐不同的二叉搜索树（中等）

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。
在这里插入图片描述
卡尔666

class Solution:
    def numTrees(self, n: int) -> int:
        dp = [0]*(n + 1)
        dp[0], dp[1] = 1 , 1
        print(dp)
        for i in range(2, n + 1):
            for j in range(1,i + 1):
                dp[i] += dp[j - 1]*dp[i - j]
                print(dp)
        return dp[-1]

背包问题 ：

解题步骤：
①确定dp数组及下标的含义
②确定递推公式
③确定dp数组初始值
④确定遍历顺序
⑤打印dp数组验证
在这里插入图片描述

0-1背包：

一、01背包原型

有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。
在这里插入图片描述
暴力解法时间复杂度：2^n
重点在于理解dp数组的含义和递推公式的含义，手写遍历一次数组就理解了

# 01 背包问题 动态规划
def bag_problem(weight, value, bag_size) -> int :
    m = len(weight)
    n = bag_size + 1
    dp = [[0 for i in range(n)] for j in range(m)]

    # 初始化
    for j in range(1, n):
        if weight[0] <= j:
            dp[0][j] = value[0]
            
    # 先遍历物品再遍历背包无影响，因为递推值来自左上方
    for i in range(1, m):
        cur_weight, cur_value = weight[i], value[i]
        for j in range(1, n):
            if cur_weight > j:
                # 放不下，value和原来（前一个）相同
                dp[i][j] = dp[i - 1][j]
            else:
                # 放得下，value = 放不下时的最大价值+当前物品价值
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - cur_weight] + cur_value)
            print(dp)
            print(dp[-1][-1])


if __name__  == "__main__":
    weight = [1, 3, 4]
    value = [15, 20, 30]
    bag_size = 4
    bag_problem(weight, value, bag_size)

空间优化-使用一维数组的几个关键点：
① 第一行无需再初始化，若初始值大于后面的最大值，最大值会被覆盖，第一行[0]也会遍历，原来从第二行[1]开始
② 倒序遍历，原来的当前dp值是从上一个数（左上）中比较而来，所以本身初始化为几都不影响，现在上一个数来源于左边，保证每个物品添加一次
③ 遍历顺序不可颠倒，因为是一维数组，如果竖向遍历，每个dp[j]只能放入一个物品

# 01 背包问题 一维数组
def bag_problem(weight, value, bag_size) -> int :
    m = len(weight)
    n = bag_size + 1
    dp = [0]*n

    # 不需要初始化，全都是0，防止覆盖

    # 遍历顺序不可颠倒，只能先遍历物品再遍历背包
    for i in range(m):
        for j in range(bag_size, weight[i] - 1, -1):
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
            print(dp)
    print(dp[-1])


if __name__  == "__main__":
    weight = [1, 3, 4]
    value = [15, 20, 30]
    bag_size = 4
    bag_problem(weight, value, bag_size)

二、⭐01背包的应用

416.分割等和子集:

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

在这里插入图片描述

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        target = sum(nums)

        if target % 2 == 1:
            return False
        else:
            target //= 2
        
        dp = [0]*(target + 1)
        
        for i in range(len(nums)):
            for j in range(target, nums[i] - 1, -1):
                    dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
                    print(dp)
                   
        return dp[target] == target
1049.最后一块石头的重量II

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：
如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

在这里插入图片描述
思路：
跟上一道题一样，把数组内的数分成尽量相等的两堆，凑出小的那一堆( dp[target] ), 最后结果用大堆（ sum（stones）- dp[stones]）- 小堆（ dp[stones] ）= 剩下的单蹦石头

class Solution:
    def lastStoneWeightII(self, stones: List[int]) -> int:
        target = sum(stones)
        target //= 2
        dp = [0] * (target + 1)
        
        for i in range(len(stones)):
            for j in range(target, stones[i] - 1, -1):
                dp[j] = max(dp[j], dp[j - stones[i]] + stones[i])
        return sum(stones) - 2 * dp[target]
494. 目标和

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

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

例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

在这里插入图片描述
将问题转化为
+x-y = target y = sum - x
x-（sum-x）= target
x = (target + sum) / 2
求装满容量为x的背包有多少种方式
注意dp[0]初始化为1

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        # 目标绝对值大于总和或不能整除得到背包容量无解
        if abs(target) > sum(nums) or (sum(nums) + target) % 2 == 1:
            return 0
        x = (target + sum(nums)) // 2
        dp = [0] * (x + 1)
        # 容量为0时有1种方式[0]
        dp[0] = 1

        for i in range(len(nums)):
            for j in range(x, nums[i] - 1, -1):
                dp[j] += dp[j - nums[i]]
        return dp[-1]
474. 一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

在这里插入图片描述

原型：dp[j] = max(dp[j], dp[j -weight[i]] + value[i])
本题中每个字符串的0和1的个数两个维度，或者说属性，相当于原型中每个物品的weight（属性），字符串个数相当于value，所以+1

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        dp = [[0 for i in range(n + 1)] for j in range(m + 1)]
        for str in strs:
            # 边数边遍历
            zeros = str.count('0')
            ones = str.count('1')   
            # 两个维度并列，遍历顺序可颠倒         
            for i in range(m, zeros - 1, -1):
                for j in range(n, ones - 1, -1):
                    dp[i][j] = max(dp[i][j], dp[i - zeros][j - ones] + 1)

        return dp[m][n]

完全背包：

一、完全背包原型

有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品都有无限个（也就是可以放入背包多次），求解将哪些物品装入背包里物品价值总和最大。
在这里插入图片描述

def complete_pack(weight, value, bag_size) -> int :
    n = bag_size + 1
    dp = [0]*n
    # 遍历顺序可颠倒，无论如何遍历，上一个值来自dp[j - 1],已存在
    for i in range(len(weight)):
    	# 正序遍历保证每个物品可被多次添加
        for j in range(weight[i], n):
            dp[j] = max(dp[j],dp[j - weight[i]] + value[i])
    print(dp[-1])

二、⭐完全背包应用

求组合：先物品后背包
求排列：先背包后物品

518. （组合数）零钱兑换 II

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。假设每一种面额的硬币有无限个。 题目数据保证结果符合 32 位带符号整数。

在这里插入图片描述
注意遍历顺序不能颠倒，颠倒后求的是排列数，要求的是组合数
dp[0] 初始化为1

class Solution:
    def change(self, amount: int, coins: List[int]) -> int:
        dp = [0]*(amount + 1)
        dp[0] = 1
        for i in range(len(coins)):
            for j in range(coins[i], amount + 1):
                dp[j] += dp[j - coins[i]]
        return dp[-1]
377. （排列数）组合总和 Ⅳ

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

在这里插入图片描述
注意遍历范围

class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        dp = [0]*(target + 1)
        dp[0] = 1
        for i in range(1, target + 1):
            for j in nums:
                if i >= j:
                    dp[i] += dp[i - j]
        return dp[-1]

本题相当于前面爬楼梯题目的进阶：

（排列数）爬楼梯-进阶版（同上一道题，换条件）

一步可以走m个台阶，走到n有多少种走法？

class Solution:
    def climbStairs(self, n: int) -> int:
        dp = [0]*(n + 1)
        dp[0] = 1
        m = 2
        # 遍历背包
        for j in range(n + 1):
            # 遍历物品
            for step in range(1, m + 1):
                if j >= step:
                    dp[j] += dp[j - step]
        return dp[n]
139. ⭐（排列数）单词拆分

给你一个字符串 s 和一个字符串列表 wordDict 作为字典。请你判断是否可以利用字典中出现的单词拼接出 s 。注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

在这里插入图片描述

dp数组意义：dp[i] 代表长度为i的字符串能否被字典中的字符串组成（布尔值），最终返回dp[n]能不能被组成
初始化：非空字符串，dp[0]无意义，递推需要该值，所以dp[0]=True
递推公式：j从0开始，如果dp[j]可以组成，j到i的字符在字典中，则i之前的都能组成
视频讲解：https://www.bilibili.com/video/BV1pd4y147Rh/?spm_id_from=333.788&vd_source=0a8fa6e199761d9bcbc5d45a71832fed

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
        n = len(s) + 1
        dp = [False]*n
        dp[0] = True

        for j in range(1, n):
            for word in wordDict:
                if j >= len(word):
                    # dp[j] = 原来的值/j之前的字符串可组成 且 j到i的字符在字典中
                    dp[j] = dp[j] or (word == s[j - len(word):j] and dp[j - len(word)])
        return dp[-1]
322. (最小数)零钱兑换

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。你可以认为每种硬币的数量是无限的。

在这里插入图片描述
求最小，非零下标初始化为一个大值，防止后面的数被初始值覆盖
本题求最少个数，与遍历顺序无关，可颠倒

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
      
        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)
        return dp[-1] if dp[-1] != float("inf") else -1


        # 先背包后物品
        for j in range(1, amount + 1):
            for i in range(len(coins)):
                if j >= coins[i]:
                    dp[j] = min(dp[j], dp[j - coins[i]] + 1)
        return dp[-1] if dp[-1] != float("inf") else -1
279. (最小数)完全平方数的和（同上一道题，换条件）

给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。
在这里插入图片描述
自己写的能通过但会有点慢，因为函数1/2x > x^1/2 ,限定物品数字范围的时候用不了sqrt（n），取到n/2,每次循环多几个数字（傻的

class Solution:
    def numSquares(self, n: int) -> int:
        if n == 1: return 1
        dp = [float("inf")]*(n + 1)
        dp[0] = 0
        
        for i in range(1, (n // 2) + 1):
            for j in range(i**2, n + 1):
                dp[j] = min(dp[j], dp[j - i * i] + 1)

        return dp[n]

示例代码：
先列出数字再循环

class Solution:
    def numSquares(self, n: int) -> int:
        nums = [i**2 for i in range(1, n + 1) if i**2 <= n ]
        dp = [10**4]*(n + 1)
        dp[0] = 0

        # 先物品后背包
        for num in nums:
            for j in range(num, n + 1):
                dp[j] = min(dp[j], dp[j - num] + 1)
        return dp[-1]

        # 先背包后物品
        for j in range(1, n + 1):
            for num in nums:
                if j >= num:
                    dp[j] = min(dp[j], dp[j - num] + 1)
        return dp[-1]

多重背包问题：

多重背包原型

有N种物品和一个容量为V 的背包。第i种物品最多有Mi件可用，每件耗费的空间是Ci ，价值是Wi 。求解将哪些物品装入背包可使这些物品的耗费的空间 总和不超过背包容量，且价值总和最大。
在这里插入图片描述
两种方法：

一、转化为0-1背包问题,如图
二、多一层循环，遍历物品数量
在这里插入图片描述

def test_multi_pack1():
    '''版本一：改变物品数量为01背包格式'''
    weight = [1, 3, 4]
    value = [15, 20, 30]
    nums = [2, 3, 2]
    bag_weight = 10
    for i in range(len(nums)):
        # 将物品展开数量为1
        while nums[i] > 1:
            weight.append(weight[i])
            value.append(value[i])
            nums[i] -= 1
            
    # 后面和0-1背包一样
    dp = [0]*(bag_weight + 1)
    # 遍历物品
    for i in range(len(weight)):
        # 遍历背包
        for j in range(bag_weight, weight[i] - 1, -1):
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
    
    # print(" ".join(map(str, dp)))
    print(dp[-1])

def test_multi_pack2():
    '''版本：改变遍历个数'''
    weight = [1, 3, 4]
    value = [15, 20, 30]
    nums = [2, 3, 2]
    bag_weight = 10

    dp = [0]*(bag_weight + 1)
    for i in range(len(weight)):
        for j in range(bag_weight, weight[i] - 1, -1):
            # 以上是01背包，加上遍历个数
            for k in range(1, nums[i] + 1):
                if j - k*weight[i] >= 0:
                    dp[j] = max(dp[j], dp[j - k*weight[i]] + k*value[i])

    # print(" ".join(map(str, dp)))
    print(dp[-1])


if __name__ == '__main__':
    test_multi_pack1()
    test_multi_pack2()

在这里插入图片描述
存图方便以后复习
在这里插入图片描述

背包问题的代码简单，但是不太容易从题目中抽离出背包问题的原型及想清楚dp数组含义和状态转移方程，需要多练！

樱桃小完犊⁡⁡子
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题汇总
weixin_44171872的博客
09-19 2万+
剑指offer 剑指 Offer 03 数组中重复的数字 剑指 Offer 04 二维数组中的查找 剑指 Offer 05 替换空格 剑指 Offer 06 从尾到头打印链表 剑指 Offer 07 重建二叉树 剑指 Offer 09 用两个栈实现队列 剑指 Offer 10- I 斐波那契数列 剑指 Offer 10- II 青蛙跳台阶问题 剑指 Offer 11 旋转数组的最小数字 剑指 Offer 12 矩阵中的路径 剑指 Offer 13 机器人的运动范围 剑指 Offer 14- I 剪绳子 剑指
leetcode刷题账号-LeetCode:LeetCode刷题记录(C#)
07-06
这个压缩包文件"LeetCode-master"很可能包含了某个用户在刷题过程中的代码记录或者解决方案。 在刷LeetCode的过程中，有几个关键知识点是值得深入探讨的： 1. **基础数据结构**：在LeetCode的题目中，常见数据结构...
LeetCode刷题笔记17--动态规划Ⅰ
weixin_44580808的博客
08-10 96
LeetCode刷题笔记17–动态规划Ⅰ 动态规划标准流程： 典型的动态规划，以下按照标准流程解题。 状态定义： 设动态规划列表 dpdp ，dp[i]dp[i] 代表前 ii 个房子在满足条件下的能偷窃到的最高金额。 转移方程： 设： 有 nn 个房子，前 nn 间能偷窃到的最高金额是 dp[n]dp[n] ，前 n-1n−1 间能偷窃到的最高金额是 dp[n-1]dp[n−1] ，此时向这些房子后加一间房，此房间价值为 numnum ； 加一间房间后： 由于不能抢相邻的房子，意味着抢第 n+1n+1 间
LeetCode 刷题 -- Day 6
2401_83694336的博客
04-24 1052
在遍历队列的过程中，利用while(q.size()–) 实现遍历每一层，将遍历的元素出队，并将下一层压入队列，最后就得到了各层结点值了。在遍历队列的过程中，利用while(q.size()–) 实现遍历每一层，将遍历的元素出队，并将下一层压入队列，最后就得到了各层结点值了。DFS 遍历树，且每下一层高度 h+1，当访问到叶子结点时，就得出了一条从根节点到最近叶子结点的路径长度了（为当前h+1），记录最小的路径长度即为答案。② root 不为空，则找它的左右孩子的高度，并返回较大的高度 h。
leetcode刷题---字符串---学生出勤记录Ⅰ
破浪会有时的博客
12-17 383
给定一个字符串来代表一个学生的出勤记录，这个记录仅包含以下三个字符： 'A' : Absent，缺勤 'L' : Late，迟到 'P' : Present，到场 如果一个学生的出勤记录中不超过一个’A’(缺勤)并且不超过两个连续的’L’(迟到),那么这个学生会被奖赏。 你需要根据这个学生的出勤记录判断他是否会被奖赏。 示例 1: 输入: “PPALLP” 输出: True 示例 2: 输入: “PPALLL” 输出: False 这题很简单，直接定义一个数组来存放数据学生出勤数据即可。 class So
leetcode刷题记录39-213. 打家劫舍 II
xianduan_的博客
06-12 244
求0~n - 1范围内能偷到的最大值和1~n范围内能偷到的最大值，返回较大值即可。你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都。，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。偷窃到的最高金额 = 1 + 3 = 4。，今晚能够偷窃到的最高金额。
Leetcode刷题记录-图论BFS、DFS&二叉树Ⅰ
weixin_46570364的博客
03-24 194
Leetcode刷题记录-图论BFS、DFS&二叉树Ⅰ
leetcode刷题---热门百题---跳跃游戏---贪心算法
破浪会有时的博客
02-17 672
给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。 数组中的每个元素代表你在该位置可以跳跃的最大长度。 判断你是否能够到达最后一个下标。 示例 1： 输入：nums = [2,3,1,1,4] 输出：true 解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。 示例 2： 输入：nums = [3,2,1,0,4] 输出：false 解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。
leetcode刷题记录
pxyp123的博客
03-09 452
leetcode刷题记录
C++leetcode刷题c-c-master.zip
03-18
LeetCode中的题目涵盖了从基础的数据结构（如数组、链表、树、图）到复杂的算法（如动态规划、回溯、贪心、二分查找）等各个层次，是提升编程技能和算法理解的绝佳途径。通过刷题，开发者可以锻炼逻辑思维，提高代码...
Leetcode刷题笔记-堆
08-19
Leetcode刷题笔记—堆相关题型，刷透一道题顶10盲刷10道题，还在苦苦纠结于打开力扣直奔题解的苦恼吗? 赶快来看一看吧
Leetcode刷题笔记-大厂面试突破集
08-15
首先，从题目类型上看，涵盖了哈希表、动态规划、前缀和、二分查找、双指针、贪心策略、回溯算法、模拟题、树的遍历、分治策略等多种算法。例如，1001题《网格照明》利用哈希表和线性映射来解决；1004题《最大连续1...
JAVA小白leetcode刷题顺序--offer:-提供
07-06
本人也是java小白一个，刷题剑指offer也是开始第三遍，准备记录一下每道题的一些通用解法，可能不是最优的，但一定是最容易理解和接受的~ 小白选取的《剑指offer》是LeetCode上面的剑指offer系列，里面的题目顺序和...
【CT】LeetCode手撕—94. 二叉树的中序遍历
weixin_44382896的博客
07-02 342
思路1：使用递归的方式中序遍历。
LeetCode热题100刷题5：189. 轮转数组、238. 除自身以外数组的乘积、41. 缺失的第一个正数
cir_sky的博客
07-03 210
数组篇，今天的三道题略简单
力扣（2024.07.01）
m0_52507142的博客
07-01 690
随机决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，个非负整数，用来表示柱状图中各个柱子的高度。在一个随机下标处将字符串分割成两个非空的子字符串。返回的解集中，子集可以按任意顺序排列。注意：最终，合并后数组不应由函数返回，而是存储在数组。，其中可能包含重复元素，请你返回该数组所有可能的。求在该柱状图中，能够勾勒出来的矩形的最大面积。栈，数组，动态规划，矩阵，单调栈（目前不会）中，使合并后的数组同样按非递减顺序排列。如果字符串的长度为 1 ，算法停止。
刷leetcode中常用且有效的方法总结
最新发布
路有瑶台的博客
07-04 239
刷题的时候经常会因为不知道一个方法多写很多行代码，既然有trick为何不用！你问我眼中为何常含泪水，因为我忘记方法忘的深沉。join（）是 Python 中的一个字符串方法，它用于将序列（如列表、元组、集合等，但集合需要首先转换为列表或其他有序序列，因为集合是无序的）中的元素以指定的字符连接生成一个新的字符串。方法来更新计数器中的计数。可以传递另一个可迭代对象或者另一个。提供了一个快速简单的方式来统计哈希对象在集合中出现的次数。
AcWing_Tree题解1
08-04
"AcWing夏季LeetCode刷题活动介绍及树相关题目解析" 在AcWing的暑期LeetCode刷题活动中，参与者将面临一系列精选的高频率算法题目，总计80道，涵盖了各种数据结构和算法主题。活动分为8周进行，每周会有10道题目，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值