【算法进阶2-动态规划】斐波那契数列(递归调用、动态规划)、钢条切割问题(自定而下实现、自底向上、切割方案)

最新推荐文章于 2024-08-26 00:02:00 发布
最新推荐文章于 2024-08-26 00:02:00 发布
阅读量105 收藏 3
点赞数 2
分类专栏： 算法题 文章标签： 算法 动态规划 代理模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44145338/article/details/141530186
版权

1 斐波那契数
2 钢条切割问题
2.1 最优解情况
2.2 钢条切割问题之自定而下实现
2.3 钢条切割问题之自底向上实现
2.4 钢条切割问题-重构解-切割方案

1 斐波那契数

# 1 子问题的重复计算
def fibonacci(n: int) -> int:
    """
    使用递归方式计算第 n 个斐波那契数。
    该方法效率低，因为会重复计算相同的子问题。

    :param n: 要计算的斐波那契数的索引（从 1 开始）
    :return: 返回第 n 个斐波那契数
    """
    # 基础情况：第 1 个和第 2 个斐波那契数都是 1
    if n == 1 or n == 2:
        return 1
    else:
        # 递归调用：第 n 个斐波那契数等于前两个斐波那契数之和
        return fibonacci(n - 1) + fibonacci(n - 2)


print(fibonacci(10))  # 使用递归方法，输出 55


# 2 动态规划--》递推式
def fibonacci_no_recursion(n: int) -> int:
    """
    使用迭代方式计算第 n 个斐波那契数，避免递归的重复计算。

    :param n: 要计算的斐波那契数的索引（从 1 开始）
    :return: 返回第 n 个斐波那契数
    """
    # 初始化斐波那契数列的前两个值
    f = [0, 1, 1]

    # 当 n 大于 2 时，通过迭代计算后续的斐波那契数
    if n > 2:
        for i in range(n - 2):
            # 计算下一个斐波那契数，并将其添加到列表中
            num = f[-1] + f[-2]
            f.append(num)

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


print(fibonacci_no_recursion(100))  # 354224848179261915075

2 钢条切割问题

在这里插入图片描述
在这里插入图片描述

2.1 最优解情况

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.2 钢条切割问题之自定而下实现

import time


def cal_time(func):
    """
    装饰器，用于计算函数的执行时间。

    :param func: 被装饰的函数
    :return: 包装后的函数，附加了执行时间的计算
    """

    def wrapper(*args, **kwargs):
        # 记录开始时间
        t1 = time.time()

        # 执行被装饰的函数并获取返回值
        result = func(*args, **kwargs)

        # 记录结束时间
        t2 = time.time()

        # 计算并打印函数运行时间
        print(f"{func.__name__} running time: {t2 - t1} seconds.")

        # 返回函数执行的结果
        return result

    return wrapper


def cut_rod_recurision_1(p: list, n: int) -> int:
    """
    使用递归方法求解钢条切割问题。

    钢条切割问题的目标是将一根长度为 n 的钢条切成若干段，
    使得每段的总价值最大化。价格由列表 p 提供，其中 p[i] 表示长度为 i 的钢条的价格。

    :param p: 列表，包含各个长度的钢条对应的价格，p[0] 通常为 0
    :param n: 钢条的总长度
    :return: 返回长度为 n 的钢条的最大收益
    """
    # 如果钢条长度为 0，则最大收益为 0
    if n == 0:
        return 0

    # 初始化最大收益为切割长度为 n 的收益
    res = p[n]

    # 递归地计算所有可能的切割方式
    for i in range(1, n):
        # 对每个可能的切割点 i，计算最大收益
        res = max(res, cut_rod_recurision_1(p, i) + cut_rod_recurision_1(p, n - i))

    return res


# price = [0, 1, 5, 8, 9, 10, 17, 17, 20, 24, 30]
# print(cut_rod_recurision_1(price, 9))  # 25

def cut_rod_recurision_2(p: list, n: int) -> int:
    """
    使用递归方法求解钢条切割问题的优化版本。

    该函数通过递归计算长度为 n 的钢条的最大收益。
    钢条的价格由列表 p 提供，其中 p[i] 表示长度为 i 的钢条的价格。

    :param p: 列表，包含各个长度的钢条对应的价格，p[0] 通常为 0
    :param n: 钢条的总长度
    :return: 返回长度为 n 的钢条的最大收益
    """
    # 如果钢条长度为 0，则最大收益为 0
    if n == 0:
        return 0

    # 初始化最大收益为 0，因为我们可能不切割钢条，即收益为 0
    res = 0

    # 递归地计算所有可能的切割方式
    for i in range(1, n + 1):
        # 对每个可能的切割点 i，计算当前切割方案的收益
        # res = max(当前最大收益, 将钢条切成长度 i 和 n-i 两部分的收益)
        res = max(res, p[i] + cut_rod_recurision_2(p, n - i))

    # 返回最大收益
    return res


# price = [0, 1, 5, 8, 9, 10, 17, 17, 20, 24, 30]
# print(cut_rod_recurision_2(price, 9))  # 25

price = [0, 1, 5, 8, 9, 10, 17, 17, 20, 21, 23, 24, 26, 27, 28, 30, 33, 36, 37, 39, 40]
# print(len(price))
# print(cut_rod_recurision_2(price, 20))  # 56

@cal_time
def c1(p: list, n: int) -> int:
    """
    使用装饰器 cal_time 来计算并打印 cut_rod_recurision_1 函数的运行时间。

    :param p: 列表，包含各个长度的钢条对应的价格，p[0] 通常为 0
    :param n: 钢条的总长度
    :return: 返回长度为 n 的钢条的最大收益
    """
    return cut_rod_recurision_1(p, n)


@cal_time
def c2(p: list, n: int) -> int:
    """
    使用装饰器 cal_time 来计算并打印 cut_rod_recurision_2 函数的运行时间。

    :param p: 列表，包含各个长度的钢条对应的价格，p[0] 通常为 0
    :param n: 钢条的总长度
    :return: 返回长度为 n 的钢条的最大收益
    """
    return cut_rod_recurision_2(p, n)


print(c1(price, 20))
print(c2(price, 20))

2.3 钢条切割问题之自底向上实现

在这里插入图片描述

import time


def cal_time(func):
    """
    装饰器，用于计算函数的执行时间。

    :param func: 被装饰的函数
    :return: 包装后的函数，附加了执行时间的计算
    """

    def wrapper(*args, **kwargs):
        # 记录开始时间
        t1 = time.time()

        # 执行被装饰的函数并获取返回值
        result = func(*args, **kwargs)

        # 记录结束时间
        t2 = time.time()

        # 计算并打印函数运行时间
        print(f"{func.__name__} running time: {t2 - t1} seconds.")

        # 返回函数执行的结果
        return result

    return wrapper


def cut_rod_recurision_2(p: list, n: int) -> int:
    """
    使用递归方法求解钢条切割问题的优化版本。

    该函数通过递归计算长度为 n 的钢条的最大收益。
    钢条的价格由列表 p 提供，其中 p[i] 表示长度为 i 的钢条的价格。

    :param p: 列表，包含各个长度的钢条对应的价格，p[0] 通常为 0
    :param n: 钢条的总长度
    :return: 返回长度为 n 的钢条的最大收益
    """
    # 如果钢条长度为 0，则最大收益为 0
    if n == 0:
        return 0

    # 初始化最大收益为 0，因为我们可能不切割钢条，即收益为 0
    res = 0

    # 递归地计算所有可能的切割方式
    for i in range(1, n + 1):
        # 对每个可能的切割点 i，计算当前切割方案的收益
        # res = max(当前最大收益, 将钢条切成长度 i 和 n-i 两部分的收益)
        res = max(res, p[i] + cut_rod_recurision_2(p, n - i))

    # 返回最大收益
    return res


price = [0, 1, 5, 8, 9, 10, 17, 17, 20, 21, 23, 24, 26, 27, 28, 30, 33, 36, 37, 39, 40]


@cal_time
def c2(p: list, n: int) -> int:
    """
    使用装饰器 cal_time 来计算并打印 cut_rod_recurision_2 函数的运行时间。

    :param p: 列表，包含各个长度的钢条对应的价格，p[0] 通常为 0
    :param n: 钢条的总长度
    :return: 返回长度为 n 的钢条的最大收益
    """
    return cut_rod_recurision_2(p, n)


@cal_time
def cut_rod_dp(p: list, n: int) -> int:
    """
    钢条切割问题的动态规划解决方案，自底向上实现。

    该函数通过动态规划方法求解长度为 n 的钢条的最大收益。
    钢条的价格由列表 p 提供，其中 p[i] 表示长度为 i 的钢条的价格。

    :param p: 列表，包含各个长度的钢条对应的价格，p[0] 通常为 0
    :param n: 钢条的总长度
    :return: 返回长度为 n 的钢条的最大收益
    """
    # 初始化一个长度为 n+1 的列表 r，其中 r[i] 表示长度为 i 的钢条的最大收益
    r = [0] * (n + 1)

    # 遍历每一个可能的钢条长度 i
    for i in range(1, n + 1):
        # 对于每个长度 i，初始化当前最大收益为 0
        res = 0

        # 遍历所有可能的切割点 j，从 1 到 i
        for j in range(1, i + 1):
            # 计算切割方案的收益，并更新最大收益
            # res = max(当前最大收益, 切割成长度 j 和 i-j 两部分的收益)
            res = max(res, p[j] + r[i - j])

        # 将长度为 i 的钢条的最大收益存储在 r[i]
        r[i] = res

    # 返回长度为 n 的钢条的最大收益
    return r[n]


print(cut_rod_dp(price, 15))  # 42

2.4 钢条切割问题-重构解-切割方案

在这里插入图片描述

import time
from typing import Tuple, List


def cal_time(func):
    """
    装饰器，用于计算函数的执行时间。

    :param func: 被装饰的函数
    :return: 包装后的函数，附加了执行时间的计算
    """

    def wrapper(*args, **kwargs):
        # 记录开始时间
        t1 = time.time()

        # 执行被装饰的函数并获取返回值
        result = func(*args, **kwargs)

        # 记录结束时间
        t2 = time.time()

        # 计算并打印函数运行时间
        print(f"{func.__name__} running time: {t2 - t1} seconds.")

        # 返回函数执行的结果
        return result

    return wrapper


def cut_rod_recurision_2(p: list, n: int) -> int:
    """
    使用递归方法求解钢条切割问题的优化版本。

    该函数通过递归计算长度为 n 的钢条的最大收益。
    钢条的价格由列表 p 提供，其中 p[i] 表示长度为 i 的钢条的价格。

    :param p: 列表，包含各个长度的钢条对应的价格，p[0] 通常为 0
    :param n: 钢条的总长度
    :return: 返回长度为 n 的钢条的最大收益
    """
    # 如果钢条长度为 0，则最大收益为 0
    if n == 0:
        return 0

    # 初始化最大收益为 0，因为我们可能不切割钢条，即收益为 0
    res = 0

    # 递归地计算所有可能的切割方式
    for i in range(1, n + 1):
        # 对每个可能的切割点 i，计算当前切割方案的收益
        # res = max(当前最大收益, 将钢条切成长度 i 和 n-i 两部分的收益)
        res = max(res, p[i] + cut_rod_recurision_2(p, n - i))

    # 返回最大收益
    return res


# price = [0, 1, 5, 8, 9, 10, 17, 17, 20, 21, 23, 24, 26, 27, 28, 30, 33, 36, 37, 39, 40]


@cal_time
def c2(p: list, n: int) -> int:
    """
    使用装饰器 cal_time 来计算并打印 cut_rod_recurision_2 函数的运行时间。

    :param p: 列表，包含各个长度的钢条对应的价格，p[0] 通常为 0
    :param n: 钢条的总长度
    :return: 返回长度为 n 的钢条的最大收益
    """
    return cut_rod_recurision_2(p, n)


@cal_time
def cut_rod_dp(p: list, n: int) -> int:
    """
    钢条切割问题的动态规划解决方案，自底向上实现。

    该函数通过动态规划方法求解长度为 n 的钢条的最大收益。
    钢条的价格由列表 p 提供，其中 p[i] 表示长度为 i 的钢条的价格。

    :param p: 列表，包含各个长度的钢条对应的价格，p[0] 通常为 0
    :param n: 钢条的总长度
    :return: 返回长度为 n 的钢条的最大收益
    """
    # 初始化一个长度为 n+1 的列表 r，其中 r[i] 表示长度为 i 的钢条的最大收益
    r = [0]  # 只包含一个元素 0，后续会扩展到长度为 n+1

    # 遍历每一个可能的钢条长度 i 从 1 到 n
    for i in range(1, n + 1):
        # 对于每个长度 i，初始化当前最大收益为 0
        res = 0

        # 遍历所有可能的切割点 j，从 1 到 i
        for j in range(1, i + 1):
            # 计算当前切割方案的收益，并更新最大收益
            # 比较当前最大收益和切割成长度 j 和 i-j 两部分的收益
            res = max(res, p[j] + r[i - j])

        # 将长度为 i 的钢条的最大收益存储在 r[i]
        r.append(res)

    # 返回长度为 n 的钢条的最大收益
    return r[n]


# price = [0, 1, 5, 8, 9, 10, 17, 17, 20, 21, 23, 24, 26, 27, 28, 30, 33, 36, 37, 39, 40]
# print(cut_rod_dp(price, 20))  # 56


from typing import List, Tuple


def cut_rod_extend(p: list, n: int) -> Tuple[int, List[int]]:
    """
    扩展的钢条切割问题动态规划解决方案，自底向上实现。

    该函数不仅计算长度为 n 的钢条的最大收益，还追踪实现最大收益的切割方案。

    :param p: 列表，包含各个长度的钢条对应的价格，p[0] 通常为 0
    :param n: 钢条的总长度
    :return: 返回一个元组，其中第一个元素是长度为 n 的钢条的最大收益，第二个元素是一个列表，表示每个长度的钢条的最佳切割点
    """
    # 初始化一个长度为 n+1 的列表 r，其中 r[i] 表示长度为 i 的钢条的最大收益
    r = [0] * (n + 1)

    # 初始化一个长度为 n+1 的列表 s，用于存储每个长度的钢条的最佳切割点
    s = [0] * (n + 1)

    # 遍历每一个可能的钢条长度 i
    for i in range(1, n + 1):
        # 对于每个长度 i，初始化当前最大收益为 0
        res_r = 0  # 当前长度 i 的最大收益
        res_s = 0  # 对应最大收益的最佳切割长度

        # 遍历所有可能的切割点 j，从 1 到 i
        for j in range(1, i + 1):
            # 比较通过切割长度 j 和 i-j 两部分的收益是否大于当前最大收益
            if p[j] + r[i - j] > res_r:
                # 更新最大收益和最佳切割长度
                res_r = p[j] + r[i - j]
                res_s = j

        # 将当前长度 i 的最大收益和最佳切割长度存储在 r 和 s 列表中
        r[i] = res_r
        s[i] = res_s

    # 返回长度为 n 的钢条的最大收益和最佳切割点列表
    return r[n], s


def cut_rod_solution(p: list, n: int) -> list:
    """
    根据最佳切割点列表还原钢条切割方案

    该函数使用最佳切割点列表 `s` 还原出钢条的切割方案。

    :param p: 列表，包含各个长度的钢条对应的价格，p[0] 通常为 0
    :param n: 钢条的总长度
    :return: 返回一个列表，表示钢条的切割方案
    """
    # 调用 cut_rod_extend 函数获取最佳切割点列表
    _, s = cut_rod_extend(p, n)

    ans = []  # 存储最终的切割方案
    while n > 0:
        # 将当前长度的最佳切割点添加到切割方案中
        ans.append(s[n])
        # 更新剩余长度
        n -= s[n]

    # 返回最终的切割方案
    return ans


price = [0, 1, 5, 8, 9, 10, 17, 17, 20, 21, 23, 24, 26, 27, 28, 30, 33, 36, 37, 39, 40]
_, s = cut_rod_extend(price, 20)
print(s)  # [0, 1, 2, 3, 2, 2, 6, 1, 2, 3, 2, 2, 6, 1, 2, 3, 2, 2, 6, 1, 2]
print(cut_rod_extend(price, 20))  # (56, [0, 1, 2, 3, 2, 2, 6, 1, 2, 3, 2, 2, 6, 1, 2, 3, 2, 2, 6, 1, 2])
print(cut_rod_solution(price, 20))  # [2, 6, 6, 6]
林光虚霁晓
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Python 算法基础篇：斐波那契数列问题的动态规划解法
小蓝枣的博客
07-24 898
斐波那契数列是计算机科学中一个经典的问题，动态规划是解决该问题的高效算法技术。本篇博客将重点介绍斐波那契数列问题的动态规划解法，包括状态定义、状态转移方程、边界条件和状态转移过程，并通过实例代码演示动态规划算法的实现，每行代码都配有详细的注释。
斐波那契数列问题解法总结--递归、动态规划、矩阵幂
要做更好的自己的Vicky_ Blog
06-04 428
一、递归方法 时间复杂度。 def fibonacci(n): if n == 1: return 1 elif n == 2: return 1 elif n > 2: return fibonacci(n-1)+fibonacci(n-2) for n in range(1,100): print(n...
算法-动态规划 Dynamic Programming--从菜鸟到老鸟
热门推荐
有图有真相
07-15 46万+
前言最近在牛客网上做了几套公司的真题，发现有关动态规划（Dynamic Programming）算法的题目很多。相对于我来说，算法里面遇到的问题里面感觉最难的也就是动态规划（Dynamic Programming）算法了，于是花了好长时间，查找了相关的文献和资料准备彻底的理解动态规划（Dynamic Programming）算法。一是帮助自己总结知识点，二是也能够帮助他人更好的理解这个算法。后面的参
1.2.1-斐波那契数列4种解法(暴力递归+动态规划)
qq_39444290的博客
05-20 581
Reference LeetCode 509. 斐波那契数列 labuladong的算法小抄 Markdown语法 Labuladong的算法小抄(纸质书籍 2021年1月第1版，2022年1月第七次印刷 第2章，第1节) 此问题解法和下一个凑零钱问题解法，我都会详细介绍解法原理，再后续动态规划算法原理和此相同，我只会解释题目解决方案窍门(即找到“状态”、“选择”和状态转移方程)，不会再详细解释其他相关知识。 动态规划一般解法 暴力穷举 -> 带备忘录的递归解法 -> dp 数组的迭代解法
【算法-剑指 Offer】10- I. 斐波那契数列（递归；动态规划）
赖念安的博客
08-12 196
剑指 Offer 10- I. 斐波那契数列 - 力扣（LeetCode） 发布：2021年8月12日15:09:49 问题描述及示例 写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下： F(0) = 0, F(1) = 1 F(N) = F(N - 1) + F(N - 2), 其中 N > 1. 斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。 答案需要取模 1e9+7（1000000007），如计
动态规划实战篇--斐波那契数列
云原生Java Web领域技术博客
02-20 1641
斐波那契数列是最经典的动态规划算法应用实例之一。接下来，将从斐波那契数列入手，学习下基于动态规划求解问题。
动态规划(上)---斐波那契数列
foreverjueye的博客
04-17 2602
初步了解动态规划，以及通过第一个问题斐波那契数列，快速掌握动态规划的相关思想。
一分钟学算法-递归-斐波那契数列递归解法及优化
weixin_62650212的博客
08-23 456
我们以此题为例，假如我们要求解斐波那契数列的第一百项数字，那麽我们会得到这张调用关系图，同一项会被重复计算非常非常多次。斐波那契数列，又称黄金分割数列，是一个经典的数学数列，其特点是第一项，第二项为1，后面每个数字都是前两个数字之和。这样我们在每次计算前先去字典中寻找这一项，如果有值，那么直接拿出来使用，如果没有，再计算它。每次计算某一项时先去集合中查询，如果已经计算过，那么直接返回值，如果没有，则计算，并且在返回值之前先在集合中记录一下。知道了斐波那契数列的定义后，我们将其代入到递归问题的分析当中。
Fibonacci数列--动态规划与递归的Java实现
颜的博客
04-13 933
Fibonacci数列–动态规划与递归的Java实现 递归与动态规划 相似点：递归和动态规划都要求给出 递推公式 ，将大问题划分为相似子问题求解。而动态规划比递归好处是：保存中间计算结果（子问题的解），去除重复计算！ 递归的特点： (1) 外层往往需要内层计算结果：发现父问题与子问题的关系，具体问题具体实现 (2) 必须有一个明确的递归结束条件，称为递归出口！ 递归实现 public class ...
算法分析实验报告：熟悉环境和递归算法、动态规划算法、贪心算法、回溯法
07-05
在本实验报告中，我们将深入探讨四种核心的算法思想：递归算法、动态规划、贪心算法和回溯法。这些算法在计算机科学和信息技术领域起着至关重要的作用，是解决复杂问题的关键工具。 首先，让我们来理解递归算法。...
递归方法实现斐波那契数列_递归方法实现斐波那契数列_python_源码
10-02
斐波那契数列是一个经典的数学概念，在计算机科学中经常被用作教学示例和算法设计的基础。这个数列的定义非常简单：第一项和第二项都是1，从第三项开始，每一项都等于前两项之和。用数学公式表示就是： F(1) = 1 F...
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
在《代码随想录》中，可能会涵盖如斐波那契数列、背包问题、最长公共子序列等经典动态规划题目。理解动态规划的关键在于构建状态转移方程和找到正确的状态定义。 回溯（Backtracking）是一种试探性的解决问题方法，...
Java实现用递归算法和非递归算法求解斐波那契数列问题.docx
06-28
### Java实现用递归算法和非递归算法求解斐波那契数列问题 #### 知识点解析 在给定的文档标题与描述中，“Java实现用递归算法和非递归算法求解斐波那契数列问题”明确指出了本文将围绕Java编程语言、递归算法与非...
算法-数论- 斐波那契数列（Fibonacci）.rar
09-16
这个数列由意大利数学家斐波那契（Leonardo Fibonacci）在13世纪引入，用于模拟兔子繁殖的问题，因此也被称为“兔子数列”。数列的定义非常简单：第一项是0，第二项是1，之后每一项都是前两项之和。用数学公式表示...
算法日记day 45（单调栈之每日温度|接雨水）
m0_74980681的博客
08-22 834
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 344
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
【算法】深入浅出聚类算法：原理、应用与Java实现
最新发布
一个不断前行的程序者
08-26 588
聚类算法是一种将数据集中的对象自动划分为多个子集的算法。每个子集称为一个簇，簇内的对象具有较高的相似度，而簇与簇之间的相似度较低。聚类算法的主要目的是发现数据中的自然结构，而不是通过已知的类别标签。本文介绍了聚类算法的原理、应用场景以及如何在Java中实现一个简单的聚类算法。通过聚类算法，我们可以发现数据集中的自然结构，有助于更好地理解数据。在实际应用中，可以根据具体需求选择合适的聚类算法。希望本文能够帮助读者更好地理解和应用聚类算法。
最小区间00
青釉Oo的博客
08-21 475
最小区间
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值