一个方法团灭 LeetCode 股票买卖问题

最新推荐文章于 2024-05-20 18:16:07 发布
最新推荐文章于 2024-05-20 18:16:07 发布
阅读量183 收藏
点赞数
分类专栏： 刷题 文章标签： leetcode 动态规划 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c630843901/article/details/124826408
版权

文章目录

这篇文章参考 英文版高赞题解 的思路，用状态机的技巧来解决，可以全部提交通过。不要觉得这个名词高大上，文学词汇而已，实际上就是 DP table，看一眼就明白了。

一、穷举框架

动态规划核心套路 说过，动态规划算法本质上就是穷举「状态」，然后在「选择」中选择最优解。

我们只需要抽出来力扣第 188 题「 买卖股票的最佳时机 IV」进行研究，因为这道题是最泛化的形式，其他的问题都是这个形式的简化，看下题目：
在这里插入图片描述那么对于这道题，我们具体到每一天，看看总共有几种可能的「状态」，再找出每个「状态」对应的「选择」。我们要穷举所有「状态」，穷举的目的是根据对应的「选择」更新状态。听起来抽象，你只要记住「状态」和「选择」两个词就行，下面实操一下就很容易明白了。

for 状态1 in 状态1的所有取值：
    for 状态2 in 状态2的所有取值：
        for ...
            dp[状态1][状态2][...] = 择优(选择1，选择2...)

比如说这个问题，每天都有三种「选择」：买入、卖出、无操作，我们用 buy, sell, rest 表示这三种选择。

但问题是，并不是每天都可以任意选择这三种选择的，因为 sell 必须在 buy 之后，buy 必须在 sell 之后。那么 rest 操作还应该分两种状态，一种是 buy 之后的 rest（持有了股票），一种是 sell 之后的 rest（没有持有股票）。而且别忘了，我们还有交易次数 k 的限制，就是说你 buy 还只能在 k > 0 的前提下操作。

我们现在的目的只是穷举，你有再多的状态，要做的就是一把梭全部列举出来。

这个问题的「状态」有三个，第一个是天数，第二个是允许交易的最大次数，第三个是当前的持有状态（即之前说的 rest 的状态，我们不妨用 1 表示持有，0 表示没有持有）。然后我们用一个三维数组就可以装下这几种状态的全部组合：

dp[i][k][0 or 1]
0 <= i <= n - 1, 1 <= k <= K
n 为天数，大 K 为交易数的上限，0 和 1 代表是否持有股票。
此问题共 n × K × 2 种状态，全部穷举就能搞定。

for 0 <= i < n:
    for 1 <= k <= K:
        for s in {0, 1}:
            dp[i][k][s] = max(buy, sell, rest)

我们想求的最终答案是 dp[n - 1][K][0]，即最后一天，最多允许 K 次交易，最多获得多少利润。

二、状态转移框架

现在，我们完成了「状态」的穷举，我们开始思考每种「状态」有哪些「选择」，应该如何更新「状态」。

只看「持有状态」，可以画个状态转移图：

在这里插入图片描述
通过这个图可以很清楚地看到，每种状态（0 和 1）是如何转移而来的。根据这个图，我们来写一下状态转移方程：

dp[i][k][0] = max(dp[i-1][k][0],dp[i][k][1]+prices[i])
			 max( 今天选择 rest,        今天选择 sell       )

解释：今天我没有持有股票，有两种可能，我从这两种可能中求最大利润：

  1. 我昨天就没有持有，且截至昨天最大交易次数限制为 k；然后我今天选择 rest，所以我今天还是没有持有，最大交易次数限制依然为 k。
  2. 我昨天持有股票，且截至昨天最大交易次数限制为 k；但是今天我 sell 了，所以我今天没有持有股票了，最大交易次数限制依然为 k。
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
              max( 今天选择 rest,         今天选择 buy         )

解释：今天我持有着股票，最大交易次数限制为 k，那么对于昨天来说，有两种可能，我从这两种可能中求最大利润：
3. 我昨天就持有着股票，且截至昨天最大交易次数限制为 k；然后今天选择 rest，所以我今天还持有着股票，最大交易次数限制依然为 k。

  1. 我昨天本没有持有，且截至昨天最大交易次数限制为 k - 1；但今天我选择 buy，所以今天我就持有股票了，最大交易次数限制为 k。
  2. 这里着重提醒一下，时刻牢记「状态」的定义，状态 k 的定义并不是

「已进行的交易次数」，而是「最大交易次数的上限限制」。如果确定今天进行一次交易，且要保证截至今天最大交易次数上限为 k，那么昨天的最大交易次数上限必须是 k - 1。

注意 k 的限制，在选择 buy 的时候相当于开启了一次交易，那么对于昨天来说，交易次数的上限 k 应该减小 1。

现在，我们已经完成了动态规划中最困难的一步：状态转移方程。如果之前的内容你都可以理解，那么你已经可以秒杀所有问题了，只要套这个框架就行了。不过还差最后一点点，就是定义 base case，即最简单的情况。

dp[-1][...][0] = 0
解释：因为 i 是从 0 开始的，所以 i = -1 意味着还没有开始，这时候的利润当然是 0。

dp[-1][...][1] = -infinity
解释：还没开始的时候，是不可能持有股票的。
因为我们的算法要求一个最大值，所以初始值设为一个最小值，方便取最大值。

dp[...][0][0] = 0
解释：因为 k 是从 1 开始的，所以 k = 0 意味着根本不允许交易，这时候利润当然是 0。

dp[...][0][1] = -infinity
解释：不允许交易的情况下，是不可能持有股票的。
因为我们的算法要求一个最大值，所以初始值设为一个最小值，方便取最大值。

把上面的状态转移方程总结一下：

base case：
dp[-1][...][0] = dp[...][0][0] = 0
dp[-1][...][1] = dp[...][0][1] = -infinity

状态转移方程：
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])

这个数组索引是 -1 怎么编程表示出来呢，负无穷怎么表示呢？这都是细节问题，有很多方法实现。现在完整的框架已经完成，下面开始具体化。

三、秒杀题目

第一题，力扣第 121 题「 买卖股票的最佳时机」，相当于 k = 1 的情况：
在这里插入图片描述
直接套状态转移方程，根据 base case，可以做一些化简：

dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
dp[i][1] = max(dp[i-1][1], -prices[i])

直接写出代码：

// 原始版本
int maxProfit_k_1(int[] prices) {
    int n = prices.length;
    int[][] dp = new int[n][2];
    for (int i = 0; i < n; i++) {
        if (i - 1 == -1) {
            // base case
            dp[i][0] = 0;
            dp[i][1] = -prices[i];
            continue;
        }
        dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] + prices[i]);
        dp[i][1] = Math.max(dp[i-1][1], -prices[i]);
    }
    return dp[n - 1][0];
}

// 空间复杂度优化版本
int maxProfit_k_1(int[] prices) {
    int n = prices.length;
    // base case: dp[-1][0] = 0, dp[-1][1] = -infinity
    int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
    for (int i = 0; i < n; i++) {
        // dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
        dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]);
        // dp[i][1] = max(dp[i-1][1], -prices[i])
        dp_i_1 = Math.max(dp_i_1, -prices[i]);
    }
    return dp_i_0;
}

第二题，看一下力扣第 122 题「 买卖股票的最佳时机 II」，也就是 k 为正无穷的情况：

在这里插入图片描述
动态转移方程：

dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i])

完整代码：

// 原始版本
int maxProfit_k_inf(int[] prices) {
    int n = prices.length;
    int[][] dp = new int[n][2];
    for (int i = 0; i < n; i++) {
        if (i - 1 == -1) {
            // base case
            dp[i][0] = 0;
            dp[i][1] = -prices[i];
            continue;
        }
        dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] + prices[i]);
        dp[i][1] = Math.max(dp[i-1][1], dp[i-1][0] - prices[i]);
    }
    return dp[n - 1][0];
}

// 空间复杂度优化版本
int maxProfit_k_inf(int[] prices) {
    int n = prices.length;
    int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
    for (int i = 0; i < n; i++) {
        int temp = dp_i_0;
        dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]);
        dp_i_1 = Math.max(dp_i_1, temp - prices[i]);
    }
    return dp_i_0;
}

第三题，看力扣第 309 题「 最佳买卖股票时机含冷冻期」，也就是 k 为正无穷，但含有交易冷冻期的情况：

在这里插入图片描述
状态转移方程：

dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
dp[i][1] = max(dp[i-1][1], dp[i-2][0] - prices[i])
解释：第 i 天选择 buy 的时候，要从 i-2 的状态转移，而不是 i-1 。

完整代码：

// 原始版本
int maxProfit_with_cool(int[] prices) {
    int n = prices.length;
    int[][] dp = new int[n][2];
    for (int i = 0; i < n; i++) {
        if (i - 1 == -1) {
            // base case 1
            dp[i][0] = 0;
            dp[i][1] = -prices[i];
            continue;
        }
        if (i - 2 == -1) {
            // base case 2
            dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] + prices[i]);
            // i - 2 小于 0 时根据状态转移方程推出对应 base case
            dp[i][1] = Math.max(dp[i-1][1], -prices[i]);
            //   dp[i][1] 
            // = max(dp[i-1][1], dp[-1][0] - prices[i])
            // = max(dp[i-1][1], 0 - prices[i])
            // = max(dp[i-1][1], -prices[i])
            continue;
        }
        dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] + prices[i]);
        dp[i][1] = Math.max(dp[i-1][1], dp[i-2][0] - prices[i]);
    }
    return dp[n - 1][0];
}

// 空间复杂度优化版本
int maxProfit_with_cool(int[] prices) {
    int n = prices.length;
    int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
    int dp_pre_0 = 0; // 代表 dp[i-2][0]
    for (int i = 0; i < n; i++) {
        int temp = dp_i_0;
        dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]);
        dp_i_1 = Math.max(dp_i_1, dp_pre_0 - prices[i]);
        dp_pre_0 = temp;
    }
    return dp_i_0;
}

第四题，看力扣第 714 题「 买卖股票的最佳时机含手续费」，也就是 k 为正无穷且考虑交易手续费的情况：
在这里插入图片描述
状态转移方程：

dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i] - fee)
解释：相当于买入股票的价格升高了。
在第一个式子里减也是一样的，相当于卖出股票的价格减小了。

完整代码：

// 原始版本
int maxProfit_with_fee(int[] prices, int fee) {
    int n = prices.length;
    int[][] dp = new int[n][2];
    for (int i = 0; i < n; i++) {
        if (i - 1 == -1) {
            // base case
            dp[i][0] = 0;
            dp[i][1] = -prices[i] - fee;
            //   dp[i][1]
            // = max(dp[i - 1][1], dp[i - 1][0] - prices[i] - fee)
            // = max(dp[-1][1], dp[-1][0] - prices[i] - fee)
            // = max(-inf, 0 - prices[i] - fee)
            // = -prices[i] - fee
            continue;
        }
        dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
        dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i] - fee);
    }
    return dp[n - 1][0];
}

// 空间复杂度优化版本
int maxProfit_with_fee(int[] prices, int fee) {
    int n = prices.length;
    int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
    for (int i = 0; i < n; i++) {
        int temp = dp_i_0;
        dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]);
        dp_i_1 = Math.max(dp_i_1, temp - prices[i] - fee);
    }
    return dp_i_0;
}

第五题，看力扣第 123 题「 买卖股票的最佳时机 III」，也就是 k = 2 的情况：

在这里插入图片描述

状态转移方程：

原始的状态转移方程，没有可化简的地方
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])

与之前的不一样，需要对k进行穷举

// 原始版本
int maxProfit_k_2(int[] prices) {
    int max_k = 2, n = prices.length;
    int[][][] dp = new int[n][max_k + 1][2];
    for (int i = 0; i < n; i++) {
        for (int k = max_k; k >= 1; k--) {
            if (i - 1 == -1) {
                // 处理 base case
                dp[i][k][0] = 0;
                dp[i][k][1] = -prices[i];
                continue;
            }
            dp[i][k][0] = Math.max(dp[i-1][k][0], dp[i-1][k][1] + prices[i]);
            dp[i][k][1] = Math.max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i]);
        }
    }
    // 穷举了 n × max_k × 2 个状态，正确。
    return dp[n - 1][max_k][0];
}

优化版本：

public class Solution {

    public int maxProfit(int[] prices) {
        int len = prices.length;
        if (len < 2) {
            return 0;
        }
			//dp[i][j]表示第i次交易的状态
        int[][] dp = new int[3][2];
        dp[1][1] = -prices[0];
        dp[2][1] = Integer.MIN_VALUE;
        for (int i = 1; i < len; i++) {
            dp[1][1] = Math.max(dp[1][1], -prices[i]);
            dp[1][0] = Math.max(dp[1][0], dp[1][1] + prices[i]);
            dp[2][1] = Math.max(dp[2][1], dp[1][0] - prices[i]);
            dp[2][0] = Math.max(dp[2][0], dp[2][1] + prices[i]);
        }
        return Math.max(dp[1][0], dp[2][0]);
    }
}

第六题，看力扣第 188 题「 买卖股票的最佳时机 IV」，即 k 可以是题目给定的任何数的情况：
在这里插入图片描述
有了上一题 k = 2 的铺垫，这题应该和上一题的第一个解法没啥区别，你把上一题的 k = 2 换成题目输入的 k 就行了。

class Solution {
    public int maxProfit(int k, int[] prices) {
        int len = prices.length;
        if (len < 2||k==0) {
            return 0;
        }
			
        int[][] dp = new int[k+1][2];
        dp[1][1] = -prices[0];
        for(int i=2;i<=k;i++){
            dp[i][1] = Integer.MIN_VALUE;
        }
        
        for (int i = 1; i < len; i++) {
            dp[1][1] = Math.max(dp[1][1], -prices[i]);
            dp[1][0] = Math.max(dp[1][0], dp[1][1] + prices[i]);
            for(int j=2;j<k+1;j++){
                dp[j][1] = Math.max(dp[j][1], dp[j-1][0] - prices[i]);
                dp[j][0] = Math.max(dp[j][0], dp[j][1] + prices[i]);
            }

        }
        int max=dp[1][0];
        for(int i=1;i<k+1;i++)
            max=Math.max(max, dp[i][0]);

        return max;
    }
}
Joey Liao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode股票买卖-LeetcodeMayChallenge2020:31天leetcode挑战！一天，一个问题！#leetcode#挑
07-06
leetcode股票买卖力扣五月挑战 2020 31 天 leetcode 挑战！ 一天，一个问题！ #leetcode #挑战 下面我将列出日常问题以及问题所基于的核心概念以及我在以以下格式解决问题时遇到的任何困难！ 第 n 天：问题标题 --&...
团灭 LeetCode 股票买卖问题
07-04 712
目录 1、动态规划架构 1.1、穷举框架 1.2、状态转移框架 2、LeetCode121. 买卖股票的最佳时机 2.1、动态规划 2.2、寻找历史最小值 3、LeetCode122. 买卖股票的最佳时机 II 3.2、峰谷法 3.3、贪心算法（遇到递增就累加） 4、LeetCode123. 买卖股票的最佳时机 III 5、LeetCode188. 买卖股票的最佳时机 IV 6、LeetCode309. 最佳买卖股票时机含冷冻期 7、LeetCode714. 买卖股票的最佳时机含手
股票问题
wxmnq66的博客
08-23 246
解题思路： 很多读者抱怨股票系列问题奇技淫巧太多，如果面试真的遇到这类问题，基本不会想到那些巧妙的办法，怎么办？所以本文拒绝奇技淫巧，而是稳扎稳打，只用一种通用方法解决所用问题，以不变应万变。 这篇文章用状态机的技巧来解决，可以全部提交通过。不要觉得这个名词高大上，文学词汇而已，实际上就是 DP table，看一眼就明白了。 先随便抽出一道题，看看别人的解法： C++ int maxProfit(...
C刷题：一个方法团灭LeetCode股票买卖问题
来知晓的博客
05-08 214
C刷题：一个方法团灭LeetCode股票买卖问题核心框架易错点LeetCode相关题目 Git项目地址：LeetCodeUsingC刷题笔记 本篇解法思路参考了labuladong的算法小抄里的文章《一个方法团灭 LeetCode 股票买卖问题》，将原来C++代码，根据C代码实现做了部分调整和简化。下面根据个人理解，总结下C代码实现时，一些核心要点和注意事项。 核心框架 关键点 理解状态遍历的思路本质，类似于知道初始条件，不断迭代所有可能，最终得到结果 记住状态转移方程写法和初始条件，并灵活应用 买前必须
一个方法团灭 LEETCODE 股票买卖问题
Alex抱着爆米花的博客
05-12 74
使用动态规划技巧团灭力扣股票买卖问题
leetcode买卖股票问题-LeetCode:力码
07-07
leetcode买卖股票问题力码 由 Java 实现的 LeetCode。 按数据结构 大批 细绳 链表 两个数字相加 从列表末尾删除第 N 个节点 合并两个排序列表 合并 k 个排序列表（时间限制问题。需要 [O = kLog(n)]） 成对交换节点 ...
leetcode股票买卖-IshGill:伊什吉尔
07-06
leetcode股票买卖欢迎 我的名字是伊什吉尔 我是奥克兰大学计算机科学专业的学生和热情的软件工程师 :telescope: 我目前正在从事股票和加密货币投资组合项目。 在这里查看： :people_with_bunny_ears: 愿意在任何与...
leetcode 买卖股票的最佳时机 II java
01-06
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。 注意：你不能同时参与多笔交易（你必须在再次购买前...
Java实现 LeetCode 123 买卖股票的最佳时机 III（三）
01-06
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。 注意: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 ...
通用解法团灭LeetCode股票买卖问题
More than coding
02-02 468
本文受labuladong-团灭 LeetCode 股票买卖影响，在其基础上增加了自己的阐述，方便理解 在LeetCode上有这么6道买卖股票的问题，如果你单独去看每道题的题解，可能会觉得这好像是不同的6道题，而且有的解法很精巧，不可能在短时间内想到。 其实这6道题都是同一道题（买卖股票的最佳时机 IV）的变种，如果这道题我们会了，那么就可以一举把这6题都拿下。那么接下来我们来看看如何解这道“始祖”题。 这里要注意：一笔交易是指从买入股票到卖出的整个过程。 我们先来看一下为什么这道题能用动态规划求解.
leetcode 团灭股票系列问题
Elon Zero的博客
10-07 335
这 6 道股票买卖问题是有共性的，我们通过对第四题（限制最大交易次数为 k）的分析一道一道解决。因为第四题是一个最泛化的形式，其他的问题都是这个形式的简化。 第一题是只进行一次交易，相当于 k = 1；第二题是不限交易次数，相当于 k = +infinity（正无穷）；第三题是只进行 2 次交易，相当于 k = 2；剩下两道也是不限次数，但是加了交易「冷冻期」和「手续费」的额外条件，其实就是第二题...
团灭动态规划经典-----买卖股票最佳时机问题
m0_61791601的博客
04-26 366
万字动态规划经典题解，团灭买卖股票最佳时机问题。
团灭6道leetcode股票买卖问题 Java
Mr_Lewis的博客
09-07 153
Leetcode 上共有 6 道 股票买卖问题，分别是 121（1次交易），122（无限次交易），123（2次交易），188（k次交易），309（无限次交易且卖出后有一天冷冻期），714（无限次交易且每次卖出包含固定手续费），这6道问题可以用同一个状态转移方程解决： i表示当前天数，k表示目前可交易次数，0表示空仓状态，1表示持仓状态 dp[i][k][0] = Math.max(dp[i-1][k][0],dp[i-1][k][1]+price[i]) 上一行表示第i天可进行k次交易且空仓状态，可能是
LeetCode-122. Best Time to Buy and Sell Stock II
qq_17753903的博客
10-18 230
0.原题 Say you have an array for which the ith element is the price of a given stock on day i. Design an algorithm to find the maximum profit. You may complete as many transactions as you like (i.e., ...
力扣HOT100 - 1143. 最长公共子序列
qq_61504864的博客
05-20 305
【代码】力扣HOT100 - 1143. 最长公共子序列。
LeetCode 2644.找出可整除性得分最大的整数：暴力模拟（两层循环）
<font color="Pink">Tisfy的博客</font>
05-18 871
LeetCode 2644.找出可整除性得分最大的整数：暴力模拟（两层循环） 给你两个下标从 0 开始的整数数组 nums 和 divisors 。 divisors[i] 的 可整除性得分 等于满足 nums[j] 能被 divisors[i] 整除的下标 j 的数量。 返回 可整除性得分 最大的整数 divisors[i] 。如果有多个整数具有最大得分，则返回数值最小的一个。
每日5题Day7 - LeetCode 31 - 35
alimamaalala的博客
05-19 141
注意这道题的处理逻辑，我们应该走最右边的数i开始，向左遍历找到小于他的数j，然后交换，一定要注意交换后右边序列（j所在位置的后一位）也要满足是升序（因为刚刚已经完成升序了，每次升一点，所有子序列就要满足是最小升序，如果看文字太抽象，请用[2,3,1]这个例子自行模拟）
【算法】【二叉树，DFS，哈希集合，分类讨论】力扣1110. 删点成林
最新发布
未来就在脚下。
05-20 680
本题通过DFS遍历二叉树，结合分类讨论的方法，逐步删除指定节点并生成新的森林。该算法有效地处理了节点删除后树结构的调整问题，并通过哈希集合优化删除判断的时间复杂度，最终实现了高效的解决方案。
动态规划股票买卖问题
08-25
动态规划股票买卖问题是一系列与股票买卖相关的问题。通过动态规划的方法，可以解决多种情况下的股票买卖问题。这些问题包括买卖一次到买卖多次，买卖两次到买卖k次，以及考虑冷冻期和手续费等多种情况。 动态规划...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值