回文树的学习

最新推荐文章于 2021-04-25 19:52:19 发布
最新推荐文章于 2021-04-25 19:52:19 发布
阅读量123 收藏 1
点赞数
分类专栏： 回文树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39898877/article/details/98469663
版权

 

理论部分参考论文：回文树及其实现 翁文涛

模板

const int MAXN = 100005 ;  
const int N = 26 ;  
  
struct Palindromic_Tree {  
    int next[MAXN][N] ;//next指针，next指针和字典树类似，指向的串为当前串两端加上同一个字符构成  
    int fail[MAXN] ;//fail指针，失配后跳转到fail指针指向的节点  
    int cnt[MAXN] ;  
    int num[MAXN] ;  
    int len[MAXN] ;//len[i]表示节点i表示的回文串的长度  
    int S[MAXN] ;//存放添加的字符  
    int last ;//指向上一个字符所在的节点，方便下一次add  
    int n ;//字符数组指针  
    int p ;//节点指针  
  
    int newnode ( int l ) {//新建节点  
        for ( int i = 0 ; i < N ; ++ i ) next[p][i] = 0 ;  
        cnt[p] = 0 ;  
        num[p] = 0 ;  
        len[p] = l ;  
        return p ++ ;  
    }  
  
    void init () {//初始化  
        p = 0 ;  
        newnode (  0 ) ;  
        newnode ( -1 ) ;  
        last = 0 ;  
        n = 0 ;  
        S[n] = -1 ;//开头放一个字符集中没有的字符，减少特判  
        fail[0] = 1 ;  
    }  
  
    int get_fail ( int x ) {//和KMP一样，失配后找一个尽量最长的  
        while ( S[n - len[x] - 1] != S[n] ) x = fail[x] ;  
        return x ;  
    }  
  
    void add ( int c ) {  
        c -= 'a' ;  
        S[++ n] = c ;  
        int cur = get_fail ( last ) ;//通过上一个回文串找这个回文串的匹配位置  
        if ( !next[cur][c] ) {//如果这个回文串没有出现过，说明出现了一个新的本质不同的回文串  
            int now = newnode ( len[cur] + 2 ) ;//新建节点  
            fail[now] = next[get_fail ( fail[cur] )][c] ;//和AC自动机一样建立fail指针，以便失配后跳转  
            next[cur][c] = now ;  
            num[now] = num[fail[now]] + 1 ;  
        }  
        last = next[cur][c] ;  
        cnt[last] ++ ;  
    }  
  
    void count () {  
        for ( int i = p - 1 ; i >= 0 ; -- i ) cnt[fail[i]] += cnt[i] ;  
        //父亲累加儿子的cnt，因为如果fail[v]=u，则u一定是v的子回文串！  
    }  
} ;

Palindromic Tree

【bzoj3676】[Apio2014]回文串

 

bzoj2565: 最长双回文串

https://www.lydsy.com/JudgeOnline/problem.php?id=2565

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 100005 ;
const int N = 26 ;
struct Palindromic_Tree {
    int next[MAXN][N] ;//next指针，next指针和字典树类似，指向的串为当前串两端加上同一个字符构成
    int fail[MAXN] ;//fail指针，失配后跳转到fail指针指向的节点
    int cnt[MAXN] ;
    int num[MAXN] ;
    int len[MAXN] ;//len[i]表示节点i表示的回文串的长度
    int S[MAXN] ;//存放添加的字符
    int last ;//指向上一个字符所在的节点，方便下一次add
    int n ;//字符数组指针
    int p ;//节点指针

    int newnode ( int l ) {//新建节点
        for ( int i = 0 ; i < N ; ++ i ) next[p][i] = 0 ;
        cnt[p] = 0 ;
        num[p] = 0 ;
        len[p] = l ;
        return p ++ ;
    }

    void init () {//初始化
        p = 0 ;
        newnode (  0 ) ;
        newnode ( -1 ) ;
        last = 0 ;
        n = 0 ;
        S[n] = -1 ;//开头放一个字符集中没有的字符，减少特判
        fail[0] = 1 ;
    }

    int get_fail ( int x ) {//和KMP一样，失配后找一个尽量最长的
        while ( S[n - len[x] - 1] != S[n] ) x = fail[x] ;
        return x ;
    }
    int add ( int c ) {
        c -= 'a' ;
        S[++ n] = c ;
        int cur = get_fail ( last ) ;//通过上一个回文串找这个回文串的匹配位置
        if ( !next[cur][c] ) {//如果这个回文串没有出现过，说明出现了一个新的本质不同的回文串
            int now = newnode ( len[cur] + 2 ) ;//新建节点
            fail[now] = next[get_fail ( fail[cur] )][c] ;//和AC自动机一样建立fail指针，以便失配后跳转
            next[cur][c] = now ;
            num[now] = num[fail[now]] + 1 ;
        }
        last = next[cur][c] ;
        cnt[last] ++ ;
        return len[last];
    }

    void count () {
        for ( int i = p - 1 ; i >= 0 ; -- i ) cnt[fail[i]] += cnt[i] ;
        //父亲累加儿子的cnt，因为如果fail[v]=u，则u一定是v的子回文串！
    }
} ;
Palindromic_Tree T;
char s[100050];
int len[100050];
int main(){
    scanf("%s",s);
    int n=strlen(s);
    T.init();
    int ans=0;
    for(int i=n-1;i>=0;i--){
        len[i]=T.add(s[i]);
    }
    T.init();
    for(int i=0;i<n-1;i++){
        ans=max(ans,T.add(s[i])+len[i+1]);
    }
    printf("%d\n",ans);
    return 0;
}

bzoj2160: 拉拉队排练

https://www.lydsy.com/JudgeOnline/problem.php?id=2160

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int MAXN = 1000005 ;
const int N = 26 ;
struct Palindromic_Tree {
    int next[MAXN][N] ;//next指针，next指针和字典树类似，指向的串为当前串两端加上同一个字符构成
    int fail[MAXN] ;//fail指针，失配后跳转到fail指针指向的节点
    int cnt[MAXN] ;
    int num[MAXN] ;
    int len[MAXN] ;//len[i]表示节点i表示的回文串的长度
    int S[MAXN] ;//存放添加的字符
    int last ;//指向上一个字符所在的节点，方便下一次add
    int n ;//字符数组指针
    int p ;//节点指针

    int newnode ( int l ) {//新建节点
        for ( int i = 0 ; i < N ; ++ i ) next[p][i] = 0 ;
        cnt[p] = 0 ;
        num[p] = 0 ;
        len[p] = l ;
        return p ++ ;
    }

    void init () {//初始化
        p = 0 ;
        newnode (  0 ) ;
        newnode ( -1 ) ;
        last = 0 ;
        n = 0 ;
        S[n] = -1 ;//开头放一个字符集中没有的字符，减少特判
        fail[0] = 1 ;
    }

    int get_fail ( int x ) {//和KMP一样，失配后找一个尽量最长的
        while ( S[n - len[x] - 1] != S[n] ) x = fail[x] ;
        return x ;
    }
    int add ( int c ) {
        c -= 'a' ;
        S[++ n] = c ;
        int cur = get_fail ( last ) ;//通过上一个回文串找这个回文串的匹配位置
        if ( !next[cur][c] ) {//如果这个回文串没有出现过，说明出现了一个新的本质不同的回文串
            int now = newnode ( len[cur] + 2 ) ;//新建节点
            fail[now] = next[get_fail ( fail[cur] )][c] ;//和AC自动机一样建立fail指针，以便失配后跳转
            next[cur][c] = now ;
            num[now] = num[fail[now]] + 1 ;
        }
        last = next[cur][c] ;
        cnt[last] ++ ;
        return len[last];
    }

    void count () {
        for ( int i = p - 1 ; i >= 0 ; -- i ) cnt[fail[i]] += cnt[i] ;
        //父亲累加儿子的cnt，因为如果fail[v]=u，则u一定是v的子回文串！
    }
} ;
Palindromic_Tree T;
char s[MAXN];
ll len[MAXN];
ll n,k;
bool cmp(int x,int y){
    return x>y;
}
const ll mod=19930726;
ll fpow(ll a, ll b)
{
	ll ans = 1;//A
	a = a % mod;
	while (b > 0)
	{
		if (b&1)
			ans = ans * a % mod;
		b >>= 1;
		a = a * a % mod;
	}
	return ans;
}
int main(){
    scanf("%lld%lld",&n,&k);
    scanf("%s",s);
    T.init();
    ll ans=1;
    ll m=0;
    for(int i=0;i<n;i++){
        T.add(s[i]);
    }
    T.count();
    int mx=0;
    for(int i=2;i<=n+2;i++){
        if(T.len[i]&1){
            len[T.len[i]]+=T.cnt[i];
            mx=max(mx,T.len[i]);
            m+=T.cnt[i];
        }
    }
    if(k>m){
        printf("-1\n");
        return 0;
    }
    for(int i=mx;i>=1;i-=2){
        ll mn=min(k,len[i]);
        k-=mn;
        if(mn) ans=(ans*fpow(i,mn))%mod;
    }
    printf("%lld\n",ans);
    return 0;
}

Codeforces 17E. Palisection 

https://codeforces.com/problemset/problem/17/E

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 2e6+5;
const int mod = 51123987;
int n,fa[N],len[N],dep[N],tot,last,p1[N],p2[N],ans;
int to[N],nxt[N],ww[N],head[N],cnt;
char s[N];
void init()
{
    fa[last=0]=fa[1]=1;
    len[tot=1]=-1;
    memset(head,0,sizeof(head));cnt=0;
}
void link(int u,int v,int c)
{
    to[++cnt]=v;nxt[cnt]=head[u];ww[cnt]=c;
    head[u]=cnt;
}
int tr(int v,int c)
{
    for (int e=head[v];e;e=nxt[e])
        if (ww[e]==c) return to[e];
    return 0;
}
void extend(int c,int n)
{
    int v=last;
    while (s[n-len[v]-1]!=s[n]) v=fa[v];
    if (!tr(v,c))
    {
        int u=++tot,k=fa[v];
        len[u]=len[v]+2;
        while (s[n-len[k]-1]!=s[n]) k=fa[k];
        fa[u]=tr(k,c);dep[u]=dep[fa[u]]+1;
        link(v,u,c);
    }
    last=tr(v,c);
}
int main()
{
    scanf("%d",&n);
    scanf("%s",s+1);
    init();
    for (int i=1;i<=n;++i) extend(s[i]-'a',i),(ans+=(p1[i]=dep[last]))%=mod;
    ans=1ll*ans*(ans-1)/2%mod;
    reverse(s+1,s+n+1);
    init();
    for (int i=1;i<=n;++i) extend(s[i]-'a',i),p2[n-i+1]=dep[last];
    for (int i=n;i;--i) (p2[i]+=p2[i+1])%=mod;
    for (int i=1;i<=n;++i) ans=(ans-1ll*p1[i]*p2[i+1]%mod+mod)%mod;
    printf("%d\n",ans);
    return 0;
}

Palindrome Mouse

https://ac.nowcoder.com/acm/contest/886/C

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int MAXN = 100005 ;
const int N = 26 ;
struct Palindromic_Tree {
    int next[MAXN][N] ;//next指针，next指针和字典树类似，指向的串为当前串两端加上同一个字符构成
    int fail[MAXN] ;//fail指针，失配后跳转到fail指针指向的节点
    int cnt[MAXN] ;
    int num[MAXN] ;//右端点在这一位子串的个数
    int len[MAXN] ;//len[i]表示节点i表示的回文串的长度
    int S[MAXN] ;//存放添加的字符
    int last ;//指向上一个字符所在的节点，方便下一次add
    int n ;//字符数组指针
    int p ;//节点指针
    int sz[MAXN],c[MAXN],vis[MAXN];
    int newnode ( int l ) {//新建节点
        for ( int i = 0 ; i < N ; ++ i ) next[p][i] = 0 ;
        cnt[p] = 0 ;
        num[p] = 0 ;
        len[p] = l ;
        return p ++ ;
    }

    void init () {//初始化
        p = 0 ;
        newnode (  0 ) ;
        newnode ( -1 ) ;
        last = 0 ;
        n = 0 ;
        S[n] = -1 ;//开头放一个字符集中没有的字符，减少特判
        fail[0] = 1 ;
    }

    int get_fail ( int x ) {//和KMP一样，失配后找一个尽量最长的
        while ( S[n - len[x] - 1] != S[n] ) x = fail[x] ;
        return x ;
    }
    int add ( int c ) {
        c -= 'a' ;
        S[++ n] = c ;
        int cur = get_fail ( last ) ;//通过上一个回文串找这个回文串的匹配位置
        if ( !next[cur][c] ) {//如果这个回文串没有出现过，说明出现了一个新的本质不同的回文串
            int now = newnode ( len[cur] + 2 ) ;//新建节点
            fail[now] = next[get_fail ( fail[cur] )][c] ;//和AC自动机一样建立fail指针，以便失配后跳转
            next[cur][c] = now ;
            num[now] = num[fail[now]] + 1 ;
        }
        last = next[cur][c] ;
        cnt[last] ++ ;
        return len[last];
    }

    void count () {
        for ( int i = p - 1 ; i >= 0 ; -- i ) cnt[fail[i]] += cnt[i] ;
        //父亲累加儿子的cnt，因为如果fail[v]=u，则u一定是v的子回文串！
    }
    int dfs(int u){
        sz[u]=1;
        c[u]=0;
        for(int t=u;!vis[t]&&t>1;t=fail[t]){
            vis[t]=u;
            c[u]++;
        }
        for(int i=0;i<26;i++){
            if(next[u][i]==0) continue;
            sz[u]+=dfs(next[u][i]);
        }
        for(int t=u;vis[t]==u&&t>1;t=fail[t]){
            vis[t]=0;
        }
        return sz[u];
    }
    long long solve(){
        dfs(0);dfs(1);
        long long ans=0;
        for(int i=2;i<p;i++){
            ans+=1ll*sz[i]*c[i];
        }
        ans=ans-p+2;
        return ans;
    }
} ;
Palindromic_Tree T;
char s[MAXN];
int n;
int main(){
    int ca=1;
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%s",s);
        n=strlen(s);
        T.init();
        ll ans=0;
        for(int i=0;i<n;i++){
            T.add(s[i]);
        }
        printf("Case #%d: %lld\n",ca++,T.solve());
    }
    return 0;
}

 

A_root_A
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
回文树在线剖分
Exelite的博客
08-23 160
回文树在线剖分？？？回文树在线剖分？？？PrefaceThe problemSourceDescriptionData ConstraintAnalysisPostscript 回文树在线剖分？？？ Preface 蒟蒻刚学PAM，就做到一道恶心PAM+LCT题，然而蒟蒻并不会LCT，于是想出一种奇妙的解法，在此分享。欢迎讨论交流。 The problem Source IOI2017中国国家队候选队论文集 – 回文树及其应用 翁文涛 – 5.5 AlphaDog（原创） Also in 本校OJ Prob
回文自动机
qq_42852687的博客
01-30 1693
回文自动机一，定义二，状态概述三，引理四，具体理论例题1，P3649 [APIO2014] 回文串 特别鸣谢：翁文涛 – 2017 国家候选队论文《回文树及其应用 》 特别鸣谢：bzt的题解 一，定义 PAM 是一个接受且仅接受某个字符串的所有回文子串的中心及右半部分的 DFA。 保证回文串为奇回文串，如果不是需要构造，如此PAM就是一颗自动机而非分裂的子树 这是一颗成品 PAM ~ 看起来不那么离散嘛 二，状态概述 PAM 的每个状态都表示一个回文子串，其中包含两个特殊状态， 长度 为 0 和
[BZOJ]3676 [APIO2014] 回文串 回文自动机
Le Petit Prince
12-11 369
3676: [Apio2014]回文串Time Limit: 20 Sec  Memory Limit: 128 MBSubmit: 2953  Solved: 1325[Submit][Status][Discuss]Description考虑一个只包含小写拉丁字母的字符串s。我们定义s的一个子串t的“出 现值”为t在s中的出现次数乘以t的长度。请你求出s的所有回文子串中的最 大出现值。 Inp
另一种保证单次插入回文自动机复杂度的做法
weixin_30906671的博客
12-12 126
对于插入一个字符串，普通回文自动机复杂度是均摊的。 对于单次插入复杂度有证明的回文自动机插入， 设\(\sum\)为字符集大小，翁文涛的论文里提到了单次插入\(O(\sum)\)的记忆化，从理论上来说，可以通过主席树优化到\(O(log\sum)\)，但是代码量就增加了，而且对于26的字符集，这样写应该会变慢吧。 翻金策字符串算法选讲的时候，偶然发现了一个浅显的结论，回文串的border等价于它的...
区间更新与点值
恒持此志成永志
07-25 241
#include&lt;bits/stdc++.h&gt; using namespace std; const int MAXN=100005; int n; int bit[MAXN]; int c[MAXN],b[MAXN]; int lowbit(int x) {     return x &amp; (-x); } void updata(int k,int v){//更新区间    ...
数据结构中回文、线性表、表达式的代码
01-20
处理表达式时，我们通常需要进行解析，将输入的字符串表达式转化为抽象语法树（AST），然后进行求值。C语言中，我们可以使用栈来辅助处理算术表达式，通过压栈、弹栈来执行运算符的优先级规则。 在提供的压缩包文件...
C二叉树中的伪回文路径.zip
最新发布
02-24
通过阅读源码，我们可以学习到如何实现这个算法，包括如何表示二叉树、如何遍历树以及如何判断和构建伪回文路径。 总的来说，这个话题涉及了二叉树的遍历、字符串处理、动态规划和可能的最优化问题，这些都是计算机...
C语言学习实例220例
06-16
019 判断回文数 020 求数组前n元素之和 021 求解钢材切割的最佳订单 022 通过指针比较整数大小 023 指向数组的指针 024 寻找指定元素的指针 025 寻找相同元素的指针 026 阿拉伯数字转换为罗马数字 027 字符替换 028 ...
小学语文知识树简图PPT学习教案.pptx
10-05
小学语文知识树是一个系统性的教学资源，旨在帮助学生和教师清晰地理解语文学习的主要内容和结构。这份PPT教案涵盖了从基础知识到高级技巧的多个层面，包括但不限于以下几个方面： 1. **基础知识**：语文学习的基础...
用队列和栈判断回文_赫夫曼数_双向链表_内部排序（8种）.zip
05-20
这里我们探讨的主题包括“用队列和栈判断回文”、“赫夫曼数”、“双向链表”以及“内部排序（8种）”。下面将详细阐述这些知识点。 1. **用队列和栈判断回文**： 回文是指正读反读都能读通的字符串，如“level”...
【论文推荐】了解《强化学习》必看的6篇论文【附打包下载地址】
weixin_48294000的博客
04-25 1352
论文推荐“SFFAI105期来自清华大学的翁文涛推荐的文章主要关注于基础研究的强化学习领域，你可以认真阅读讲者推荐的论文，来与讲者及同行线上交流哦。”关注文章公众号回复"SFFAI...
【分块+回文自动机】LibreOJ6070(2017 山东一轮集训 Day4)[基因]题解
ZigZagK的博客
01-03 671
题目概述给出一个由小写字母构成的字符串，有 mm 个询问 [l,r][l,r] ，表示求 s[l..r]s[l..r] 中本质不同回文字串的个数，强制在线。解题报告因为强制在线询问区间，所以我们想到分块。以每个块的左端点开始构造后缀的回文自动机，就可以得到 ans[i][j]ans[i][j] 表示从第 ii 个块左端点开始到 jj 中不同回文子串的个数。然后对于每个询问，我们都只需要查询至多一个块
C++ 字符串相关算法总结
qq_43826794的博客
09-28 722
字符串相关的算法 字典树 何为字典树 在n个字符串中查找某个字符串，就像用英语字典查单词一样 先翻第一个字母，然后是第二个，然后是第三个 查找任意单词，查找次数最多只需要这个单词的字母个数 实现与功能 根节点不包含字符，除根节点以外每个子节点都只包含一个字符 从根节点到某一个节点，路径上的字符连接起来，为该节点对应的字符串 每个节点的所有子节点包含的字符互不相同 通常在结点设置一个标志来标记该节点...
回文树（回文自动机）学习小记
Cold_Chair的博客
12-13 585
参考资料：翁文涛在2017年国家候选队的论文。前言：感觉这个东西比后缀自动机好理解。博主是看wwt的论文学的：wwt给出的这种不用打通配符的方法更加简洁。定义：回文树有两个根。分别为even,odd，长度分别是0和-1。len为一个点代表的字符串的实际长度。fail为这个点失配后的最长回文后缀。go是自动机的边。构建：fail[even]=odd用和后缀自动机一样的增量法。考虑当前的串是t，在t后面
回文树总结
abcyan1235的博客
03-31 138
回文树总结 写马拉车还不如写回文树。 ---BY 陈菊开 回文树是啥 原论文请转2017年集训队论文《回文树及其应用》BY翁文涛 我感觉回文树/回文自动机相较于后缀自动机还是要好理解一点的（像我这种菜鸡到现在还不是很懂SAM）。 回文树，顾名思义，就是要把一个串的所有回文子串丢到一棵树上。那要向SAM一样记录个什么鬼\(endpos\)啥的吗？不用。只需要对每一种本质不同的回文子串建...
队伍统计
Com_man_der的博客
01-27 252
Description 现在有n个人要排成一列，编号为1-&gt;n 。但由于一些不明原因的关系，人与人之间可能存在一些矛盾关系，具体有m条矛盾关系(u,v),表示编号为u的人想要排在编号为v的人前面。要使得队伍和谐，最多不能违背k条矛盾关系（即不能有超过k条矛盾关系(u,v),满足最后v排在了u前面）。问有多少合法的排列。答案对10^9+7取模。 Input 输入文件名为count.in。...
最长回文串_最小回文划分
weixin_39576149的博客
11-28 140
问题给定一个字符串 ，求最小的 ，使得存在 ，满足 均为回文串，且 依次连接后得到的字符串等于 。暴力做法考虑动态规划，记 表示 长度为 的前缀的最小划分数，转移只需要枚举以第 个字符结尾的所有回文串： 由于一个字符串最多会有 个回文子串，因此上述算法的时间复杂度为 。显然不能接受，为了加速转移，首先给出一些引理。引理与证明知乎传公式太麻烦了，证明过程留作读者自行思考（误，...
LOJ6070 基因 分块+回文自动机
weixin_34256074的博客
06-22 143
这个在翁文涛的论文里有讲到 大概的就是一个子串的回文自动机是原串回文自动机的子图 于是每隔\(\sqrt n\)重新跑一个\((k \times \sqrt n,n)\)的回文自动机 记录回文串个数和位置 并且分别维护后缀的\(fail\)和前缀的\(fail\) 每次询问\((l,r)\)只需要把\((k \times\sqrt n,r)\)的答案直接加上 再暴力添加\((l,(k \times...
CDQZ多校集训记
weixin_30673715的博客
12-19 174
20171218 DAY0 初相逢 　　今天的阳光很好，确实好极了。下午开始时，mercer说门外站了一堆人，我看都不用看就知道是衡水的。衡水人，怎么说呢，觉得还是挺不一样的。不知道像凡哥和超哥这种奇异的生物究竟是如何得以存在的……可以想到，他们的生活确实十分的简朴，一个年级可以被硬生生切成3块，A部B部C部鼓励无端竞争，每个部20个班，每个班80个人，一个年级就能有将近5000人之多。这简直是...
"LeetCode 336题：回文对的例题分析及解题思路
具体来说，可以将每个单词的翻转插入Trie树中，然后通过遍历单词列表来查找每个单词是否有对应的翻转在Trie树中，且剩余部分是回文的情况。这样做能够将查找过程的时间复杂度降为O(k^2)，其中k是单词的平均长度。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值