动态规划问题总结

最新推荐文章于 2020-05-07 12:19:16 发布
最新推荐文章于 2020-05-07 12:19:16 发布
阅读量209 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39373577/article/details/99754240
版权

一、
鉴别：题目里有最优、最长、最大、最小、计数等字眼，要考虑是否是DP问题

二、解决思路
将原问题拆解成子问题

  1. 所有的动归问题基本都可以使用递归求解（想象斐波那契数列），寻找递推公式，这里的设计要考虑无效性，即如果我走了当前这一步，会造成什么后果（比如下一步不能走）。
  2. 但是利用递归会出现大量的冗余计算，这时要想着怎么优化问题——去冗余（一般问题都是离散的，这样把之前计算的结果保存到数组、二维数组、map等数据结构中，就可以防止重复计算）
  3. 递归是自顶向下计算，从n推到0，可以使用循环（自底向上）从0推到N设计，避免递归。

三、经典题

  • 斐波那契数列（上台阶）
  • 机器人在棋盘中的路径
#include <iostream>
#include <vector>
using namespace std;
int uniquePaths(int m, int n);
int main()
    {
        int a=2,b=4;
       int r= uniquePaths(a,b);
        cout<<r<<endl;
    }

int uniquePaths(int m, int n)
{
    int res[m][n];
    res[0][0]=1;
    for(int i=0;i<m;i++)
        res[i][0]=1;
    for(int i=1;i<n;i++)
    {
        res[0][i]=1;
    }
    for(int i=1;i<m;i++)
    {
        for(int j=1;j<n;j++)
        {
            res[i][j]=res[i-1][j]+res[i][j-1];
            if(j==1d&&i==1)
                res[i][j]=0;
        }
    }
    return res[m-1][n-1];
}
  • 排列组合
  • 01背包
#include<iostream>
using namespace std;


int main()
{
    int N,V;
    cin>>N>>V;
    int weight[N];
    int vaule[N];
    for(int i=1;i<=N;i++)
      cin>>weight[i]>>vaule[i];
    int f[N+1][V+1];
    for(int i=0;i<=N;i++)
    {
        for(int j=0;j<=V;j++)
        {
            f[i][j]=0;
        }
    }
    for(int i=1;i<=N;i++)
    {
        for(int j=1;j<=V;j++)
        {
            f[i][j]=f[i-1][j];
            if(j>=weight[i])
            f[i][j]=max(f[i][j],f[i-1][j-weight[i]]+vaule[i]);
        }
        
    }
    cout<<f[N][V];
}
   //空间复杂度N*V,时间复杂度N*V
   
/****************************************************************/
优化空间复杂度的办法，用一个一维数组存储状态 （通用解法，使用滚动数组）
#include<iostream>
using namespace std;


int main()
{
    int N,V;
    cin>>N>>V;
    int weight[N];
    int vaule[N];
    for(int i=1;i<=N;i++)
      cin>>weight[i]>>vaule[i];
    int f[V+1];
        for(int j=0;j<=V;j++)
        {
            f[j]=0;
        }
    
    for(int i=1;i<=N;i++)
    {
        for(int j=V;j>=weight[i];j--)
        {
            f[j]=max(f[j],f[j-weight[i]]+vaule[i]); 改成一维数组
        }
        
    }
    cout<<f[V];
}
  • 完全背包问题（leedcode322）
    在这里插入图片描述
    完全背包问题有一个套路魔板
int main()
{
    int N,V;
    cin>>N>>V;
    int weight[N];
    int vaule[N];
    for(int i=1;i<=N;i++)
      cin>>weight[i]>>vaule[i];
    int f[V+1];
        for(int j=0;j<=V;j++)
        {
            f[j]=0;
        }
    
    for(int i=1;i<=N;i++)
    {
    /*******************************************************************************************
     ///主要的不同就在这里,就是01背包的起始范围反转一下,为什么这样做呢？原因是由于范围是从weight[i]~V,从小到
    ///到大运行，这样f[j-weight[i]（因为在j之前）在本次循环里就算过了，f[j-weight[i]]这个状态的意义是总数为j-weight[i]
    时，可能的最值，这里可能已经包含了若干个i物品，因为发f[j-weight]这个状态，是在第i次循环里面得到的。从而实现了
    一个i可以被取多次的条件。
    *************************************************************************************************/
        for(int j=weight[i];j<=V;j++) 
        {
            f[j]=max(f[j],f[j-weight[i]]+vaule[i]); 改成一维数组
        }
        
    }
    cout<<f[V];
}

复杂度较高的直观写法
 #include<iostream>
using namespace std;


int main()
{
    int N,V;
    cin>>N>>V;
    int weight[N];
    int vaule[N];
    for(int i=1;i<=N;i++)
        cin>>weight[i]>>vaule[i];
    int dp[V+1];
    
        for(int j=0;j<=V;j++)
            dp[j]=0;
    
    
    for(int i=1;i<=N;i++)
    {
        for(int j=V;j>=0;j--)  ///从后往前便利是为了变一维数组时，用到的是i-1时刻的状态
        {
            for(int k=0;k<=j/weight[i];k++)
            {
                dp[j] = max(dp[j], dp[j-weight[i]*k] + k*vaule[i]);
            }
        }
    }
    cout<< dp[V]<<endl;
    return 0;
}
  • 多重背包问题
    多重背包是限制单个物品个数的完全背包问题，其实就是在01背包上在套一个循环用来限制单个物体的取样次数。
#include<iostream>
using namespace std;
int main()
{
    int N,V;
    cin>>N>>V;
    int weight[N];int value[N];int count[N];
    for(int i=0;i<N;i++)
        cin>>weight[i]>>value[i]>>count[i];
    int dp[V+1];
    for(int i=0;i<V+1;i++)
        dp[i]=0;
    for(int i=0;i<N;i++)
    {
        for(int j=V;j>=0;j--)
        {
            for(int k=0;(k<=count[i])&&(k*weight[i]<=j);k++)
               dp[j]=max(dp[j],dp[j-k*weight[i]]+k*value[i]);  这里比01背包多加了一层循环，用来约束单个物体的取样次数问题
        }
    }
    cout<<dp[V];
    return 0;
}

优化解法（二进制优化）
多重背包的解法出现了三层循环，可以优化成两层循环，具体的优化思想是，每个物体可以取s次，可以把这s次当成一样的s个独立的物体，这样，多重背包问题就转化成了01背包问题，但是这里面有一个问题，就是将每个物体很多次这个事儿看成独立的物体，s的总次数如果比较多，就会出现较高的复杂度，于是使用取log的方式优化，举个例子，物体a可以选10次
那么现在把10拆分:
10=1+2+4 10-(1+2+4)=3 那么现在将10分成1,2,4,3这四组，我们可以发现，这四组，0~10都可以由这4个数通过某种方式组合得到，所以10次现在就等价于1,2,4,3次，这样就把原本需要拆分10次的问题变成了拆分4次，降低了时间消耗。

#include<iostream>
#include<vector>
using namespace std;
int main()
{
    struct Good
    {
        int w,v;
    };
    vector<Good> Goods;
    int N,V;
    cin>>N>>V;
    int dp[V+1];
    for(int i=0;i<V+1;i++)
      dp[i]=0;
    for(int i=0;i<N;i++)
    {
        int w,v,s;
        cin>>w>>v>>s;
        for(int k=1;k<=s;k*=2)
        {
            s-=k;
            Goods.push_back({w*k,v*k});
        }
        if(s>0)
            Goods.push_back({w*s,v*s});
    }
    for(auto i:Goods)
    {
        for(int j=V;j>=i.w;j--)
        {
            dp[j]=max(dp[j],dp[j-i.w]+i.v);
        }
        
    }
    cout<<dp[V];
    return 0;

}

优化解法2（单调队列解法） ///先放一放，去看看滑动窗口。。。

- 混合背包问题
第一类物品只能用1次
第二类物品可以用无限次
第三类物品可以用多次
混合背包问题其实就是01背包、完全背包、多重背包的组合题，只需要根据条件带入不同的情况就行了

时间复杂度较高的写法（主要是因为多重背包问题造成的，可以使用二进制优化）

#include<iostream>
using namespace std;
int main()
{
    int N,V;
    cin>>N>>V;
    int dp[V+1];
    /*struct Thing
    {
        int kind;
        int w;
        int V;
    };*/
    for(int i=0;i<V+1;i++)
        dp[i]=0;
    for(int i=0;i<N;i++)
    {
        int w,v,s;
        cin>>w>>v>>s;
        if(s==-1)
        {
            for(int j=V;j>=w;j--)
                dp[j]=max(dp[j],dp[j-w]+v);
        } 
        else if(s==0)
        {
            for(int j=w;j<=V;j++)
            {
                dp[j]=max(dp[j],dp[j-w]+v);
            }
        }
        else
            for(int j=V;j>=0;j--)
            {
                for(int k=0;k*w<=j&&k<=s;k++)
                    dp[j]=max(dp[j],dp[j-k*w]+k*v);
            }
    }
     cout<<dp[V];
        return 0;
}

二进制优化（把所有的数据放一个结构体里）

#include<iostream>
#include<vector>
using namespace std;
int main()
{
    int N,V;
    cin>>N>>V;
    int dp[V+1];
    struct Thing
    {
        int w;
        int v;
        int kind;
    };
    vector<Thing>Things;
    for(int i=0;i<V+1;i++)
        dp[i]=0;
    for(int i=0;i<N;i++)
    {
        int w,v,s;
        cin>>w>>v>>s;
        if(s==-1)
        {
            Things.push_back({w,v,s});
        }
        else if(s==0)
        {
            Things.push_back({w,v,s});
        }
        else
        {
            for(int k=1;k<=s;k*=2)
            {
                s-=k;
                Things.push_back({k*w,k*v,-1});
            }
            if(s>0)
                Things.push_back({s*w,s*v,-1});
        }
    }
    for(auto i:Things)
    {
        if(i.kind==-1)
        {
            for(int j=V;j>=i.w;j--)
                dp[j]=max(dp[j],dp[j-i.w]+i.v);
        }
        else
        {
            for(int j=i.w;j<=V;j++)
            {
                dp[j]=max(dp[j],dp[j-i.w]+i.v);
            }
        }
    }
     cout<<dp[V];
        return 0;
}
  • 二维背包问题
    一个物体不仅有体积，还有重量
    用一个二维数组保存状态dp[j][k]表示j体积，k重量下的最大值
#include<iostream>
using namespace std;
int main()
{
    int N,V,M;
    cin>>N>>V>>M;
    int dp[V+1][M+1];
    for(int i=0;i<V+1;i++)
    {
        for(int j=0;j<M+1;j++)
        dp[i][j]=0;
    }
    for(int i=0;i<N;i++)
    {
        int w,m,v; ///体积、重量、价值
        cin>>w>>m>>v;
        for(int j=V;j>=w;j--)
        {
            for(int k=M;k>=m;k--)
                dp[j][k]=max(dp[j][k],dp[j-w][k-m]+v);
        }
    }
    cout<<dp[V][M];
    return 0;

}
  • 分组背包问题

分组背包问题是把物体分成若干组，每一组里只能选一个物体
比如当前循环到了第i组，需要从第i组中挑出一个物体
for(int a=0;a<第i组的物体个数;a++)
{
for(j=V;j>a这个物体的体积;j++) 这里能体现出同一组物体之间的互斥关系
dp[j]=max{dp[j],dp[j-a的体积]+a的价值
}

#include<iostream>
using namespace std;
int main()
{
    int N,V;
    cin>>N>>V;
    int dp[V+1];
    for(int i=0;i<V+1;i++)
        dp[i]=0;
    int weight[101]{0};
    int value[101]{0};
    for(int i=0;i<N;i++)
    {
        int a; ///某组有几个物品
        cin>>a;
        for(int j=0;j<a;j++)
        {
           cin>>weight[j]>>value[j];
        }
        for(int k=V;k>=0;k--)
        {
            for(int r=0;r<a;r++)
            {
                if(weight[r]<=k)
                 dp[k]=max(dp[k],dp[k-weight[r]]+value[r]);
            }
               
        }
    }
    cout<<dp[V];
    return 0;
}
  • 背包问题求方案数
    最优选择一共有多少种不同的方案
#include<iostream>
using namespace std;
int main()
{
    int mod=100000007;
    int N,V;
    cin>>N>>V;
    int f[V+1];  
 /*****************************************************************************
注意这里与01背包的区别，01背包的f数组表示体积小于等于j时的最大价值，但是j并不一定全用了，比如体积是10的时候最大价值是5，但是可能在体积是9的时候最大价值就已经是5了，体积是10的时候的最大价值
其实和体积为9的时候是一样的。那么，如何让数组f[j]表示的是正好体积是j的时候的方案数呢？在初始化f[j]
数组的时候，如果f[0]等于0，其他的都初始化为负无穷，这样所有的状态都是从f[0]转换过来的，这样就可以
了。
如果像01背包那样，需要把f[0]数组全部初始化为0
************************************************************************************/
    int g[V+1]; ///开一个g数组，表示最大价值正好是j时，总的方案数是多少
    for(int i=0;i<V+1;i++)
    {
        f[i]=INT32_MIN;
        g[i]=0;
    }
    g[0]=1;
    for(int i=0;i<N;i++)
    {
        int w,v;
        cin>>w>>v;
        for(int j=V;j>=w;j--)
        {
            int t=max(f[j],f[j-w]+v);
            int s=0;
            if(t==f[j]) s=s+g[j];
            if(t==f[j-w]+v) s=s+g[j-w]; 看t是从哪个状态转移过来的
            if(s>=mod) s-=mod;
            f[j]=t;
            g[j]=s;
        }
    }
    int maxv=0;
    for(int i=0;i<=V;i++)
    {
        maxv=max(maxv,f[i]);  ///找出最优的方案
    }
    int res=0;
    for(int i=0;i<=V;i++)
    {
        if(f[i]==maxv)
        {
            res+=g[i];     统计最优方案的方案种数
            if(res>=mod)res-=mod;
        }
    }
    cout<<res;
    return 0;
}
  • 求背包问题的一个具体方案（输出字典排序最小的一个）
#include <iostream>
using namespace std;
int main() {
    int N, V;
    cin >> N >> V;
    int w[N + 1];
    w[0] = 0;
    int v[N + 1];
    v[0] = 0;
    int dp[N + 2][V + 2];
    for (int i = 0; i < N + 2; i++) {
        for (int j = 0; j < V + 2; j++)
            dp[i][j] = 0;
    }
    for (int i = 1; i < N + 1; i++) {
        cin >> w[i] >> v[i];
    }
从第N个物品开始取，直到取到第一个物体，为什么这么取呢，因为我们想要字典排序最小的输出，所以比
如我们需要先确定第一个物体要不要选，如果要选，把他输出出来，而不是先找第N个物体要不要选。
    for (int i = N; i >=1; i--) {
        for (int j = 0; j <= V; j++) {
            dp[i][j] = dp[i+1][j];
            if (j >= w[i])
                dp[i][j] = max(dp[i][j], dp[i+1][j - w[i]] + v[i]);
        }
    }
    int vol=V;
    for(int i=1;i<=N;i++) 
    {
        if(vol>=w[i]&&dp[i][vol]==dp[i+1][vol-w[i]]+v[i])
        {
            cout<<i<<" ";
            vol-=w[i];
        }
    }
    return 0;
}
书生落拓
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
常见动态规划问题总结
mc695192383的博客
04-12 1万+
最近毕业面临找工作的问题，在刷各大厂笔试题的时候发现大厂特别爱考一类问题，就是动态规划问题。于是决定将我见到的各类常见的动态规划问题做个总结，方便后期复习。 动态规划即Dynamic Programming，简称DP，初接触动态规划问题会觉得这类问题很抽象，晦涩难懂，不同的问题的求解思路也是千差万别，但是从本质上来看动态规划问题，最核心的思想就是将一个大的问题拆分成一个一个的子问题，通过定义问
dp动态规划动归经典问题买书问题01背包
10-17
买书问题 dp实现 题目：买书 有一书店引进了一套书，共有3卷，每卷书定价是60元，书店为了搞促销，推出一个活动，活动如下： 如果单独购买其中一卷，那么可以打9.5折。 如果同时购买两卷不同的，那么可以打9折。 如果同时购买三卷不同的，那么可以打8.5折。 如果小明希望购买第1卷x本，第2卷y本，第3卷z本，那么至少需要多少钱呢？（x、y、z为三个已知整数）。 1、过程为一次一次的购买，每一次购买也许只买一本（这有三种方案），或者买两本（这也有三种方案）， 或者三本一起买（这有一种方案），最后直到买完所有需要的书。 2、最后一步我必然会在7种购买方案中选择一种，因此我要在7种购买方案中选择一个最佳情况。 3、子问题是，我选择了某个方案后，如何使得购买剩余的书能用最少的钱？并且这个选择不会使得剩余的书为负数 。母问题和子问题都是给定三卷书的购买量，求最少需要用的钱，所以有"子问题重叠"，问题中三个购买量设置为参数， 分别为i、j、k。 4、的确符合。 5、边界是一次购买就可以买完所有的书，处理方式请读者自己考虑。 6、每次选择最多有7种方案，并且不会同时实施其中多种，因此方案的选择互不影响，所以有"子问题独立"。 7、我可以用minMoney[i][j][k]来保存购买第1卷i本，第2卷j本，第3卷k本时所需的最少金钱。 8、共有x * y * z个问题，每个问题面对7种选择，时间为：O( x * y * z * 7) = O( x * y* z )。 9、用函数MinMoney(i,j,k)来表示购买第1卷i本，第2卷j本，第3卷k本时所需的最少金钱，那么有： MinMoney(i,j,k)=min(s1,s2,s3,s4,s5,s6,s7),其中s1,s2,s3,s4,s5,s6,s7分别为对应的7种方案使用的最少金钱： s1 = 60 * 0.95 + MinMoney(i-1,j,k) s2 = 60 * 0.95 + MinMoney(i,j-1,k) s3 = 60 * 0.95 + MinMoney(i,j,k-1) s4 = (60 + 60) * 0.9 + MinMoney(i-1,j-1,k) s5 = (60 + 60) * 0.9 + MinMoney(i-1,j,k-1) s6 = (60 + 60) * 0.9 + MinMoney(i-1,j,k-1) s7 = (60 + 60 + 60) * 0.85 + MinMoney(i-1,j-1,k-1)
动态规划之线性动归
mazi的博客
07-08 7304
线性规划是一类问题。目标函数为特定变量的线性函数，约束是这些变量的线性不等式（standard form）或等式（slack form），目的是求目标函数的最大值或最小值。这类动态规划是平时比较常见的一类动态规划问题。 一、钢条切割问题： 假设公司出售一段长度为i英寸的钢条的价格为Pi（i = 1, 2, …单位：美元），下面给出了价格表样例： 长度i
一道动归问题
liyanguestc的专栏
08-01 856
                           Card Game   The multiplication puzzle is played with a row of cards,each containing a single positive integer.The player takes one card out of the row and scores the number
C：动态规划算法详解及走方格问题
AngelDg的博客
09-26 6243
问题描述： 小明从A点要去B点，请问有多少种不同的路线？规则是只能向下和向右走。 思绪： 典型的动归问题，假设B在A的右边，此时只有一条路线；B在A的下面，也只有一条路线； 然后慢慢累加，如下图所示！ 问题扩展： 此时在A到B的路程中有一柱子挡着（柱子不能被翻越）。请问有多少种不同的路线？ 思绪 同上所述，不考虑柱子占据的位置，慢慢累加！ 代码如下： #define _CRT_SECU...
C++之动态规划问题汇总
最新发布
03-05
leetcode常见动态规划问题整理，包括解答和思路以及一些模式化的代码结构~
01背包问题动态规划z
11-16
动态规划解决问题的关键在于状态转移方程，01背包问题的状态转移方程可以总结为： ```markdown dp[i][w] = max(dp[i-1][w], dp[i-1][w-wi]+vi) if w >= wi dp[i-1][w] otherwise ``` 这里的max操作确保了我们始终...
动态规划-背包问题1
08-03
总结来说，0-1背包问题是一个典型的动态规划问题，其核心在于利用最优子结构和重叠子问题的特性，通过递归公式构建并填充一个二维数组，以找到背包容量限制下的最大价值解决方案。在实现过程中，通过跳跃点优化可以...
动态规划法求解0-1背包问题实验报告.pdf
06-05
总结来说，动态规划法求解0-1背包问题的关键在于构建正确的状态转移方程，并通过填表的方式逐步计算出所有子问题的最大价值。这种思想不仅可以应用于背包问题，还可以广泛应用于其他优化问题，如最长公共子序列、...
山东财经大学新生赛暨天梯赛选拔赛 D 流星雨 (区间贪心)
Romantic Chopin in C Sharp Minor
03-16 245
链接：https://ac.nowcoder.com/acm/contest/547/D 来源：牛客网 题目描述 英仙座流星雨（学名Perseids）是以英仙座γ星附近为辐射点出现的流星雨，也称英仙座γ流星雨。每年在7月20日至8月20日前后出现，于8月13日达到高潮。与象限仪座流星雨、双子座流星雨并称为北半球三大流星雨。 暑假到了，又是一个去看流星雨的好季节。 看流星雨最重要的...
【动态规划】常见动态规划题目总结
I am what i am
08-10 4382
此博客是为总结动态规划常见题目 题目1：word break 1.1 题目描述： Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words. For exa...
Note: 动态规划问题总结
琉璃的博客
05-07 226
动态规划不是一个具体的算法，而是一种思想。 这种思想具体的就是 从局部最优解采用一定策略推导出全局最优解，从子问题的答案中一步步推出整个问题的答案。 解决动态规划问题通常采用四个步骤： 问题拆解（找到问题的子问题） 状态定义（使当前状态就是当前问题的解） 写出递推方程（之前相邻子问题的答案推出当前状态的答案） 代码实现 通过几个题目去理解动态规划和这四个步骤。 三角形最小路径和问题 ...
动态规划常见类型总结
热门推荐
FanJin的博客
03-26 1万+
本文针对动态规划的常见类型进行总结。虽说总结的是动态规划，但顺便把递推也放了进来。严格来说，递推不属于动态规划问题，因为动态规划不仅有递推过程，还要有决策（即取最优），但广义的动态规划是可以包含递推的，递推是一类简单的、特殊的动态规划，毕竟动态规划与递推密不可分。动态规划类型主要分为纯粹动态规划问题和复合动态规划问题。 几点说明： 1、博主本人于2012年对信息学竞赛中的动态规划问题进行了总结...
动态规划问题个人总结
一名渣程序员的无厘头记录
09-19 360
参考： http://www.hawstein.com/posts/dp-novice-to-advanced.html http://blog.csdn.net/a45872055555/article/details/29224177参考文章给出的内容很详细了，我仅为个人学习理解写下该文，详细内容可查看参考文章。 动态规划：从新手到专家动态规划（ Dynamic Programming，简
动态规划之背包问题
每天完成一个小目标
10-31 316
前言背包问题是动态规划的一系列经典问题，想必不少人刚接触动态规划问题时都是从这一类问题入手。最近刷LintCode时遇到了动态规划的专题，结合一直想读却一直懒得读的《背包问题九讲》，特意开一篇Blog学习一下。正题1. 01 背包问题有N件物品和一个容量为V的背包。放入第i件物品耗费的费用是Ci，得到的价值是Wi。求解将哪些物品装入背包可以使价值总和最大。基本思路这是最基本的背包问题，特点是：每种物
动态规划经典问题总结
走好每一步！
05-19 1983
动态规划解法一般分以下几步： * 描述最优子结构 * 列出状态转移方程 * 从上而下递归求解 或者从下而上递推求解 一般情况下使用递推求解比较方便，最优子结构的描述影响着求解的方式 以下是动态规划经典问题： 最大连续子序列和问题 子结构描述： sum[i] 表示以i结尾最大连续子序列和 状态转移方程 sum[i] = max(sum[i-1]+a[i], a[i]) 代码如下：
经典动态规划问题总结
zjwson的博客
08-16 624
动态规划引入 首先我们以一个最基本的例子来分析——菲波那切数列。 我们都知道，菲波那切数列的递推公式f(n) = f(n-1)+f(n-2) （这里我就说明一般情况，不列举边界条件了），很简单，如果我们用递归的方法来求解f(n)，两三行代码就出来了。那么我们深入分析一下这样有什么问题？ f(2) = f(1) + f(0); f(3) = f(2) + f(1); f(4) = f(

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值