析合树

最新推荐文章于 2023-02-01 19:17:05 发布
最新推荐文章于 2023-02-01 19:17:05 发布
阅读量595 收藏 3
点赞数
分类专栏： 析合树 奇妙数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A1847225889/article/details/100714952
版权

析合树是一种解决连续段问题的数据结构。
比如这样的一个问题：给你一个 1 1 1到 n n n的排列，然后有一堆询问，每次询问区间 [ l , r ] [l,r] [l,r]，问包含 [ l , r ] [l,r] [l,r]的最小连续段是什么。
也就是这题
所谓的连续段，就是满足 m a x l . . r − m i n l . . r + 1 = r − l + 1 max_{l..r}-min_{l..r}+1=r-l+1 maxl..r​−minl..r​+1=r−l+1的连续段。

推荐这篇：https://oi-wiki.org/ds/divide-combine/
里面有比较系统的介绍。
虽然没有线性的构造方法

关于析合树，有各种各样的定义和性质，那些东西就是叫人看不懂的……。
所以我在这里就简单地说一说。
先说个性质：对于两个连续段 [ l 1 , r 1 ] [l_1,r_1] [l1​,r1​]和 [ l 2 , r 2 ] [l_2,r_2] [l2​,r2​]
如果它们有交集（即 [ l 2 , r 1 ] [l_2,r_1] [l2​,r1​]），则交集也是连续段。
并且它们的并集也是连续段。
这个不用解释吧……

有一个叫本源连续段的概念，不过具体指什么，我也不太懂……所以就不说了……
估计学到差不多的时候看字面意思就知道是什么东西了……
在这里插入图片描述
盗张图来瞅一瞅。
析合树的每个点都表示一个连续段，确切地说，是本源连续段。
析合树有两种点：析点和合点。
析点满足所有相邻儿子都不能合并成个连续段，合点满足所有相邻儿子都能合并成个连续段（可以看成儿子都是顺序或倒序的）。
有个很显然的性质是，析点至少有四个节点，合点至少有两个节点。
至于最下面的叶子结点就不要管了……程序实现时为了方便我会将其设为析点。
如果建出了析合树，前面的那个问题就有的答案：求出两个点的 L C A LCA LCA，如果是析点，则就是析点代表的区间。如果是合点，则就是 l l l和 r r r的祖先在 L C A LCA LCA下的儿子之间组成的区间。

接下来就是最重要的问题：如何建析合树。
建析合树用的是增量法，也就是一个一个点加进去。
维护一个栈，表示目前形成的森林的根节点。
假设加进去的点为 x x x，栈顶为 t o p top top。

  1. t o p top top为合点，并且 t o p top top的最后一个儿子可以和 x x x合并。这个时候就直接将 x x x作为 t o p top top的儿子，然后将 t o p top top递归下去继续干。
  2. t o p top top和 x x x可以合并。新建一个合点，作为 t o p top top和 x x x的父亲，然后将它们的父亲递归下去。
  3. 往前面找若干个节点，满足这若干个节点和 x x x可以合并。然后新建一个析点，将这些点都作为它的儿子，然后将它递归下去。
  4. 若栈为空，或者第三个操作没有找到， x x x节点就加入栈顶。

然而直接这样建树是 O ( n 2 ) O(n^2) O(n2)的。上面第三个操作的时候可能一直往前找都找不到，那这样一次就是 O ( n ) O(n) O(n)的了。
考虑直接在这方面优化。一个简单的思路是求出 L i L_i Li​，表示 [ L i , i ] [L_i,i] [Li​,i]以 i i i为右端点的最长的连续段。
这样在第三个操作的时候就能够明确最多找到哪里，并且，最后面这些节点全部都会合并起来，栈顶的节点就是 [ L i , i ] [L_i,i] [Li​,i]
问题转化成了如何求 L i L_i Li​
看看这题。用那个线段树的做法就行了。
大体思路就是维护两个单调栈，然后在线段树上维护。
求出了 L i L_i Li​，那么建树的时间复杂度就是 O ( n ) O(n) O(n)的了。
可惜预处理需要 O ( n lg ⁡ n ) O(n \lg n) O(nlgn)的时间来预处理。

放个代码：

using namespace std;
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cassert>
#define N 100010
int n,a[N];
int smn[N],smx[N],tn,tx;
int mn[N*4],tag[N*4];
int L[N];
inline void pushdown(int k){
	if (tag[k]){
		mn[k<<1]+=tag[k],mn[k<<1|1]+=tag[k];
		tag[k<<1]+=tag[k],tag[k<<1|1]+=tag[k];
		tag[k]=0;
	}
}
void add(int k,int l,int r,int st,int en,int c){
	if (st<=l && r<=en){
		mn[k]+=c;
		tag[k]+=c;
		return;
	}
	pushdown(k);
	int mid=l+r>>1;
	if (st<=mid)
		add(k<<1,l,mid,st,en,c);
	if (mid<en)
		add(k<<1|1,mid+1,r,st,en,c);
	mn[k]=min(mn[k<<1],mn[k<<1|1]);
}
int find(int k,int l,int r,int st,int en,int v){
	if (mn[k]>v)
		return 0;
	if (l==r)
		return l;
	pushdown(k);
	int mid=l+r>>1,res=0;
	if (st<=mid)
		res=find(k<<1,l,mid,st,en,v);
	if (!res && mid<en)
		res=find(k<<1|1,mid+1,r,st,en,v);
	return res;
}
int cnt;
struct Node{
	Node *fa,*lst;
	int mn,mx;
	bool xihe;
	int l,r;
} d[N*2],*null=d;
int num[N];
Node *st[N*2];
int top;
inline int ok(Node *x,Node *y){
	if (x->mx+1==y->mn)
		return 1;
	if (x->mn-1==y->mx)
		return -1;
	return 0;
}
void insert(Node *x){
	int tmp;
	if (top && st[top]->xihe==1 && (tmp=ok(st[top]->lst,x))){
		if (tmp==1)
			st[top]->mx=x->mx;
		else
			st[top]->mn=x->mn;
		st[top]->lst=x;
		st[top]->r=x->r;
		x->fa=st[top--];
		insert(x->fa);
		return;
	}
	if (top && (tmp=ok(st[top],x))){
		if (tmp==1)
			d[++cnt]={null,x,st[top]->mn,x->mx,1,st[top]->l,x->r};
		else
			d[++cnt]={null,x,x->mn,st[top]->mx,1,st[top]->l,x->r};
		st[top--]->fa=x->fa=&d[cnt];
		insert(x->fa);
		return;
	} 
	for (int i=top,mn=x->mn,mx=x->mx;i && L[x->r]<=st[i]->r;--i){
		mn=min(mn,st[i]->mn);
		mx=max(mx,st[i]->mx);
		if (mx-mn+1==x->r-st[i]->l+1){
			d[++cnt]={null,x,mn,mx,0,st[i]->l,x->r};
			x->fa=&d[cnt]; 
			for (;top>=i;--top)
				st[top]->fa=&d[cnt];
			insert(x->fa);
			return;
		}
	}
	st[++top]=x;
}
int f[N*2][18],dep[N*2];
void getdep(int x){
	if (dep[x] || x==0)
		return;
	getdep(f[x][0]);
	dep[x]=dep[f[x][0]]+1;
}
inline void getans(int u,int v){
	if (dep[u]>dep[v]){
		for (int k=dep[u]-dep[v],i=0;k;k>>=1,++i)
			if (k&1)
				u=f[u][i];
	}
	else
		for (int k=dep[v]-dep[u],i=0;k;k>>=1,++i)
			if (k&1)
				v=f[v][i];
	for (int i=17;i>=0;--i)
		if (f[u][i]!=f[v][i])
			u=f[u][i],v=f[v][i];
	if (d[f[u][0]].xihe==0)
		printf("%d %d\n",d[f[u][0]].l,d[f[v][0]].r);
	else
		printf("%d %d\n",d[u].l,d[v].r);
}
int main(){
	freopen("c.in","r",stdin);
	freopen("c.out","w",stdout);
	scanf("%d",&n);
	for (int i=1;i<=n;++i)
		scanf("%d",&a[i]);
	for (int i=1;i<=n;++i){
		for (;tn && a[smn[tn]]>a[i];--tn)
			add(1,1,n,smn[tn-1]+1,smn[tn],a[smn[tn]]-a[i]);
		for (;tx && a[smx[tx]]<a[i];--tx)
			add(1,1,n,smx[tx-1]+1,smx[tx],a[i]-a[smx[tx]]);
		smn[++tn]=i,smx[++tx]=i;
		add(1,1,n,i,i,i);
		L[i]=find(1,1,n,1,i,i);
	}
	st[0]=null;
	*null={null,null,0,0,0,0,0};
	for (int i=1;i<=n;++i){
		d[num[i]=++cnt]={null,null,a[i],a[i],0,i,i};
		insert(&d[cnt]);
	}
	assert(top==1 && st[top]->l==1 && st[top]->r==n);
	for (int i=1;i<=cnt;++i)
		f[i][0]=d[i].fa-d;
	for (int i=1;i<=cnt;++i)
		getdep(i);
	for (int i=1;i<=17;++i)
		for (int j=1;j<=cnt;++j)
			f[j][i]=f[f[j][i-1]][i-1];
	int Q;
	scanf("%d",&Q);
	while (Q--){
		int l,r;
		scanf("%d%d",&l,&r);
		getans(num[l],num[r]);
	}
	return 0;
}

到此为止了么？
不，实际上有真正的 O ( n ) O(n) O(n)解法。
对于一个区间 [ l , r ] [l,r] [l,r]，找到 [ l , r ] [l,r] [l,r]中的最大值 m x mx mx和最小值 m n mn mn。
然后找到值为 [ m n , m x ] [mn,mx] [mn,mx]的最右位置 R R R。显然，如果 r &lt; R r&lt;R r<R，那么以 r r r为右端点的最大区间左端点小于 l l l。也就是说，不存在 L &lt; l L&lt;l L<l的区间 [ L , r ] [L,r] [L,r]包含 [ l , r ] [l,r] [l,r]。
在做第三个操作的时候，沿路记下 m n mn mn和 m x mx mx，求出 R R R。如果 r &lt; R r&lt;R r<R，就不用做下去了，因为 R R R只会越来越大。
求的时候直接用 R M Q RMQ RMQ， O ( 1 ) O(1) O(1)处理询问。
这是个非常好的优化，尽管它看起来仍然是 O ( n 2 ) O(n^2) O(n2)的，但是数据似乎不怎么卡。
为了满足强迫症的想法，我们使劲将它优化到 O ( n ) O(n) O(n)。
对于栈中的每个点，可以记录一个 f a i l fail fail指针表示它之前找到的第一个 r &lt; R r&lt;R r<R的地方。
那么以后就不需要暴力找，只需要跳 f a i l fail fail来找。
每条 f a i l fail fail边只会跳 O ( 1 ) O(1) O(1)次（跳了意味着这次 R ≤ r R\leq r R≤r，如果在后来还没有成功， f a i l r fail_r failr​一定会指向一个更前的点。这样在后来跳的时候，再也不会经过这条边。）
所以这样做的时间复杂度是 O ( n ) O(n) O(n)的！
然而，我们愕然发现预处理的时间复杂度依然是 O ( n lg ⁡ n ) O(n\lg n) O(nlgn)……

先放个代码：

using namespace std;
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
//#include <cassert>
#define N 100010
int lg[N];
int n,a[N];
int mx[N][17];
inline int query(int l,int r){
	int m=lg[r-l+1];
	return max(mx[l][m],mx[r-(1<<m)+1][m]);
}
int cnt;
struct Node{
	Node *fa,*lst;
	int mn,mx;
	bool xihe;
	int l,r;
} d[N*2],*null=d;
int num[N];
int top;
Node *st[N*2];
int fail[N*2],mnf[N*2],mxf[N*2];
inline int ok(Node *x,Node *y){return x->mx+1==y->mn?1:(x->mn-1==y->mx?-1:0);}
void insert(Node *x){
	if (!top){
		st[++top]=x;
		fail[top]=0;
		mnf[top]=x->mn;
		mxf[top]=x->mx;
		return;
	}
	int tmp;
	if (st[top]->xihe==1 && (tmp=ok(st[top]->lst,x))){
		if (tmp==1)
			st[top]->mx=x->mx;
		else
			st[top]->mn=x->mn;
		st[top]->lst=x;
		st[top]->r=x->r;
		x->fa=st[top];
		top--;
		insert(x->fa);
		return;
	}
	if (tmp=ok(st[top],x)){
		if (tmp==1)
			d[++cnt]={null,x,st[top]->mn,x->mx,1,st[top]->l,x->r};
		else
			d[++cnt]={null,x,x->mn,st[top]->mx,1,st[top]->l,x->r};
		st[top]->fa=x->fa=&d[cnt];
		top--;
		insert(x->fa);
		return;
	}
	for (int i=top,mn=x->mn,mx=x->mx;i;mn=min(mn,mnf[i]),mx=max(mx,mxf[i]),i=fail[i]){
		mn=min(mn,st[i]->mn);
		mx=max(mx,st[i]->mx);
		if (query(mn,mx)>x->r){
			st[++top]=x;
			fail[top]=i;
			mnf[top]=mn;
			mxf[top]=mx;
			return;
		}
		if (mx-mn+1==x->r-st[i]->l+1){
			d[++cnt]={null,x,mn,mx,0,st[i]->l,x->r};
			x->fa=&d[cnt];
			for (;top>=i;--top)
				st[top]->fa=&d[cnt];
			insert(x->fa);
			return;
		}
	}
}
int f[N*2][18],dep[N*2];
void getdep(int x){
	if (dep[x] || x==0)
		return;
	getdep(f[x][0]);
	dep[x]=dep[f[x][0]]+1;
}
inline void getans(int u,int v){
	if (dep[u]>dep[v]){
		for (int k=dep[u]-dep[v],i=0;k;k>>=1,++i)
			if (k&1)
				u=f[u][i];
	}
	else
		for (int k=dep[v]-dep[u],i=0;k;k>>=1,++i)
			if (k&1)
				v=f[v][i];
	for (int i=17;i>=0;--i)
		if (f[u][i]!=f[v][i])
			u=f[u][i],v=f[v][i];
	if (d[f[u][0]].xihe==0)
		printf("%d %d\n",d[f[u][0]].l,d[f[v][0]].r);
	else
		printf("%d %d\n",d[u].l,d[v].r);
}
int main(){ 
	freopen("c.in","r",stdin);
	freopen("c.out","w",stdout);
	scanf("%d",&n);
	lg[0]=0,lg[1]=0;
	for (int i=2;i<=n;++i)
		lg[i]=lg[i>>1]+1;
	for (int i=1;i<=n;++i)
		scanf("%d",&a[i]);
	for (int i=1;i<=n;++i)
		mx[a[i]][0]=i;
	for (int i=1;1<<i<=n;++i)
		for (int j=1;j+(1<<i)-1<=n;++j)
			mx[j][i]=max(mx[j][i-1],mx[j+(1<<i-1)][i-1]);
	st[0]=null;
	*null={null,null,0,0,0,0,0};
	for (int i=1;i<=n;++i){
		d[num[i]=++cnt]={null,null,a[i],a[i],0,i,i};
		insert(&d[cnt]);
	}
	for (int i=1;i<=cnt;++i)
		f[i][0]=d[i].fa-d;
	for (int i=1;i<=cnt;++i)
		getdep(i);
	for (int i=1;i<=17;++i)
		for (int j=1;j<=cnt;++j)
			f[j][i]=f[f[j][i-1]][i-1];
	int Q;
	scanf("%d",&Q);
	while (Q--){
		int l,r;
		scanf("%d%d",&l,&r);
		getans(num[l],num[r]);
	}
	return 0;
}

接着我们考虑如何处理 [ l , r ] [l,r] [l,r]的询问。
其实只要处理出所有 i ∈ [ l , r ) i \in [l,r) i∈[l,r)的 [ i , i + 1 ] [i,i+1] [i,i+1]的并，就是 [ l , r ] [l,r] [l,r]询问的答案。
对于栈中的每个节点，处理出 [ l , r ] [l,r] [l,r]的答案（好像是 [ l , r ) [l,r) [l,r)？）。对于每条 f a i l fail fail边，处理出中间答案的并。
所以现在的问题是求所有 [ i , i + 1 ] [i,i+1] [i,i+1]的答案。
实际上这可以看成许多个区间询问，然而我们要 O ( n ) O(n) O(n)来预处理出这些东西。
区间询问怎么预处理？有个很牛的方法是 O ( n ) O(n) O(n)建出笛卡尔树，然后变成 L C A LCA LCA问题。用 T a r j a n − L C A Tarjan-LCA Tarjan−LCA来求。这样就可以达到 O ( n ) O(n) O(n)了。
或者也可以在建树之后用 + 1 − 1 R M Q +1-1RMQ +1−1RMQ来解决，然而我没有打过。
所以实际上 O ( n ) O(n) O(n)好像没有什么用啊……毕竟如果出题，肯定不只是析合树，然而其它操作总是要 lg ⁡ \lg lg级别的……
而且这样代码复杂度还很恐怖……
我没打过，别找我拿标程……

如果真的要打析合树，用线段树的 O ( n lg ⁡ n ) O(n\lg n) O(nlgn)方法似乎是一种不错的选择，因为思路比较简单。
或者用 O ( n lg ⁡ n ) O(n\lg n) O(nlgn)预处理 S T ST ST表来搞，还有记录 f a i l fail fail边，这样代码长度会短一些。
至于纯正的 O ( n ) O(n) O(n)……就在嘴巴上说说算了吧……

相场法模拟二元合金中考虑溶质偏析的comsol枝晶生长研究,comsol枝晶生长相场法模拟 二元合金 考虑溶质偏析 ,comsol;枝晶生长;相场法模拟;二元合金;溶质偏析,COMSOL二元合金溶质偏
01-29
具体来说，通过COMSOL软件进行的枝晶生长相场法模拟研究，可以对二元合金中的溶质偏析进行定量分析，观察不同偏析条件下枝晶的形态变化，并对枝晶生长的动力学和热力学过程进行解析。这些模拟研究不仅可以预测实际...
数理逻辑辅助工具-合取范式&析取范式生成器
01-22
在这个领域中，合取范式（Conjunctive Normal Form, CNF）和析取范式（Disjunctive Normal Form, DNF）是两种重要的逻辑表达方式。它们在计算机科学，尤其是人工智能和软件工程中有着广泛的应用，例如在电路设计、...
【学习笔记】析合树
weixin_34056162的博客
06-14 400
定义 为了方便，下面的定义都是对一个\(n\)阶排列 定义一个段的值域$ran[l,r] = [min a_i , max a_i] (l \le i \le r) $ ，对于一个排列\(ran[l,r] \ge r-l+1\) 定义1 一个段是连续的，当且\(|ran[l,r]|= r-l+1\) ，显然$ \varnothing ,[1,n],[i,i]$都是连续的 性质1： 对于两...
析合树学习笔记
ez_lcw的博客
11-02 748
析合树 对于一个 nnn 阶排列 ppp，定义其一个区间 [l,r][l,r][l,r] 是连续的，当且仅当 pl,pl+1,⋯ ,prp_{l},p_{l+1},\cdots,p_rpl​,pl+1​,⋯,pr​ 值域连续。我们用下标区间 [l,r][l,r][l,r] 来代表这个连续段，用 f(l,r)f(l,r)f(l,r) 表示这个连续段的值域区间。 我们称排列 ppp 的所有连续段构成的集合为 IpI_pIp​。 连续段有几个显而易见的性质： 对于任意两个有交且互不包含的连续段 A,B∈IpA
数理逻辑程序：生成合取与析取范式工具
它使用二叉树作为内部表示和处理结构，这表明算法可能涉及到将逻辑表达式转换为二叉树形式，然后遍历这棵树以提取出构成合取范式或析取范式的基础子句。文件信息中提到了“比较详细的说明文档”，意味着用户需要参考...
Tutte对图论的贡献
05-30
这是一篇博士论文，专门介绍Tutte 教授对于图论和组合数学的贡献，罕见的材料。
实验1-利用真值表法求取主析取范式以及主合取范式的实现1
08-08
实验目的是通过实践加深对析取、合取范式以及它们与二进制对应关系的理解。 在传统的表达式计算中，我们通常会为每个命题变元建立一个映射，然后通过栈或表达式树来计算表达式的值。然而，这种方法存在一些局限性：...
Codeforces Round #493 (Div. 1) E. Good Subsegments 析合树
MTS_ZX的博客
02-26 262
原题链接 题目描述：给定一个长度为n的排列，每次询问一个区间，有多少个子区间是连续段 解法：建出析合树，考虑询问区间是[l,r][l,r][l,r],设L=l−1,R=r+1;K=lca(L,R)L=l-1,R=r+1; K=lca(L,R)L=l−1,R=r+1;K=lca(L,R)。K的儿子中L的祖先为SLSLSL,R的祖先为SRSRSR。 需要统计以下信息： tottottot:以iii为根的子树内连续段数目 lnlnln:iii所在的儿子序列中，只使用下标小于iii的儿子及其后代组成的连续段数目 r
析合树学习小记
Cold_Chair的博客
06-10 2963
析合树……怎么说呢，应该是一个排列的一种划分方法，用于处理连续段有关问题。 首先定义连续段： 对于一个排列的一个区间[x,y][x,y][x,y]，如果把这个区间的数拿出来排序，是连续的若干个数，即y−x+1=max(x..y)−min(x..y)+1y-x+1=max(x..y)-min(x..y)+1y−x+1=max(x..y)−min(x..y)+1，则称[x,y][x,y][x,y]为...
学习析合树小记
RainbowCrown_CGH's blog
12-12 359
前言 心态崩了 这玩意不仅比较猎奇，而且网上有关资料还是参差不齐的。 看WC2019LCA的ppt也是一头雾水（尤其是那个定义） 最后在三个地方终于找到了有价值的东西。（自己看到下面的参考资料） 然后想想还是写写博客加强印象以免忘记吧。 正题 引入 我们看一道题： 让我们来想想这题怎么做？ 有一个十分方便的方法—— 对于每次询问，我们考虑选出询问区间内的最大值与最小值。 然后再找出选取最大到最小...
析合树是你的谎言
七代目鸽影
09-12 293
Hail the PRINCIPAL! Heil dem Schulleiter! Salut au proviseur!
析合树形态计数 dp
Four's
03-10 832
  正儿八经的用析合树本身的题没见着，析合树形态计数倒是一大堆。。。   名词注释：   子段：一个排列中的连续子序列   非平凡子段：长度大于 111、且不为排列本身的子段   连续段：若把一个子段的元素重排后是连续的，那么这个子段是一个连续段。 V1 题源：【2018-2019 ICPC, NEERC, Northern Eurasia Finals】I. Interval-Free Per...
【清华夏令营模拟2019.5.22】连续段（析合树+多项式牛顿迭代）
Cold_Chair的博客
05-22 721
Description： n<=1e5，P是NTT模数 题解： 析合树见WC2019LCA营员交流讲稿 我们考虑把一个序列划分成本源连续段。 怎么划分呢？就是极大划分，假设划分成了x段。 这x段需要满足任取一个区间的段，要么可以全部可以拼起来(1)，要么除了最大的那一个其它都不行(2)。 仔细思考这样就能表示所有的段了。 (1)就是析点，(2)就是合点。 考虑x=2、3时只能是合点 设F表...
[BZOJ]5259: [Cerc2017]区间 线段树
TYB的博客
03-25 465
Description 给定一个1到n的排列a1, . . . , an。 对于一个区间[l, r]，我们称该区间是连续的，如果将al, . . . , ar排列之后得到的是一列连续的数。 （换句话说，如果x,y都在该区间中，那么所有介于x,y之间的数也在该区间中） 现在有m(1 ≤ n, m ≤ 100000)个询问，每个询问给出一个区间[xi, yi], 你需要找到一个长度最短的连续区间[li...
[乱搞] BZOJ 4434 [Cerc2015]Ice Igloos
雯舞
04-13 551
#include<cstdio> #include<cstdlib> #include<cmath> #include<algorithm> using namespace std;double r[505][505]; double A,B,C; double K,L;int Count(int x,int y1,int y2){ int ret=0; for (int y=y1;y<=y
数据结构之二叉树
m0_65503491的博客
02-01 780
数据结构之二叉树 概念及代码实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值