python算法和数据结构刷题[5]：动态规划

动态规划（Dynamic Programming, DP）是一种算法思想，用于解决具有最优子结构的问题。它通过将大问题分解为小问题，并找到这些小问题的最优解，从而得到整个问题的最优解。动态规划与分治法相似，但区别在于动态规划的子问题通常不是相互独立的。

动态规划的核心是解决重复子问题。例如，斐波那

契数列问题，可以通过递归实现，但效率低下，因为会有重复计算。动态规划通过存储已解决的子问题的答案，避免重复计算，从而提高效率。这种方法需要额外的存储空间，是一种空间换时间的策略。

如果一个问题，可以把所有可能的答案穷举出来，并且穷举出来后，发现存在重叠子问题，就可以考虑使用动态规划。

单维动态规划

斐波那契数列

def fibonacci(n):
    # 如果n小于等于1，直接返回n
    if n <= 1:
        return n
    
    # 初始化dp数组，用于存储从0到n的斐波那契数
    dp = [0] * (n + 1)
    dp[1] = 1  # 斐波那契数列的第二个数是1

    # 使用动态规划填充dp数组
    for i in range(2, n + 1):
        dp[i] = dp[i - 1] + dp[i - 2]

    # 返回第n个斐波那契数
    return dp[n]

# 测试代码
print(fibonacci(0))  # 输出 0
print(fibonacci(1))  # 输出 1
print(fibonacci(2))  # 输出 1
print(fibonacci(3))  # 输出 2
print(fibonacci(4))  # 输出 3
print(fibonacci(5))  # 输出 5
print(fibonacci(6))  # 输出 8
print(fibonacci(7))  # 输出 13

70. 爬楼梯 - 力扣（LeetCode）

到达第 n 个台阶的方法数等于到达第 n-1 个台阶和第 n-2 个台阶的方法数之和

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

118. 杨辉三角 - 力扣（LeetCode）

给出一个整数输出杨辉三角 

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        dp = [[0] * i for i in range(1, numRows + 1)]
        
        for i in range(numRows):
            dp[i][0] = 1
            dp[i][i] = 1

        res = []
        for i in range(numRows):
            for j in range(i):
                if i != 0 and j != 0:
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]
            res.append(dp[i])

        return res

 322. 零钱兑换 - 力扣（LeetCode）

背包问题：背包问题通常描述为：给定一组物品，每个物品有一定的价值（value）和重量（weight），需要从中选择一些物品放入一个给定容量的背包中，使得放入背包的物品的总价值最大，同时不超过背包的容量。

完全背包问题 

返回构成该金额所需的最少硬币数量。如果该金额无法通过硬币的任何组合来弥补，则返回 。-1

def coinChange(coins, amount):
    # 创建一个数组，长度为 amount + 1，初始值为 amount + 1
    dp = [amount + 1] * (amount + 1)
    # 金额为0时，需要0个硬币
    dp[0] = 0
    
    # 遍历每个金额
    for a in range(1, amount + 1):
        # 遍历每种硬币
        for coin in coins:
            # 如果当前硬币面额小于等于当前金额
            if coin <= a:
                # 更新 dp[a] 为使用当前硬币后的最少硬币数量
                dp[a] = min(dp[a], dp[a - coin] + 1)
    
    # 如果 dp[amount] 还是初始值，则返回 -1，否则返回 dp[amount]
    return dp[amount] if dp[amount] != amount + 1 else -1

# 示例
coins = [1, 2, 5]
amount = 11
print(coinChange(coins, amount))  # 输出应该是 3

279. 完全平方数 - 力扣（LeetCode）

完全背包问题

def numSquares(n):
    # 创建一个数组来存储每个数字的最小完全平方数个数，初始值为0
    dp = [0] * (n + 1)#，用于存储每个数字 i 可以表示为完全平方数之和的最小数量。    
    # 初始化dp数组，每个位置初始为最大值
    for i in range(1, n + 1):
        dp[i] = i  # 最坏的情况是 i 个 1 的平方
    
    # 遍历每个数字，更新其最小完全平方数个数
    for i in range(1, n + 1):
        j = 1
        while j * j <= i:
            dp[i] = min(dp[i], dp[i - j * j] + 1)
            j += 1
    
    # 返回n的最小完全平方数个数
    return dp[n]

# 示例
print(numSquares(12))  # 输出应为 3
print(numSquares(13))  # 输出应为 2，因为 13 = 4 + 9

198. 打家劫舍 - 力扣（LeetCode）

def rob(nums):
    if not nums:
        return 0
    if len(nums) == 1:
        return nums[0]
    dp = [0] * len(nums)
    dp[0] = nums[0]
    dp[1] = max(nums[0], nums[1])
    for i in range(2, len(nums)):
        dp[i] = max(dp[i-1], dp[i-2] + nums[i])
    return dp[-1]

# 示例
nums = [2, 7, 9, 3, 1]
print(rob(nums))  # 输出应该是 12，因为抢第 0、2、4 间房子（2+9+1）

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

def wordBreak(s, wordDict):
    # 首先创建一个布尔数组 dp，长度为字符串长度加一，初始化所有值为 False
    dp = [False] * (len(s) + 1)
    # dp[i] 将表示 s 的前 i 个字符是否可以被成功分割
    dp[0] = True  # 空字符串可以被成功分割

    # 遍历字符串的每一个字符
    for i in range(1, len(s) + 1):
        # 对于每一个可能的结束位置 i，检查所有可能的开始位置 j
        for j in range(i):
            # 如果 dp[j] 为 True，且 s[j:i] 在字典中，那么 dp[i] 也为 True
            if dp[j] and s[j:i] in wordDict:
                dp[i] = True
                break  # 找到一个有效的分割就跳出内层循环

    # 返回 dp[len(s)]，它表示整个字符串是否可以被成功分割
    return dp[len(s)]

# 示例用法
swordDict = ["apple", "pen", "applepen", "pine", "pineapple"]
s = "pineapplepenapple"
print(wordBreak(s, swordDict))  # 应该返回 True

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

最长递增子序列：可以不连续但是前后相对顺序不变

def lengthOfLIS(nums):
    if not nums:
        return 0

    # 初始化一个数组 dp，长度与输入数组相同，所有元素初始为 1
    # dp[i] 表示以 nums[i] 结尾的最长递增子序列的长度
    dp = [1] * len(nums)

    # 遍历数组，计算每个位置的最长递增子序列长度
    for i in range(1, len(nums)):
        for j in range(i):
            # 如果当前元素 nums[i] 大于之前的元素 nums[j]
            # 并且以 nums[i] 结尾的子序列长度可以增加
            if nums[i] > nums[j]:
                dp[i] = max(dp[i], dp[j] + 1)

    # 返回 dp 数组中的最大值，即为最长递增子序列的长度
    return max(dp)

# 示例用法
nums = [10, 9, 2, 5, 3, 7, 101, 18]
print(lengthOfLIS(nums))  # 输出应该是 4，因为最长递增子序列是 [2, 3, 7, 101]

重点：如果 nums[i] 大于 nums[j]，那么我们可以将 nums[i] 添加到以 nums[j] 结尾的递增子序列中，从而形成一个更长的递增子序列。 

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

最大乘积子数组问题是指在一个整数数组中找到一个连续的子数组（至少包含一个数），使得这个子数组中所有数的乘积是最大的。

tmp = imax;
imax = imin;
imin = tmp;
def maxProduct(nums):
    # 初始化最大乘积、当前最大乘积和当前最小乘积
    max_so_far = nums[0]
    min_so_far = nums[0]
    result = nums[0]
    
    # 遍历数组，从第二个元素开始
    for i in range(1, len(nums)):
        # 如果当前元素是负数，那么最大乘积和最小乘积会交换
        if nums[i] < 0:
            max_so_far, min_so_far = min_so_far, max_so_far
        
        # 更新当前最大乘积和最小乘积
        max_so_far = max(nums[i], max_so_far * nums[i])
        min_so_far = min(nums[i], min_so_far * nums[i])
        
        # 更新结果为最大乘积
        result = max(result, max_so_far)
    
    return result

# 示例
nums = [2, 3, -2, 4]
print(maxProduct(nums))  # 输出: 6

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

给定一个整数数组 ，如果您可以将数组划分为两个子集，使得两个子集中的元素之和相等，则 返回。

01背包问题

def canPartition(nums):
    total_sum = sum(nums)
    # 如果总和是奇数，直接返回 False
    if total_sum % 2 != 0:
        return False
    
    target = total_sum // 2
    dp = [False] * (target + 1)
    dp[0] = True  # 0 总是可以达成，不选择任何元素即可
    
    # 遍历所有物品（数组中的数字）
    for num in nums:
        # 这里必须从 target 递减到 num，以防止一个物品被重复使用
        for j in range(target, num - 1, -1):
            # 如果 dp[j - num] 是 True，则 dp[j] 也应该是 True
            dp[j] = dp[j] or dp[j - num]
    
    # dp[target] 表示是否可以从数组中选取一些数字，使得这些数字的总和等于 target
    return dp[target]

# 示例
nums = [1, 5, 11, 5]
print(canPartition(nums))  # 输出: True

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

当前字符是 ) 并且前一个字符是 (，当前字符是 ) 并且前一个字符也是 )：s = "()(())"

def longest_valid_parentheses(s):
    n = len(s)
    if n == 0:
        return 0

    # dp[i] 表示以 s[i] 结尾的最长有效括号的长度
    dp = [0] * n
    max_len = 0

    for i in range(1, n):
        if s[i] == ')':
            # 如果前一个字符是'('，则可以形成一个有效的括号对
            if s[i - 1] == '(':
                dp[i] = (dp[i - 2] if i >= 2 else 0) + 2
            # 如果前一个字符是')'，并且前面的有效括号长度为 dp[i - 1]
            # 并且 dp[i - 1] 前面的字符是'('，则可以扩展有效括号长度
            elif i - dp[i - 1] > 0 and s[i - dp[i - 1] - 1] == '(':
                dp[i] = dp[i - 1] + (dp[i - dp[i - 1] - 2] if i - dp[i - 1] >= 2 else 0) + 2
            max_len = max(max_len, dp[i])

    return max_len

# 示例
print(longest_valid_parentheses("(()"))  # 输出 2
print(longest_valid_parentheses(")()())"))  # 输出 4

多维动态规划

62. 不同路径 - 力扣（LeetCode）

与杨辉三角和爬楼梯类似

空间复杂度：2n

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        pre = [1] * n
        cur = [1] * n
        for i in range(1, m):
            for j in range(1, n):
                cur[j] = pre[j] + cur[j-1]
            pre = cur[:]
        return pre[-1]

64. 最小路径和 - 力扣（LeetCode）

向下或向右移动从左上角到右下角的最小路径和

到达每个单元格 (i, j) 的最小路径和可以由到达其上方单元格 (i-1, j) 和左方单元格 (i, j-1) 的最小路径和推导出来。

 dp[i][j] 表示到达单元格 (i, j) 的最小路径和，到达 (i, j) 的最小路径和等于到达其上方和左方单元格的最小路径和中的较小者，再加上当前单元格的值。

def min_path_sum(grid):
    if not grid or not grid[0]:
        return 0
    
    m, n = len(grid), len(grid[0])
    dp = [[0] * n for _ in range(m)]
    
    # 初始化左上角
    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]
    
    # 填充dp数组剩余部分
    for i in range(1, m):
        for j in range(1, n):
            # dp[i][j]可以从上方(dp[i-1][j])或左方(dp[i][j-1])到达，
            # 所以我们取两者的最小值，并加上当前格子的值。
            dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]
    
    # 右下角的格子将包含从左上角到右下角的最小路径和
    return dp[m - 1][n - 1]

5. 最长回文子串 - 力扣（LeetCode）

记录字符串中每对字符之间是否形成回文子串

def longest_palindromic_substring(s):
    n = len(s)
    if n == 0:
        return ""
    
    # 初始化一个二维数组，用于存储子串是否为回文
    dp = [[False] * n for _ in range(n)]
    start = 0  # 最长回文子串的起始位置
    max_length = 1  # 最长回文子串的长度

    # 所有长度为1的子串都是回文
    for i in range(n):
        dp[i][i] = True

    # 检查长度为2的子串是否为回文
    for i in range(n - 1):
        if s[i] == s[i + 1]:
            dp[i][i + 1] = True
            start = i
            max_length = 2

    # 检查长度大于2的子串
    for length in range(3, n + 1):  # 子串长度从3开始递增
        for i in range(n - length + 1):
            j = i + length - 1  # 子串的结束位置
            # 检查子串s[i:j+1]是否为回文
            if s[i] == s[j] and dp[i + 1][j - 1]:
                dp[i][j] = True
                start = i
                max_length = length

    # 返回最长回文子串
    return s[start:start + max_length]

# 示例使用
s = "babad"
print(longest_palindromic_substring(s))  # 输出可能是"bab"或"aba"

1143. 最长公共子序列 - 力扣（LeetCode）

子序列可以是不连续的；子数组（子字符串）需要是连续的。

def longest_common_subsequence(text1, text2):
    # 获取两个字符串的长度
    m, n = len(text1), len(text2)
    
    # 初始化一个二维数组 dp，用于存储子问题的解
    # dp[i][j] 表示 text1 的前 i 个字符和 text2 的前 j 个字符的最长公共子序列的长度
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    
    # 填充 dp 数组
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            # 如果当前字符相同，则最长公共子序列长度加一
            if text1[i - 1] == text2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                # 如果当前字符不同，取左上角、上方、左方三个方向的最大值
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])
    
    # dp[m][n] 即为两个字符串的最长公共子序列的长度
    return dp[m][n]

# 测试用例
text1 = "abcde"
text2 = "ace"
# 测试结果
print(longest_common_subsequence(text1, text2))

72. 编辑距离 - 力扣（LeetCode）

定两个字符串 和 ，返回将 word1 转换为 word2 所需的最小步数

def minDistance(word1, word2):
    # 创建一个矩阵来存储子问题的解
    dp = [[0 for x in range(len(word2) + 1)] for x in range(len(word1) + 1)]

    # 初始化矩阵的第一行和第一列
    for i in range(len(word1) + 1):
        dp[i][0] = i
    for j in range(len(word2) + 1):
        dp[0][j] = j

    # 填充dp矩阵
    for i in range(1, len(word1) + 1):
        for j in range(1, len(word2) + 1):
            # 如果当前字符相同，无需编辑，直接使用上一个状态的值
            if word1[i - 1] == word2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1]
            else:
                # 如果字符不同，取插入、删除、替换三者的最小值加1
                dp[i][j] = 1 + min(dp[i - 1][j],    # 删除
                                   dp[i][j - 1],    # 插入
                                   dp[i - 1][j - 1] # 替换
                                  )

    # dp矩阵的最后一个元素即为编辑距离
    return dp[len(word1)][len(word2)]

# 示例使用
word1 = "horse"
word2 = "ros"
print(minDistance(word1, word2))  # 输出应该是3，因为"horse" -> "ros"需要3步：h -> r, o ->

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/964131.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【阅读笔记】New Edge Diected Interpolation，NEDI算法，待续

【阅读笔记】New Edge Diected Interpolation，NEDI算法，待续

一、概述 由Li等提出的新的边缘指导插值(New Edge—Di-ected Interpolation&#xff0c;NEDI)算法是一种具有良好边缘保持效果的新算法&#xff0c;它利用低分辨率图像与高分辨率图像的局部协方差问的几何对偶性来对高分辨率图像进行自适应插值。 2001年Xin Li和M.T. Orchard…
阅读更多...
C++ Primer 迭代器

C++ Primer 迭代器

欢迎阅读我的 【CPrimer】专栏 专栏简介&#xff1a;本专栏主要面向C初学者&#xff0c;解释C的一些基本概念和基础语言特性&#xff0c;涉及C标准库的用法&#xff0c;面向对象特性&#xff0c;泛型特性高级用法。通过使用标准库中定义的抽象设施&#xff0c;使你更加适应高级…
阅读更多...
DeepSeek R1 简易指南：架构、本地部署和硬件要求

DeepSeek R1 简易指南：架构、本地部署和硬件要求

DeepSeek 团队近期发布的DeepSeek-R1技术论文展示了其在增强大语言模型推理能力方面的创新实践。该研究突破性地采用强化学习&#xff08;Reinforcement Learning&#xff09;作为核心训练范式&#xff0c;在不依赖大规模监督微调的前提下显著提升了模型的复杂问题求解能力。 技…
阅读更多...
直方图：摄影中的视觉数据指南

直方图：摄影中的视觉数据指南

目录 一、直方图基础&#xff1a;揭开它的神秘面纱 二、解读直方图类型&#xff1a;亮度与色彩的密码 &#xff08;一&#xff09;亮度直方图 &#xff08;二&#xff09;RGB 直方图 三、拍摄中巧用直方图&#xff1a;优化曝光与效果 &#xff08;一&#xff09;精准判断曝…
阅读更多...
力扣动态规划-19【算法学习day.113】

力扣动态规划-19【算法学习day.113】

前言 ###我做这类文章一个重要的目的还是记录自己的学习过程&#xff0c;我的解析也不会做的非常详细&#xff0c;只会提供思路和一些关键点&#xff0c;力扣上的大佬们的题解质量是非常非常高滴&#xff01;&#xff01;&#xff01; 习题 1.矩形中移动的最大次数 题目链接…
阅读更多...
树莓派pico入坑笔记，睡眠

树莓派pico入坑笔记，睡眠

关于树莓派pico和circuitpython的更多玩法&#xff0c;请看树莓派pico专栏 关于在 CircuitPython 中使用警报和浅/深度睡眠的更多信息&#xff0c;请参阅此学习指南。 树莓派pico支持浅睡眠和深度睡眠&#xff0c;其中深度睡眠唤醒后将从boot.py开始运行 支持按时间唤醒和引…
阅读更多...
【蓝桥杯】日志统计

【蓝桥杯】日志统计

日志统计&#xff08;编程题&#xff09;https://dashoj.com/d/lqbproblem/p/53https://dashoj.com/d/lqbproblem/p/53https://dashoj.com/d/lqbproblem/p/53 题目 日志统计(编程题) 讲解 这个讲解感觉比较通俗易懂。 蓝桥杯2018年省赛B组08&#xff08;c/c&#xff09;日…
阅读更多...
实验十一 Servlet(二)

实验十一 Servlet(二)

实验十一 Servlet(二) 【实验目的】 1&#xff0e;了解Servlet运行原理 2&#xff0e;掌握Servlet实现方式 【实验内容】 改造实验10&#xff0c;引入数据库&#xff0c;创建用户表&#xff0c;包括用户名和密码&#xff1a;客户端通过login.jsp发出登录请求&#xff0c;请求…
阅读更多...
Weevely代码分析

Weevely代码分析

亲测php5和php8都无效&#xff0c;只有php7有效 ailx10 1949 次咨询 4.9 网络安全优秀回答者 互联网行业 安全攻防员 去咨询 上一次做weevely实验可以追溯到2020年&#xff0c;当时还是weevely3.7&#xff0c;现在的是weevely4 生成php网页木马依然差不多…… php菜刀we…
阅读更多...
vue.js学习笔记

vue.js学习笔记

一、Vue概述 通过我们学习的htmlcssjs已经能够开发美观的页面了&#xff0c;但是开发的效率还有待提高&#xff0c;那么如何提高呢&#xff1f;我们先来分析下页面的组成。一个完整的html页面包括了视图和数据&#xff0c;数据是通过请求 从后台获取的&#xff0c;那么意味着我…
阅读更多...
MySQL（高级特性篇） 13 章——事务基础知识

MySQL（高级特性篇） 13 章——事务基础知识

一、数据库事务概述 事务是数据库区别于文件系统的重要特性之一 &#xff08;1&#xff09;存储引擎支持情况 SHOW ENGINES命令来查看当前MySQL支持的存储引擎都有哪些&#xff0c;以及这些存储引擎是否支持事务能看出在MySQL中&#xff0c;只有InnoDB是支持事务的 &#x…
阅读更多...
【C++】继承（下）

【C++】继承（下）

大家好&#xff0c;我是苏貝&#xff0c;本篇博客带大家了解C的继承&#xff08;下&#xff09;&#xff0c;如果你觉得我写的还不错的话&#xff0c;可以给我一个赞&#x1f44d;吗&#xff0c;感谢❤️ 目录 5.继承与友元6.继承与静态成员7.复杂的菱形继承及菱形虚拟继承8.继…
阅读更多...
大数据治理体系构建与关键技术实践

大数据治理体系构建与关键技术实践

&#x1f4dd;个人主页&#x1f339;&#xff1a;一ge科研小菜鸡-CSDN博客 &#x1f339;&#x1f339;期待您的关注 &#x1f339;&#x1f339; 1. 引言 随着信息技术的快速发展和数据规模的爆炸式增长&#xff0c;大数据已经成为各行业的核心资产。然而&#xff0c;数据质量…
阅读更多...
数据分析系列--[11] RapidMiner,K-Means聚类分析(含数据集)

数据分析系列--[11] RapidMiner,K-Means聚类分析(含数据集)

一、数据集 二、导入数据 三、K-Means聚类 数据说明:提供一组数据,含体重、胆固醇、性别。 分析目标:找到这组数据中需要治疗的群体供后续使用。 一、数据集 点击下载数据集 二、导入数据 三、K-Means聚类 Ending, congratulations, youre done.
阅读更多...
SpringBoot整合Mybatis|入门级增删改查|2025

SpringBoot整合Mybatis|入门级增删改查|2025

SpringBoot整合Mybatis 文章目录 SpringBoot整合Mybatis1. 新建User表2. 初始化项目2.1 新建项目2.2 配置数据库连接2.3 完善项目的架子 3. 正式开始3.1 新增用户3.2 根据邮箱查询3.4 改密码 和 删除用户3.5 用xml再写一遍 4. 进阶 1. 新建User表 CREATE DATABASE mybatis_dem…
阅读更多...
【线程】基于环形队列的生产者消费者模型

【线程】基于环形队列的生产者消费者模型

1 环形队列 环形队列采用数组来模拟&#xff0c;用取模运算来模拟环状特性。 1.如何判断环形队列为空或者为满? 当环形队列为空时&#xff0c;头和尾都指向同一个位置。当环形队列为满时&#xff0c;头和尾也都指向同一个位置。 因此&#xff0c; 可以通过加计数器或者标记…
阅读更多...
docker中运行的MySQL怎么修改密码

docker中运行的MySQL怎么修改密码

1&#xff0c;进入MySQL容器 docker exec -it 容器名 bash 我运行了 docker ps命令查看。正在运行的容器名称。可以看到MySQL的我起名为db docker exec -it db bash 这样就成功的进入到容器中了。 2&#xff0c;登录MySQL中 mysql -u 用户名 -p 回车 密码 mysql -u root -p roo…
阅读更多...
SRS代码目录

SRS代码目录

代码目录&#xff1a; src/目录下核心代码&#xff1a; core&#xff1a;核心功能模块&#xff0c;包括日志、配置、错误处理等&#xff1b;protocol&#xff1a;实现RTMP、HTTP-FLV、HLS等协议的模块&#xff1b;app&#xff1a;应用层的实现&#xff0c;包括流的发布、播放…
阅读更多...
Leetcode：680

Leetcode：680

1&#xff0c;题目 2&#xff0c;思路 首先就是判断它不发生改变会不会是回文如果不是回文&#xff0c;那么俩个指针从前往后与从后往前做对比如果俩字符不同&#xff0c;那就俩种选择&#xff0c;一种是保留前面的字符去掉后面字符&#xff0c;另一种是其反然后俩种选择只要满…
阅读更多...
SliverAppBar的功能和用法

SliverAppBar的功能和用法

文章目录 1 概念介绍2 使用方法3 示例代码 我们在上一章回中介绍了SliverGrid组件相关的内容&#xff0c;本章回中将介绍SliverAppBar组件.闲话休提&#xff0c;让我们一起Talk Flutter吧。 1 概念介绍 我们在本章回中介绍的SliverAppBar和普通的AppBar类似&#xff0c;它们的…
阅读更多...
最新文章

Copyright @ 2022~2023