状压dp

最新推荐文章于 2022-08-06 20:53:41 发布
最新推荐文章于 2022-08-06 20:53:41 发布
阅读量103 收藏 1
点赞数
原文链接：http://www.cnblogs.com/Akaina/p/11374131.html
版权

状压dp

当题目中的某一项的值极小（小于等于\(20\)）时考虑使用状压\(dp\)

状压\(dp\)是二维时一般是

\(dp[i][s]\)表示进行到第\(i\)步且第\(i\)步的状态为\(s\)时的\(dp\)值

状压\(dp\)由于是二进制，多与位运算的操作有关

以下是一些常见的位运算操作：

\(1.s\&(1<<i)\) 判断第\(i\)位是否为\(1\)

\(2.s=s | (1<<i)\)把第i位设为\(1\)

\(3.s=s\&(~(1<<i))\)把第\(i\)位设为\(0\)

\(4.s=s\)^\((1<<i)\)把第\(i\)位的值取反

\(5.s=s\&(s-1)\)把\(s\)二进制下最靠右的一个\(1\)去掉

\(6.for(s0=s;s0;s0=(s0-1)\&s)\)枚举\(s\)的子集

\(7.x\&-x\)取出最低位的\(1\)

例题

互不侵犯 洛谷P1896

\(f[i][k][s]\)表示前\(i\)行放了\(k\)个国王，当前行状态为s的方案数

#include <iostream>
#include <cstdio>
using namespace std;
int n,King,tot=0;
int s[1050],pd[1050];
int num[15];
long long ans=0;
long long f[10][105][1050];
void Deal_first()
{
    for(int i=0;i<(1<<n);i++)
    {
        int cnt=0,x=i;
        pd[i]=1;
        while(x!=0)
        {
            num[++cnt]=x%2;
            x/=2;
        }
        for(int j=1;j<cnt;j++)
        {
            if(num[j]==num[j+1]&&num[j]==1)
            {
                pd[i]=0;break;
            }
            if(num[j]==1)s[i]++;
        }
        if(pd[i]==1)if(num[cnt]==1)s[i]++;
    }
}
int main()
{
    scanf("%d%d",&n,&King);tot=(1<<n)-1;
    Deal_first();
    for(int i=0;i<=tot;i++)if(pd[i]==1)f[1][s[i]][i]=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=tot;j++)
        {
            for(int k=0;k<=tot;k++)
            {
                if(!pd[j])continue;if(!pd[k])continue;
                if(((j|(j<<1)|(j>>1))&k)!=0)continue;
                for(int t=King;t>=s[j];t--)f[i][t][j]+=f[i-1][t-s[j]][k];
            }
        }
    }
    for(int i=0;i<=tot;i++)
    {
        if(pd[i])ans+=f[n][King][i];
    }
    printf("%lld",ans);
    return 0;
}

愤怒的小鸟 洛谷P2831

显然，因为原点加两个点即可确定抛物线，故抛物线的数量最多为\(n^2\)条，又因为\(n<=18\),

故考虑用状压\(dp\),枚举抛物线，复杂度为\(O（T\times n^2\times2^n)\)

但考虑到每个猪都要被打，所以可以从小到大枚举\(S\)，每次每次打掉编号最小的还没消灭的猪，
由于包含该猪的抛物线只有\(O(n)\)种，所以时间复杂度为\(O(n*2^n)\)

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
using namespace std;
#define lld long double
#define eps 1e-8
int dp[1<<19],line[20][20];
lld x[20],y[20];
int n,m;
int lowbit(int x)
{
    return x&(-x);
}
int main()
{
    int t;scanf("%d",&t);
    while(t--)
    {
    scanf("%d%d",&n,&m);
    lld z=eps;
    memset(dp,0x3f3f3f3f,sizeof(dp));
    memset(line,0,sizeof(line));
    dp[0]=0;
    for(int i=1;i<=n;i++)
    {
        //scanf("%lf%lf",&x[i],&y[i]);//double用这个
        cin>>x[i]>>y[i];//long double用这个
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(fabs(x[i]-x[j])<eps)continue;
            lld a=y[j]/(x[j]*(x[j]-x[i]))-y[i]/(x[i]*(x[j]-x[i]));
            lld b=(y[i]-a*x[i]*x[i])/x[i];
            if(a>-eps)continue;
            for(int k=1;k<=n;k++)
                if(fabs(a*x[k]*x[k]+b*x[k]-y[k])<eps)line[i][j]|=(1<<(k-1));
        }
    }
   for(int i=0;i<(1<<n);i++)
    {
        int x=-1;
        for(int j=1;j<=18;j++)
        {
            if((i&(1<<(j-1)))==0)
            {
                x=j;break;
            }
        }
        if(x==-1)continue;
        dp[i|(1<<(x-1))]=min(dp[i|(1<<(x-1))],dp[i]+1);
        for(int j=1;j<=n;j++)dp[i|line[x][j]]=min(dp[i|line[x][j]],dp[i]+1);
    }
    printf("%d\n",dp[(1<<n)-1]);
    }
    return 0;
}

玉米田

题目链接

题意：一块\(n\times m\)的牧场，有的方格可以种草，有的不能种，且任意种草的方格不能有公共边，求方案数

\(1<=n,m<=12\)

\(m\)极小，故可以用状压\(dp\)
设\(f[i][j]\)表示前i行符合条件且第\(i\)行的状态为\(j\)的方案数
预处理\(cnt[i]\)表示在不管其它行的情况下第\(i\)行符合条件的状态数，\(g[i][j]\)表示第i行符合条件的第j个状态
在转移时需满足\(g[i-1][j]\&g[i][k]==0\)

#include <iostream>
#include <cstdio>
using namespace std;
#define mol 100000000
int n,m;
int a[15][15];
int h[15],cnt[15];
int g[15][1<<15],f[15][1<<15];
void read()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            scanf("%d",&a[i][j]);
        }
    }
    for(int i=1;i<=n;i++)
    {
        int sum=0;
        for(int j=1;j<=m;j++)
        {
            sum=sum*2+a[i][j];
        }
        h[i]=sum;
    }
}
void Deal_first()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=(1<<m)-1;j++)
        {
              int pd=1;
              if((j|h[i])==h[i])
              {
                  if(((j&(j<<1))==0)&&((j&(j>>1))==0))pd=0;
                  if(!pd)g[i][++cnt[i]]=j;
              }
        }
    }
    for(int i=1;i<=cnt[1];i++)f[1][g[1][i]]=1;
}
int main()
{
    read();
    Deal_first();
    for(int i=2;i<=n;i++)
    {
        for(int j=1;j<=cnt[i-1];j++)
        {
            for(int k=1;k<=cnt[i];k++)
            {
                if((g[i-1][j]&g[i][k])==0)
                {
                    f[i][g[i][k]]=(f[i][g[i][k]]+f[i-1][g[i-1][j]])%mol;
                }
            }
        }
    }
    int ans=0;
    for(int i=1;i<=cnt[n];i++)ans=(ans+f[n][g[n][i]])%mol;
    printf("%d\n",ans);
    return 0;
}

炮兵阵地

题目链接

题意：在\(n \times m\)的网格地图中部署炮兵部队，只能在平原地形上部署，每支炮兵部队能攻击沿横向左右各两格，沿纵向上下各两格，求最多能部署多少支炮兵部队。

玉米田的变式题。

因为前面两行都会对当前行产生影响，故\(dp\)要多记录一维，但是\(f[110][1024][1024]\)会炸空间

但发现每一行合法的状态最多\(59\)种，故只需用\(f[110][70][70]\)来记录

预处理\(cnt[i]\)表示在不管其它行的情况下第i行符合条件的状态数，\(g[i][j]\)表示第i行符合条件的第j个状态

我一开始把状态编号和状态搞混了，调错调了半天。

#include <iostream>
#include <cstdio>
using namespace std;
int n,m;
char ch[110][15];
int h[110],cnt[110];
int g[110][1<<12];
int num[1<<12]={};
int f[110][70][70];
void read()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%s",ch[i]+1);
}
void Deal_first()
{
    for(int i=1;i<=n;i++)
    {
        int sum=0;
        for(int j=1;j<=m;j++)
        {
            if(ch[i][j]=='P')sum=sum*2+1;
            else sum=sum*2;
        }
        h[i]=sum;
    }
    for(int i=1;i<=(1<<m)-1;i++)
    {
        int cnt=0;
        for(int j=1;j<=m;j++)
        {
            if((i&(1<<(j-1)))!=0)cnt++;
        }
        num[i]=cnt;
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=(1<<m)-1;j++)
        {
            if((j|h[i])==h[i])//
            {
                if((((j<<2)&j)==0)&&(((j<<1)&j)==0)&&(((j>>2)&j)==0)&&(((j>>1)&j)==0))g[i][++cnt[i]]=j;
            }
        }
    }
    for(int i=1;i<=cnt[1];i++)
    {
        for(int j=1;j<=cnt[2];j++)
        {
            if((g[1][i]&g[2][j])==0)f[2][j][i]=num[g[1][i]]+num[g[2][j]];
        }
    }
}
int main()
{
    read();
    Deal_first();
    for(int i=3;i<=n;i++)
    {
        for(int j=1;j<=cnt[i];j++)
        {
            for(int k=1;k<=cnt[i-1];k++)
            {
                if((g[i][j]&g[i-1][k])==0)
                {
                    for(int t=1;t<=cnt[i-2];t++)
                    {
                        if(((g[i][j]&g[i-2][t])==0)&&((g[i-1][k]&g[i-2][t])==0))
                        {
                            f[i][j][k]=max(f[i][j][k],f[i-1][k][t]+num[g[i][j]]);
                        }
                    }
                }
            }
        }
    }
    int ans=0;
    for(int j=1;j<=cnt[n];j++)
    {
        for(int k=1;k<=cnt[n-1];k++)
        {
            if((g[n][j]&g[n-1][k])==0)
            {
                ans=max(ans,f[n][j][k]);
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}

动物园

题目链接

题意：

动物园的围栏呈环状排列

每个小朋友可以看到从他所在位置开始数的连续5个围栏，每个小朋友有他害怕或喜欢的动物。

当下面两处情况之一发生时，小朋友就会高兴：

  • 至少有一个他害怕的动物被移走
  • 至少有一个他喜欢的动物没被移走

你可以选择去移走一些围栏，使得最多的小朋友高兴

围栏数为\(N (1≤N≤10 000)\)，小朋友的个数为\(C (1≤C≤50 000)\)

经过观察发现围栏数极小，故可以用状压\(dp\)

设\(f[i][j]\)表示第i个小朋友可以看到的动物被移走的状态为\(j\)

预处理\(s[i][j]\)表示第i个位置的所有小朋友可以看到的动物被移走的状态为j时会高兴的小朋友数量

先枚举第n个小朋友的状态，再进行\(dp\)

\(dp\)方程为

        for(int j=1;j<=n;j++)
        {
            for(int k=0;k<32;k++)
            f[j][k]=max(f[j-1][(k&15)<<1],f[j-1][((k&15)<<1)|1])+s[j][k];
        }

整道题的代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int n,m;
int s[10100][35];
int f[10100][35];
int ans=0;
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int e,f,l;scanf("%d%d%d",&e,&f,&l);
        int x=0,y=0;
        for(int j=1;j<=f;j++)
        {
            int xx;scanf("%d",&xx);
            x=x|(1<<((xx-e+n)%n));
        }
        for(int j=1;j<=l;j++)
        {
            int xx;scanf("%d",&xx);
            y=y|(1<<((xx-e+n)%n));
        }
        for(int j=0;j<32;j++)
        {
            s[e][j]+=((x&j)||(y&((~j)&31)));
        }
    }
    for(int i=0;i<32;i++)
    {
        memset(f,-0x3f3f3f3f,sizeof(f));
        f[0][i]=0;
        for(int j=1;j<=n;j++)
        {
            for(int k=0;k<32;k++)f[j][k]=max(f[j-1][(k&15)<<1],f[j-1][((k&15)<<1)|1])+s[j][k];
        }
        ans=max(ans,f[n][i]);
    }
    printf("%d\n",ans);getchar();
    return 0;
}

学校食堂

题目链接

同学们排队在食堂吃饭，每个同学想吃的菜都有一个特定的口味值T[i],每个同学的菜所需的时间为T[i]^T[j]（T[j]表示食堂做的前一道菜的口味值）,每个同学有一定的忍耐值B[i]，表示他最多允许他身后的B[i]个人先拿到饭菜。

求在满足所有人的忍耐值的前提下，学校食堂做完这些菜最少需要多少时间。

对于100%的数据，满足\(1 ≤ N ≤ 1,000，0 ≤ Ti ≤ 1,000，0 ≤ Bi ≤ 7。\)

我们通过观察发现\(B[i]\)的值极小，考虑状压\(dp\)

这道题最大的一个难点就是\(dp\)方程怎么列

首先我们考虑至少有一维是[i]且前i-1个人的菜已经做完了，肯定还有一维[j]用于状态压缩表示这个人和他身后的B[i]个人拿到菜的情况，又因为做菜时间与上一个拿到饭菜的人有关，所以再记录一维\([k]\)表示上一个拿到饭菜的人相对第i个人的位置，经过分析可得k的范围是\([-8,7]\)。(作为数组下标时需整体加8)

所以\(f[i][j][k]\)表示前i-1个人已经拿到饭菜了，第\(i\)个人到第\(i+B[i]\)个人拿到饭菜的情况为\(j\)，上一个拿到饭菜的人为第\(i+k\)个人

考虑状态方程如何转移：

如果\(j\&1==1\)，那么\(f[i][j][k]\)可以等价地转移到\(f[i+1][j>>1][k-1]\)

如果\(j\&1==0\)，枚举下一个拿到饭菜的人，注意用\(B[i]\)来限制枚举的范围

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int n;
int T[1010],B[1010];
int f[1070][1<<10][20];
int main()
{
    int Case;scanf("%d",&Case);
    while(Case--)
    {
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d%d",&T[i],&B[i]);
    memset(f,0x3f3f3f3f,sizeof(f));
    f[1][0][7]=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=0;j<=(1<<8)-1;j++)
        {
            for(int k=-8;k<=7;k++)
            {
                if(f[i][j][k+8]>=1e9)continue;
                if(j&1)f[i+1][j>>1][k+7]=min(f[i+1][j>>1][k+7],f[i][j][k+8]);
                else
                {
                    int cnt=1e9;
                    for(int t=0;t<=7;t++)
                    {
                        if(i+t>cnt)break;
                        if((j>>t)&1)continue;
                        cnt=min(cnt,i+t+B[i+t]);
                        f[i][j|(1<<t)][t+8]=min(f[i][j|(1<<t)][t+8],f[i][j][k+8]+((i+k>0)?(T[i+k]^T[i+t]):0));
                    }
                }
            }
        }
    }
    int ans=1e9;
    for(int i=-8;i<=0;i++)ans=min(ans,f[n+1][0][i+8]);
    printf("%d\n",ans);
    }
    return 0;
}

转载于:https://www.cnblogs.com/Akaina/p/11374131.html

dbp123123
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【状压DP】易懂讲解状态压缩/状态压缩DP
qq_35684989的博客
05-31 3094
本文是状态压缩DP的总结
状压dp经典问题及代码
04-28
状态压缩经典问题及代码，TSP问题，状压dp..........................................
状压DP学习总结 （详解，适合没状压dp基础的人学习，还在更新中，，，，）
Amo丶
05-20 1万+
本次博客，主要是给学弟学妹们讲解一下状压dp，不适合有基础的同学观看，可能会浪费时间，因为偏基础 先来最简单的一个吧 http://acm.hdu.edu.cn/showproblem.php?pid=1565hdu 1565 方格取数(1) Time Limit: 10000/5000 MS (Java/Others)Memory Limit: 32768/32768 K (...
算法复习——状压dp
banzhangzhi8819的博客
09-21 466
状压dp的核心在于，当我们不能通过表现单一的对象的状态来达到dp的最优子结构和无后效性原则时，我们可能保存多个元素的有关信息··这时候利用2进制的01来表示每个元素相关状态并将其压缩成2进制数就可以达到目的····此时熟悉相关的位运算就很重要了····以下是常见的一些需要位运算方法 然后说实话状压dp其它方面就和普通dp差不多了···它不像数位区间树形那样或多或少好歹有自己一定...
状压dp概念和使用技巧
KeePromise的博客
07-20 764
状压dp概念和使用技巧 1.概念 状压就是用一个N进制整数，表示一个状态。 比如: 1：有一个序列[A,B,C,D]，序列中的每个元素可以拿或者不拿。 则一共有2^4种方式，可以用一个4位的2进制整数来表示每一种方式（状态）。 整数6[0110]表示拿了B,C 整数1[0001]表示拿了A 整数15[1111]表示都拿了 2：有一些人[a,b,c,d],每个人可以拿0，1，2个苹果。 则一共有3^4种方式，可以用一个4位的3进制数来表示每一种方式（状态）。 整数3表示的3进制数为[0010]，表示只有b拿
状态压缩DP 图文详解（一）
m0_64226820的博客
08-06 1万+
超详细的讲解，有图有真相的状压DP真的不来看看吗？
状压DP_C++_算法_状压_状态压缩DP_状压DP_
09-30
由大师制作的状态压缩算法的入门资料为初学者介绍状态压缩DP相关算法并提供解题思路共47页，讲解到位 题题经典
[宫水三叶的刷题日记]：状压 DP1
08-03
2. 从侧边栏的类别目录找到「状压 DP」 3. 按照「推荐指数」从大到小进行刷题，「推荐指数」相同，则按照「难度」从易到 4. 拿到题号之后，回到本合集进行检
Week12-选做题2（状压DP）
01-03
问题描述 马上假期就要结束了，zjm还有 n 个作业，完成某个作业需要一定的时间，而且每个作业有一个截止时间，若超过截止时间，一天就要扣一分。 zjm想知道如何安排做作业，使得扣的分数最少。 ...
算法-动态规划- 状压 DP（包含源程序）.rar
09-16
算法-动态规划- 状压 DP（包含源程序）.rar
状压dp入门
weixin_45434743的博客
02-06 802
状压dp入门 什么是状态压缩dp？ 状态压缩dp就是把某些用dfs会超时的递归调用过多的题目转换成用数组中的一位数表示状态。我们知道在二进制下每一位上不是0就是1，这样就可以很好的表示事物的状态，是存在还是不存在，状态压缩就是把状态压缩到一位数内，这一位数操作时都用二进制操作。 要学状态压缩dp首先要对二进制有所了解。我们下面来介绍一下二进制的相关知识。 1.’&’符号，x&y，会将两个十进制数在二进制下进行与运算，然后返回其十进制下的值。例如3(11)&2(10)=2(10)。 2
状压dp套路总结
lpls1
09-02 227
1.创建变量，状态转移数组dp，行内合法状态数组state，记录行内合法状态的某种属性的数组num，记录状态数量的count,原始行数组row，等 2.写判断合法的函数。判断行内合法ok(int sta)，判断两行之间合法fit(int sta1,int sta2),等 3.写main函数：填充row(注意有时会把原图的01代码取反，以方便使用ok函数)，填充state和num，初始化dp的起始值...
HDU 5025 Saving Tang Monk BFS搜索
喵头鹰的博客
03-27 289
题目描述：Description 《Journey to the West》(also 《Monkey》) is one of the Four Great Classical Novels of Chinese literature. It was written by Wu Cheng’en during the Ming Dynasty. In this novel, Monkey King
状态压缩dp(状压dp)
热门推荐
唐宋元明清的博客
07-16 3万+
注：在涉及到位运算时，一定要注意位运算的优先级。该加的括号一定要加 状压dp是一类比较难理解的dp; 在讲状压dp之前，我们应该清楚所有的dp是解决多阶段决策最优化问题的一种思想方法； 请注意多阶段这三个字： 经过前面三种背包的学习，可以发现如何定义状态是解决动态规划最重要的一步； 状态的定义也就决定了相当于阶段的划分； 在背包问题中，我们通过物品的件数i和背包的容量j来定义状态或者说...
【规划】状压dp
zsjzliziyang的博客
08-09 405
1.简介 将较小的状态压缩成一个数，储存在dp的一维里，方便转移。 状压dp有很多不同的形态。 其中一种叫轮廓线dp（又称插头dp）
状压DP入门
PK__PK的博客
03-02 363
状态压缩：现在有一些物品，若我们选择某件物品，则这件物品为1，不选则为0。那么对于这些物品的选择的状态可以表示为0 0 0 1 1。这个表示选择第1件物品和第2件物品，其余的不选。对于所有状态都可以这样表示。而这些状态我们可以把他看成一个10进制的数。如例子中的状态，就可以表示为3,3的二进制为00011,这样就把状态压缩了。不需要用数组去表示是否选择物品。 例题：有一个N*M(N 我
状压 bfs
liluoyu_1016的博客
07-31 376
http://119.23.43.230/problem.php?id=1234 题目描述 小z喜欢上了一个迷宫游戏，这个游戏是这样的，有一个N*M的迷宫(即N行M列的迷宫)保证0&lt;N&lt;=500,0&lt;M&lt;=500 左上角坐标(1,1)为入口，右下角坐标(N,M)为出口，这个迷宫和一般迷宫不同的地方是， 迷宫种可能会出现k个宝石(0&lt;=k&lt;=3),小z如果...
对状压dp的一点理解
hsx353211851的博客
09-20 244
最近学习了状压dp，既然是dp和其他的dp思想是一致的都是找到转移方程转移方法然后转移就行。不同的在于状压dp利用了二进制把一个状态记录成一个二进制数。由于过去dp练习的多，刷一两道题直接算是入门了。 下面上两道洛谷的入门状压dp： P1879 [USACO06NOV]玉米田Corn Fields 题面链接：https://www.luogu.org/problem/P1879 题意：给定...
状压DP详解（1）-从状压到状压DP+简单例题玉米田Corn Fields-POJ3254
孤风的博客
06-05 1068
emmm，首先要搞懂状压DP这个东西的时候我们要搞懂状压这个概念，其实就是二进制运算的概念，比较经典的就是我写的一个状压非DP–的题目Even Parity—Uva11464—偶数矩阵： 这是我对与状压非DP的一个做法https://blog.csdn.net/qq_43906000/article/details/90798220 当然，在里面应该就可以搞懂状压这个概念了，简单来讲就是暴力枚举，...
状压DP一般分为哪几类
最新发布
06-11
状压DP一般可以分为以下几类： 1. 状态压缩表示状态：将一个状态压缩成一个整数，用二进制表示状态中的每个元素，将其转化为一个整数，方便状态转移和空间压缩。 2. 状态压缩表示集合：将一个集合压缩成一个整数，用二进制表示集合中的每个元素是否出现，将其转化为一个整数，方便状态转移和空间压缩。 3. 状态压缩表示位置：将一个位置压缩成一个整数，用二进制表示位置的出现情况，将其转化为一个整数，方便状态转移和空间压缩。 4. 状态压缩表示排列：将一个排列压缩成一个整数，用二进制表示每个元素在排列中出现的位置，将其转化为一个整数，方便状态转移和空间压缩。 这些方法都可以用在状压DP中，具体使用哪种方法，要根据问题的具体情况来决定。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值