【代码随想录】Day31~Day37贪心算法

已于 2023-01-25 12:12:13 修改
阅读量2.2k 收藏
点赞数
分类专栏： 代码随想录 文章标签： leetcode Powered by 金山文档
于 2023-01-22 00:07:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53043309/article/details/128745738
版权

理论基础

本质

选择每一阶段的局部最优解，达到全局最优。

如果找到局部最优然后退出整体最优，就是贪心。

一般步骤

  1. 将问题分解为若干个子问题

  1. 找出适合的贪心策略

  1. 求解每一个子问题的最优解

  1. 将局部最优解堆叠成全局最优解

简单题目

分发饼干：力扣455

局部最优解：大饼干给胃口大的，充分利用饼干尺寸喂饱一个；全局最优：尽可能喂饱更多的小孩。

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        //胃口排序
        sort(g.begin(),g.end());
        //饼干排序
        sort(s.begin(),s.end());
        //先遍历胃口，再遍历饼干
        int index=s.size()-1;//饼干下标
        int result=0;//记录返回结果，几个孩子能满足条件
        for(int i=g.size()-1;i>=0;i--){
            if(index>=0&&s[index]>=g[i]){ //饼干大于胃口 喂饼干
                index--;
                result++;
            }
        }
        return result;
    }
};

K次取反后最大化的数组和：力扣1005

局部最优：让绝对值大的负数变为正数，当前数值达到最大；整体最优：整个数组和达到最大

局部最优：只找数值最小的正整数进行反转；整体最优：整个数组和达到最大

class Solution {
public:
    static bool cmp(int a,int b){
        return abs(a)>abs(b);
    }
    int largestSumAfterKNegations(vector<int>& nums, int k) {
        //1.排序
        sort(nums.begin(),nums.end(),cmp);
        //2.从后向前遍历，如果小于0，就变为正数且k--
        for(int i=0;i<nums.size();i++){
            if(nums[i]<0&&k>0){
                nums[i]*=-1;
                k--;
            }
        }
        //3.如果k>0，反复反转数值最小的元素，直到k=0结束
        if(k%2==1) nums[nums.size()-1]*=-1;
        int result=0;
        for(int i=0;i<nums.size();i++){
            result+=nums[i];
        }
        return result;
    }
};

柠檬水找零：力扣860

  1. 账单是5，直接收下

  1. 账单是10，消耗一个5，增加一个10

  1. 账单是20，优先消耗一个10和一个5，如果不够，再消耗三个5

美元10只能给账单20找零，而美元5可以给账单10和账单20找零，美元5更万能

局部最优：遇到账单20，优先消耗美元10，完成本次找零。全局最优：完成全部账单的找零

class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        int five=0,ten=0,twenty=0;
        for(int i=0;i<bills.size();i++){
        //情况一：收到五美元
            if(bills[i]==5){
                five++;
            }
        //情况二：收到十美元
            if(bills[i]==10){
            if(five<=0){
                return false;//直接结束了
            }
            five--;
            ten++;
        }
        //情况三：收到而是美元
        if(bills[i]==20){
             //解决一：十美元+五美元 ！优先考虑
             if(five>0&&ten>0){
                 five--;
                 ten--;
                 twenty++;
             }
             //解决二：三张五美元！其次考虑
             else if(five>=3){
                 five=five-3;
             }
             else{
                 return false;
             }
        }
        
        }
        return true;
        
    }
};

##遇到感觉没有思路的题目，可以静下心来把能遇到的情况分析一下，只要分析到具体情况了，一下子就豁然开朗了。

中等题目

序列问题

摆动序列：力扣376

局部最优：删除单调坡度上的结点（不包含单调坡度两端的结点），那么这个坡度就可以有两个局部峰值；整体最优：整个序列有最多的局部峰值，从而达到最长摆动序列。

需要考虑三种情况：

  1. 上下坡中有平坡

  1. 数组首位两端

  1. 单调坡度有平坡

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if(nums.size()<=1) return nums.size();//不满足要求，直接返回长度
        int curDiff=0;//当前一对差值
        int preDiff=0;//前一对差值
        int result=1;//记录峰值个数，序列默认最右边有一个峰值
        for(int i=0;i<nums.size()-1;i++){
            curDiff=nums[i+1]-nums[i];//当前
            //出现峰值的情况
            if((preDiff<=0&&curDiff>0)||(preDiff>=0&&curDiff<0)){
                result++;//峰值
                preDiff=curDiff;//只在摆动的时候更新prediff
            }
        }
        return result;
    }
};

**其实没有特别明白，但给完思路以后可以写出代码

单调递增的数字：力扣738

局部最优：遇到strNum[i - 1] > strNum[i]的情况，让strNum[i - 1]--，然后strNum[i]给为9，可以保证这两位变成最大单调递增整数。

全局最优：得到小于等于N的最大单调递增的整数。

class Solution {
public:
    int monotoneIncreasingDigits(int n) {
        string strNum=to_string(n);
        int flag=strNum.size();//标记从哪里开始赋值
        //从后向前遍历
        for(int i=strNum.size()-1;i>0;i--){
            if(strNum[i-1]>strNum[i]){
                strNum[i-1]--;//前一位减小
                flag=i;//标记
            }
        }
        //把哪位改成9
        for(int i=flag;i<strNum.size();i++){
            strNum[i]='9';
        }
        return stoi(strNum);
    }
};

贪心解决股票问题

买卖股票的最佳时机：力扣122

局部最优：收集每天的正利润；全局最优：获得最大利润

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result=0;//记录结果
        for(int i=1;i<prices.size();i++){//从1开始：从第二天开始才出现利润
            result+=max(prices[i]-prices[i-1],0);//只收集正利润，不收集负利润
        }
        return result;
    }
};

买卖股票的最佳时机含手续费：力扣714

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int result=0;//返回结果
        int minprice=prices[0];//记录最小值，最小值是最佳买入时间
        //循环求得最大利润
        for(int i=1;i<prices.size();i++){//从第二天开始才有利润
            //更新最小值
            if(prices[i]<minprice){
                minprice=prices[i];
            }
            //保持原状态
            if(prices[i]>=minprice&&prices[i]<=minprice+fee) continue;
            //计算利润
            if(prices[i]>fee+minprice){
                result+=prices[i]-fee-minprice;
                minprice=prices[i]-fee;
            }
        }
        return result;
    }
};

两个维度权衡问题

分发糖果：：力扣135

要确定一边之后，再确定另一边

  1. 先确定右边评分大于左边的情况

局部最优：只要右边评分比左边大，右边的孩子就多一个糖果，全局最优：相邻的孩子中，评分高的右孩子获得比左边孩子更多的糖果

  1. 确定左孩子大于右孩子的情况

局部最优：取candyVec[i + 1] + 1 和 candyVec[i] 最大的糖果数量，保证第i个小孩的糖果数量既大于左边的也大于右边的。全局最优：相邻的孩子中，评分高的孩子获得更多的糖果

class Solution {
public:
    int candy(vector<int>& ratings) {
        vector<int> candyvec(ratings.size(),1);
        candyvec[0]=1;
        //从前向后遍历
        for(int i=1;i<ratings.size();i++){
            if(ratings[i]>ratings[i-1]){
                candyvec[i]=candyvec[i-1]+1;
            }
        }
        //从后向前遍历
        for(int i=ratings.size()-2;i>=0;i--){
            if(ratings[i]>ratings[i+1]){
                candyvec[i]=max(candyvec[i],candyvec[i+1]+1);
            }
        }
        int result=0;//收集结果
        for(int i=0;i<candyvec.size();i++){
            result+=candyvec[i];
        }
        return result;
    }
};

根据身高重建队列：力扣406

两个维度，h和k，看到这种题目一定要想如何确定一个维度，然后再按照另一个维度重新排列

按照身高从大到小排序后：

局部最优：优先按身高高的people的k来插入。插入操作过后的people满足队列属性

全局最优：最后都做完插入操作，整个队列满足题目队列属性

class Solution {
public:
    //按照h的顺序由大到小进行排序
    static bool cmp(const vector<int> a,const vector<int> b){
        //当元素0相等的时候，按照k的大小，k大的在后面
        if(a[0]==b[0]){
            return a[1]<b[1];
        }
        return a[0]>b[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort(people.begin(),people.end(),cmp);//排序
        vector<vector<int>> que;
        for(int i=0;i<people.size();i++){
            int position=people[i][1];//插入的位置在哪
            que.insert(que.begin()+position,people[i]);
        }
        return que;
    }
};

有点难度

区间问题

跳跃游戏：力扣55

转化为跳跃覆盖范围究竟可不可以覆盖到终点

局部最优解：每次最大跳跃步数（得到最大覆盖范围）；整体最优解：最后得到整体最大覆盖范围，看能否到达终点。

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int cover=0;
        if(nums.size()==1) return true;//如果只有一个元素，直接就能到达
        for(int i=0;i<=cover;i++){
            cover=max(cover,nums[i]+i);
            if(cover>=nums.size()-1) return true;
        }
        return false;
    }
};

跳跃游戏ii：力扣45

局部最优：当前可移动距离尽可能夺走，如果还没到终点，部署再加一；整体最优：一步尽可能多走，从而达到最小步数。但解题时，要从覆盖范围出发，不管怎么跳跃，覆盖范围内一定是可以跳到的，以最小的部署增加覆盖范围，覆盖范围一旦覆盖了终点，得到的就是最小步数。

需要统计：当前这一步的最大覆盖和下一步最大覆盖

class Solution {
public:
    int jump(vector<int>& nums) {
        if(nums.size()==1) return 0;//只有一个元素，直接可以走到最后
        int curDistance=0;//当前距离
        int ans=0;//最大步数
        int nextDistance=0;//下一步的距离
        for(int i=0;i<nums.size();i++){
            nextDistance=max(nextDistance,nums[i]+i);//更新下一步覆盖最远距离
            if(i==curDistance){//如果遇到
                if(curDistance<nums.size()-1){//不是终点
                    ans++;
                    curDistance=nextDistance;//更新当前覆盖最远距离的下标
                    if(nextDistance>=nums.size()-1) break;//下一步的覆盖范围已经可以到达终点 循环结束
                }else break;//是终点 直接结束
            }
        }
        return ans;
    }
};

用最少数量的箭引爆气球：力扣452

局部最优：当气球出现重叠，一起射，所用弓箭最少。全局最优：把所有气球射爆所用弓箭最少。

为了让气球尽可能的重叠，需要对数组进行排序

class Solution {
public:
    static bool cmp(const vector<int> &a,const vector<int> &b){
        return a[0]<b[0];
    }
    int findMinArrowShots(vector<vector<int>>& points) {
        if(points.size()==0) return 0;
        int result=1;//起码需要一只箭
        sort(points.begin(),points.end(),cmp);
        for(int i=1;i<points.size();i++){
            if(points[i][0]>points[i-1][1]){//两个不挨着 需要+1
                result++;
            }
            else{//两个挨着 更新最小边界
                points[i][1]=min(points[i-1][1],points[i][1]);
            }
        }
        return result;
    }
};

无重叠区间：力扣435

按照右边界排序，从左向右记录非交叉区间的个数。最后用区间总数减去非交叉区间的个数就是需要移除的区间个数了。

class Solution {
public:
    // 按照区间右边界排序
    static bool cmp (const vector<int>& a, const vector<int>& b) {
        return a[1] < b[1];
    }
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if(intervals.size()==0) return 0;
        sort(intervals.begin(),intervals.end(),cmp);//排序
        int result=1;//记录非交叉的区间
        int end=intervals[0][1];//分割点：第一个区间的结束位置
        //从前往后遍历（已经按照右边排序）
        for(int i=1;i<intervals.size();i++){
            if(end<=intervals[i][0]){
                result++;
                end=intervals[i][1];
            }
        }
        return intervals.size()-result;
    }
};

划分字母区间：力扣763

在遍历的过程中相当于是要找每一个字母的边界，如果找到之前遍历过的所有字母的最远边界，说明这个边界就是分割点了。此时前面出现过所有字母，最远也就到这个边界了。

  1. 统计每一个字符最后出现的位置

  1. 从头遍历字符，并更新字符的最远出现下标，如果找到字符最远出现位置下标和当前下标相等了，则找到了分割点

class Solution {
public:
    vector<int> partitionLabels(string s) {
        int hash[27]={0};//hash[i]是字符最后出现的位置
        for(int i=0;i<s.size();i++){
            hash[s[i]-'a']=i;//最远出现的位置
        }
        int right=0;
        int left=0;
        //分割字符串
        vector<int> result;
        for(int i=0;i<s.size();i++){
            right=max(right,hash[s[i]-'a']);
            if(i==right){
                result.push_back(right-left+1);
                left=i+1;
            }
        }
        return result;
    }
};

*对代码有不明白的地方

合并区间：力扣56

左边界排序，排序之后局部最优：每次合并都取最大的右边界，这样就可以合并更多的区间了，整体最优：合并所有重叠的区间。

class Solution {
public:
    // 按照区间左边界从小到大排序
    static bool cmp (const vector<int>& a, const vector<int>& b) {
        return a[0] < b[0];
    }

    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        vector<vector<int>> result;
        if(intervals.size()==0) return result;
        sort(intervals.begin(),intervals.end(),cmp);
        bool flag=false;//表示最后一个区间是否合并进去了
        int len=intervals.size();
        for(int i=1;i<len;i++){
            int start=intervals[i-1][0];//合并的开始位置
            int end=intervals[i-1][1];//合并的结束位置
            while(i<len&&intervals[i][0]<=end){//满足合并的情况
                //更新右区间
                end=max(end,intervals[i][1]);
                //最后一个区间也合并了的情况
                if(i==len-1) flag=true;
                i++;//继续寻找下一个合并区间
            }
            result.push_back({start,end});
        }
        //如果最后的区间不合并
        if(flag==false){
            result.push_back({intervals[len-1][0],intervals[len-1][1]});
        }
        return result; 
    }
};

其他

最大子序和：力扣53

局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算”连续和“，因为附属加上下一个元素“连续和”只会越来越小；全局最优：选取最大“连续和”。局部最优的情况下，记录最大的”连续和“，可以推出全局最优。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int result=INT32_MIN;
        int count=0;
        for(int i=0;i<nums.size();i++){
            count+=nums[i];
            //区间累计的最大值（相当于不断确定最大子序列的终止位置
            if(count>result) result=count;
            //相当于重置最大子序列的开始位置，因为负数会拉低总和
            if(count<=0) count=0;
        }
        return result;
    }
};

加油站：力扣134

  1. 如果gas的总和小于cost的综合，无论从哪里出发，都跑不了一圈

  1. rest=gas-cost为一天剩下的油，i从0开始计算累加到最后一站，如果累加没有出现负数，说明从0出发油从未中断，0就是起点。

  1. 如果累加的最小值是负数，汽车就要从非0结点出发，从后向前，看哪个结点能将这个负数填平，能把这个负数填平的结点就是出发结点

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int curSum=0;
        int minv=INT_MAX;
        //计算值
        for(int i=0;i<gas.size();i++){
            int rest=gas[i]-cost[i];
            curSum+=rest;
            if(curSum<minv){
                minv=curSum;
            }
        }
        if(curSum<0) return -1;//gas总和小于cost的总和哪里都到不了 情况1
        if(minv>=0) return 0;//0是起点 情况2
            //累加的最小值是负数，得从非0结点出发，看哪个结点能把负数填平，能填平的哪个结点就是出发结点
        for(int i=gas.size()-1;i>=0;i--){
            int rest=gas[i]-cost[i];
            minv+=rest;
            if(minv>=0){
                return i;//找到能填平的点
            }
        }
        return -1;
    }
};

监控二叉树：力扣968

从下往上看，局部最优：让叶子节点的父节点安摄像头，所用摄像头最少，整体最优：全部摄像头数量所用最少

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    
public:
    int result=0;
    int traversal(TreeNode* cur){
        //终止条件
        if(cur==NULL) return 2;//空结点定义为已经覆盖的结点
        int left=traversal(cur->left);
        int right=traversal(cur->right);
        //处理逻辑:
        //1左右均覆盖
        if(left==2&&right==2) return 0;
        //2至少有一个结点没覆盖
        if(left==0||right==0) {
            result++;
            return 1;
        }
        //3至少有一个结点有摄像头
        if(left==1||right==1) return 2;
        return -1;//表示逻辑不会走到这里
    }
    int minCameraCover(TreeNode* root) {
        if(traversal(root)==0) result++; //root无覆盖
        return result;
    }
};
狗也可以叫汤姆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux 等高频考点。该 PDF 由...
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
UVA11039
天使也掉毛
11-02 634
题意：      给你一个序列，由n个数字组成，每个数字的绝对值都不相同，然后让你从这n个数中拿出一些数，组成一个绝对值递增并且正负交替的最大序列，问组成的最大序列的最大长度是多少？ 思路：       比较简单，突破口是所有数字的绝对值都不同，那么我们直接模拟就行了，直接按绝对值sort一遍，然后第一个默认是找出序列的第一个，然后直接看看有多少正负交替的就行了，具体看代码。
代码随想录 Day31 贪心算法
2302_77073236的博客
02-29 251
贪心算法最重要的就是“局部最优推全局最优”，但是每一道题的局部最优并不一样，所以要具体问题具体分析，在第53题中有了一点错误，连续的子数组中的元素可以是一个，也可以是两个，只要和最大就行，其中的局部最优即为“两元素之间的和如果连续为负数抛弃就行，因为对下一个元素的影响肯定为负面的影响，让他变小”，然后通过for循环达到全局最优。
代码随想录 Day37 贪心算法
2302_77073236的博客
03-05 433
贪心算法是一种在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而希望导致结果是全局最好或最优的算法。贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择。选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。
【代码随想录】Day 31贪心算法
weixin_43785314的博客
08-10 96
局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算“连续和”，因为负数加上下一个元素 “连续和”只会越来越小。然后从后向前遍历小孩数组，用大饼干优先满足胃口大的，并统计满足小孩数量。唯一的难点就是如何通过局部最优，推出整体最优。使用贪心策略，先将饼干数组和小孩数组排序。如何验证可不可以用贪心算法？全局最优：选取最大“连续和”做题的时候，只要想清楚。
代码随想录打卡Day 31| 贪心算法 part1
lionelwhl的博客
08-03 122
对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j]。链接：https://leetcode.cn/problems/assign-cookies。局部最优解可以有两种方式：大饼干先喂胃口大的孩子，或者小饼干先喂胃口小的孩子。例如，有一堆钞票，你可以拿走十张，如果想达到最大的金额，你要怎么拿？每次拿最大的就是局部最优，最后拿走最大数额的钱就是推出全局最优。指定每次拿最大的，最终结果就是拿走最大数额的钱。来源：力扣（LeetCode）
【代码随想录Day31】贪心算法/DP
lisatse0115的博客
02-14 63
455.分发饼干 | 376. 摆动序列 | 53. 最大子序和
代码随想录 Day32 贪心算法
2302_77073236的博客
03-01 370
贪心算法的局部最优基本都不一样，这也成为了难点，而有些简单题，做出来甚至都不知道做的时候有哪些是局部最优，所以区分辨别局部最优，是一个重点难点，之后便可以求全局最优。
代码随想录 Day34 贪心算法
2302_77073236的博客
03-03 270
今天的452题用到了重叠区间，而如何更新重叠区间，就成为了局部最优。
代码随想录 Day36 贪心算法
2302_77073236的博客
03-04 261
今天学习的重叠区间，其实核心就是如何更新边界，以及出边界的操作，刷了几道之后思路并不是很难，但是代码的实现还是有待加强
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
在《代码随想录算法PDF》中，作者可能会采用实际的LeetCode题目作为示例，通过解题过程详解每种算法的思想、步骤和优化技巧。这不仅有助于提高编程能力，也能为面试准备提供有力的支持。通过阅读和实践书中的内容，...
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
力扣Hot100-994腐烂的橘子
最新发布
qq_52241267的博客
08-10 271
由于在找到腐烂水果后直接将它周围的水果置为腐烂水果，但是可能当前轮次腐烂的水果，又在当前轮次中影响周围水果，导致错误，所以可以标记：在不同轮次中被传染腐烂的水果标记为不同的数字，由于一开始time=0时，腐烂水果标记为2，所以在time=0到1这段时间被传染的水果标记为2+time+1,这样就可以使得本轮time=0时不会让标记为3的水果传染它周围的水果。左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个方向上。因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0。
LeetCode Hard｜【25. K 个一组翻转链表】
糖炒栗子
08-06 344
首先，做整表翻转的时候，我们的逻辑非常简单。这里简单直观多了，最大的区别是什么呢？
力扣399.除法求值
Pisasama的博客
08-06 219
【代码】力扣399.除法求值。
三数之和-Leetcode
weixin_43993064的博客
08-07 343
这里去重要注意两个指针移动过程中也要去重！
《代码随想录知识星球-学习手册PDF：精华八股文，实用知识全覆盖》
《代码随想录-八股文 PDF》是一份全面总结了《代码随想录知识星球》的精华内容的PDF文件。该文件涵盖了几乎每位程序员在学习过程中必备的知识点。录友们在知识星球中的每日总结对于准备求职的程序员来说是必备的学习...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值