树形dp

最新推荐文章于 2022-03-20 00:16:02 发布
置顶 最新推荐文章于 2022-03-20 00:16:02 发布
阅读量197 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Roar__/article/details/100542917
版权

题目列表：P1122 P2016 P1352 P2015 P2014 P1273 P1272 P2458 P1131 P1270 P3177 

P1122最大子树和

#include<bits/stdc++.h>
using namespace std;
int n;
int v[16005];
vector<int> vec[16005];
int mx=~0x3f3f3f3f,root=0;
int dp[16005];

void dfs(int cur,int fa){
	dp[cur]=v[cur];
	
	for(int i=0;i<vec[cur].size();i++){
		int to=vec[cur][i];
		if(to==fa)continue;
		
		dfs(to,cur);
		if(dp[to]<0)dp[to]=0;
		dp[cur]+=dp[to];
	}
}

int main(){
	scanf("%d",&n);
	
	for(int i=1;i<=n;i++){
		scanf("%d",&v[i]);
		if(mx<v[i]){
			root=i;mx=v[i];
		}
	}
	for(int i=1;i<n;i++){
		int a,b;
		scanf("%d%d",&a,&b);
		vec[a].push_back(b);
		vec[b].push_back(a);
	}
	
	dfs(root,0);
	cout<<dp[root]<<endl;
	
	return 0;
}

P2016战略游戏

#include<bits/stdc++.h>
using namespace std;
int n;
vector<int> vec[1505];

int dp[1505][3];
void dfs(int cur,int fa){
	dp[cur][0]=1;
	
	for(int i=0;i<vec[cur].size();i++){
		int to=vec[cur][i];
		if(to==fa)continue;
		
		dfs(to,cur);
		
		dp[cur][0]+=min(dp[to][0],dp[to][1]);//放置士兵的位置
		dp[cur][1]+=dp[to][0];//没放置士兵的位置
	}
}

int book[1505];
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		int a;
		scanf("%d",&a);
		int t;
		scanf("%d",&t);
		for(int j=1;j<=t;j++){
			int temp;
			scanf("%d",&temp);
			vec[a].push_back(temp);
			book[temp]=1;
		}
	}
	
	int root=find(book,book+n,0)-book;

	dfs(root,-1);

	int ans=min(dp[root][0],dp[root][1]);
	cout<<ans<<endl;
	return 0;
}

P1352没有上司的舞会 战略游戏升级版

#include<bits/stdc++.h>
using namespace std;
int n;
int v[6005];
vector<int> vec[6005];
int dp[6005][2];
int flag[6005];

void dfs(int cur,int fa){
	dp[cur][1]=v[cur];
	
	for(int i=0;i<vec[cur].size();i++){
		int to=vec[cur][i];
		if(to==fa)continue;
		
		dfs(to,cur);
		dp[cur][0]=max(dp[cur][0],dp[cur][0]+max(dp[to][1],dp[to][0]));//该位置没有上司
		dp[cur][1]=max(dp[cur][1],dp[cur][1]+dp[to][0]);//该位置为上司
	}
}

int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&v[i]);
	}
	
	
	for(int i=1;i<=n;i++){
		int a,b;
		scanf("%d%d",&a,&b);
		if(i==n)break;
		vec[b].push_back(a);
		flag[a]=1;
	}
	
	int ans=0;
	for(int i=1;i<=n;i++){
		if(flag[i])continue;
		dfs(i,0);
		ans+=max(dp[i][0],dp[i][1]);
	}
	
	cout<<ans;
	
	return 0;
}

P2015二叉苹果树 树上分组背包

#include<bits/stdc++.h>
using namespace std;
int n,m;
int v[105][105];
vector<int> vec[105];

int sz[105];
int dp[105][105];
void dfs(int cur,int fa){
	sz[cur]=1;
	
	for(int i=0;i<vec[cur].size();i++){
		int to=vec[cur][i];
		if(to==fa)continue;
		
		dfs(to,cur);
		sz[cur]+=sz[to];
		
		for(int j=min(m,sz[cur]-1);j;j--){
			for(int k=0;k<=min(j-1,sz[to]-1);k++){
				dp[cur][j]=max(dp[cur][j],dp[to][k]+dp[cur][j-k-1]+v[cur][to]);
			}
		}
	}
}

int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<n;i++){
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		vec[a].push_back(b);
		vec[b].push_back(a);
		v[a][b]=c,v[b][a]=c;
	}
	
	dfs(1,0);

	cout<<dp[1][m];
	
	return 0;
}

P2014选课 同二叉苹果树 都是分组背包

#include<bits/stdc++.h>
using namespace std;
int n,m;
int v[305];
vector<int> vec[305];

int sz[305];
int dp[305][305];
void dfs(int cur,int fa){
	sz[cur]=1;
	
	for(int i=0;i<vec[cur].size();i++){
		int to=vec[cur][i];
		if(to==fa)continue;
		
		dfs(to,cur);
		sz[cur]+=sz[to];
		
		for(int j=min(m,sz[cur]-1);j;j--){
			for(int k=0;k<=min(j-1,sz[to]-1);k++){
				dp[cur][j]=max(dp[cur][j],dp[to][k]+dp[cur][j-k-1]+v[to]);
			}
		}
	}
}

int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++){
		int a,b;
		scanf("%d%d",&a,&b);
		vec[i].push_back(a);
		vec[a].push_back(i);
		v[i]=b;
	}
	
	dfs(0,0);

	cout<<dp[0][m];
	
	return 0;
}

P1273有线电视网 树上分组背包

#include<bits/stdc++.h>
using namespace std;
int n,m;
int v[3005];
int mp[3005][3005];
int money[3005];
vector<int> vec[3005];
int dp[3005][3005];
int sz[3005];

void dfs(int cur,int fa){
	if(vec[cur].size()==0){
		sz[cur]=1;
		dp[cur][1]=money[cur];
		return ;
	}
	
	for(int i=0;i<vec[cur].size();i++){
		int to=vec[cur][i];
		if(to==fa)continue;
		
		dfs(to,cur);
		sz[cur]+=sz[to];
		
		for(int j=sz[cur];j;j--){
			for(int k=0;k<=sz[to];k++){
				if(j<k)break;
				dp[cur][j]=max(dp[cur][j],dp[to][k]+dp[cur][j-k]-mp[cur][to]);
			}
		}
	}
}

int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n-m;i++){
		int t;
		scanf("%d",&t);
		for(int j=1;j<=t;j++){
			int a,b;
			scanf("%d%d",&a,&b);
			vec[i].push_back(a);
			mp[i][a]=b;
			mp[a][i]=b;
		}
	}
	for(int i=1;i<=m;i++){
		scanf("%d",&money[i+n-m]);
	}
	
	memset(dp,~0x3f,sizeof(dp));
	for(int i=1;i<=n;i++){
		dp[i][0]=0;
	}
	
	dfs(1,0);
	
	for(int i=m;i;i--){
		if(dp[1][i]>=0){
			cout<<i<<endl;
			return 0;
		}
	}
	
	return 0;
}

P1272重建道路 

#include<bits/stdc++.h>
using namespace std;
int n,p;
vector<int> vec[155];
int dp[155][155];
int sz[155];
void dfs(int cur,int fa){
	sz[cur]=1;
	dp[cur][1]=vec[cur].size();
	
	for(int i=0;i<vec[cur].size();i++){
		int to=vec[cur][i];
		if(to==fa)continue;
		
		dfs(to,cur);
		sz[cur]+=sz[to];
		
		for(int j=sz[cur];j>=1;j--){
			for(int k=1;k<=sz[to];k++){
				if(j<=k)continue;
				dp[cur][j]=min(dp[cur][j],dp[cur][j-k]+dp[to][k]-1);
			}
		}
	}
}

int book[155];
int main(){
	scanf("%d%d",&n,&p);
	for(int i=1;i<n;i++){
		int a,b;
		scanf("%d%d",&a,&b);
		vec[a].push_back(b);
		book[b]=1;
	}
	int root=find(book+1,book+1+n,0)-book;
	
	memset(dp,0x3f,sizeof(dp));
	
	dfs(root,0);
	
	int ans=0x3f3f3f3f;
	for(int i=1;i<=n;i++){
		ans=min(ans,dp[i][p]+((i==root)?0:1));
	}
	cout<<ans<<endl;
	return 0;
}

P2458[SDOI2006]保安站岗 分类讨论 加维表示3种状态

因为不能忽略子节点对父节点的影响，所以需要三种状态

分别为1.在当前节点放置一个保安 2.在至少一个子节点放置保安 3.在父节点放置一个保安

dp[cur][0]=v[cur]+\sum min(dp[to][0],dp[to][1],dp[to][2])

dp[cur][1]=\sum min(dp[to][0],dp[to][1])至少存在一次dp[to][0],否则补上sig=dp[to][0]-dp[to][1]来满足至少一次dp[to][0]

dp[cur][2]=min(dp[to][0],dp[to][1])

#include<bits/stdc++.h>
using namespace std;
int n;
int v[1505];
vector<int> vec[1505];

int dp[1505][3];
void dfs(int cur,int fa){
	dp[cur][0]=v[cur];
	
	int flag=0,sig=0x3f3f3f3f;
	for(int i=0;i<vec[cur].size();i++){
		int to=vec[cur][i];
		if(to==fa)continue;
		
		dfs(to,fa);
		
		dp[cur][0]+=min(dp[to][0],min(dp[to][1],dp[to][2]));
		if(dp[to][0]<=dp[to][1]){
			flag=1;
			dp[cur][1]+=dp[to][0];
			dp[cur][2]+=dp[to][0];
		}
		else {
			sig=min(sig,dp[to][0]-dp[to][1]);
			dp[cur][1]+=dp[to][1];
			dp[cur][2]+=dp[to][1];
		}
	}
	
	dp[cur][1]+=(flag==0)?sig:0;
}

int book[1505];
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		int a,b;
		scanf("%d%d",&a,&b);
		v[a]=b;
		int t;
		scanf("%d",&t);
		for(int j=1;j<=t;j++){
			int temp;
			scanf("%d",&temp);
			vec[a].push_back(temp);
			book[temp]=1;
		}
	}
	
	int root=find(book+1,book+1+n,0)-book;
	
	dfs(root,0);

	int ans;
	ans=min(dp[root][0],dp[root][1]);
	cout<<ans;
	return 0;
}

P1131[ZJOI2007]时态同步

#include<bits/stdc++.h>
using namespace std;
#define MAXN 1000005
#define ll long long
ll n;

ll u[MAXN],v[MAXN],w[MAXN];
ll first[MAXN],nxt[MAXN],cnt;
void add(ll a,ll b,ll c){
	++cnt;
	nxt[cnt]=first[a];first[a]=cnt;
	u[cnt]=a,v[cnt]=b,w[cnt]=c;
}

ll dp[MAXN];
ll ans=0;
void dfs(int cur,int fa){
	ll mx=0;
	for(int i=first[cur];i;i=nxt[i]){
		int to=v[i];
		if(to==fa)continue;
		
		dfs(to,cur);
		
		mx=max(mx,w[i]+dp[to]);
	}
	
	dp[cur]+=mx;
	
	for(int i=first[cur];i;i=nxt[i]){
		int to=v[i];
		if(to==fa)continue;
		
		ans+=mx-(w[i]+dp[to]);
	}
}

int main(){
	scanf("%lld",&n);
	ll root;
	scanf("%lld",&root);
	for(ll i=1;i<n;i++){
		ll a,b,c;
		scanf("%lld%lld%lld",&a,&b,&c);
		add(a,b,c);
		add(b,a,c);
	}
	
	dfs(root,0);
	
	cout<<ans<<endl;
	
	return 0;
}

P1270“访问”美术馆

#include<bits/stdc++.h>
using namespace std;
#define MAXN 405

int u[MAXN],v[MAXN],w[MAXN];
int cnt,first[MAXN],nxt[MAXN];
void add(int a,int b,int c){
	++cnt;
	nxt[cnt]=first[a];first[a]=cnt;
	u[cnt]=a;v[cnt]=b;w[cnt]=c;
}

int dp[MAXN][2005];

int flag[MAXN];
pair<int,int> mp[MAXN];
int n;
bool vis[MAXN];
void pre(int cur,int fa){
	flag[fa]++;
	
	if(flag[fa]>2){
		return ;
	}
	vis[cur]=1;
	
	add(cur,fa,mp[cur].first*2);
	add(fa,cur,mp[cur].first*2);
	for(int i=0;i<=mp[cur].second;i++){
		dp[cur][i]=5*i;
	}
 
	if(mp[cur].second!=0)return ;
	
	for(int i=1;i<=n;i++){
		if(vis[i])continue;

		pre(i,cur);
	}
}

int sz[MAXN];
void dfs(int cur,int fa){
	sz[cur]=mp[cur].second;
	
	for(int i=first[cur];i;i=nxt[i]){
		int to=v[i];
		if(to==fa)continue;
		
		dfs(to,cur);
		sz[cur]+=sz[to];
		
		for(int j=sz[cur];j>=0;j--){
			for(int k=1;k<=sz[to];k++){
				if(j<k)break;
				dp[cur][j]=min(dp[cur][j],dp[to][k]+dp[cur][j-k]+w[i]);
			}
		}
	}
}


int main(){
	/*
	freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    */
	int tme;
	scanf("%d",&tme);
	int a,b,m=0;
	
	while(~scanf("%d%d",&a,&b)){
		++n;
		mp[n]=pair<int,int>(a,b);
		m+=b;
	}

	memset(dp,0x3f,sizeof(dp));
	
	pre(1,0);

	dp[0][0]=0;
	dfs(0,-1);
	
	for(int i=m;i>=0;i--){
		if(dp[0][i]<tme){
			cout<<i<<endl;
			return 0;
		}
	}
	return 0;
}

P3177[HAOI2015]树上染色

权值val不只是在当前根节点的子树内，而是对于整棵树来说的，相当于将一颗树以这条边分成两半

并且这个权值是动态的，状态不同权值也不相同，所以需要在dfs的过程中计算

#include<bits/stdc++.h>
using namespace std;
#define MAXN 4005
#define ll long long

int n,m;
int u[MAXN],v[MAXN],w[MAXN];
int cnt,first[MAXN],nxt[MAXN];
void add(int a,int b,int c){
	++cnt;
	nxt[cnt]=first[a];first[a]=cnt;
	u[cnt]=a,v[cnt]=b,w[cnt]=c;
}

int sz[MAXN];
ll dp[MAXN][MAXN];
void dfs(int cur,int fa){
	dp[cur][0]=dp[cur][1]=0;
	sz[cur]=1;
	
	for(int i=first[cur];i;i=nxt[i]){
		int to=v[i];
		if(to==fa)continue;
		
		dfs(to,cur);
		sz[cur]+=sz[to];
		
		for(int j=min(m,sz[cur]);j>=0;j--){
			for(int k=0;k<=sz[to];k++){
				if(j<k)break;
				if(dp[cur][j-k]==-1)continue;//此边的另外一部分 状态的最多黑点数比较少 可能无法达到j-k个 属于不合法状态 所以当前状态需要直接跳过
				
				int numl=k,numr=m-k;
				ll val=1ll*((n-numr-sz[to])*(sz[to]-numl)+numl*numr)*w[i];//因为是整棵树的价值，所以需要用n来减
				dp[cur][j]=max(dp[cur][j],dp[to][k]+dp[cur][j-k]+val);
			}
		}
	}
}

int book[MAXN];
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<n;i++){
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c);add(b,a,c);
		book[b]=1;
	}
	
	int root=find(book+1,book+n+1,0)-book;
	
	memset(dp,-1,sizeof(dp));
	
	dfs(root,0);
	
	cout<<dp[root][m]<<endl;
	
	return 0;
}

D - Serval and Rooted Tree

每个叶节点的值不确定，但是可以改变思路，从大小顺序入手。

dp[i]表示第i个结点的值为第dp[i]大。

若为max结点，dp[i]等于所有子结点中最小的dp[j]，越靠前越大。

若为min结点，dp[i]等于所有子结点中dp[j]的和，最大为第dp[j]大。

#include<bits/stdc++.h>
using namespace std;
#define MAXN 300005
#define inf 0x3f3f3f3f

int flag[MAXN];
int sz[MAXN];
int dp[MAXN];
vector<int> pv[MAXN];
void dfs(int cur,int fa){
	if(pv[cur].size()==0){
		dp[cur]=1;
		sz[cur]=1;
		return ;
	}
	if(flag[cur])dp[cur]=inf;
	
	for(int i=0;i<pv[cur].size();i++){
		int to=pv[cur][i];
		if(to==fa)continue;
		dfs(to,cur);

		sz[cur]+=sz[to];
		if(flag[cur]){
			dp[cur]=min(dp[to],dp[cur]);
		}
		else {
			dp[cur]+=dp[to];
		}
	}
}

int main(){
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&flag[i]);
	}
	
	for(int i=2;i<=n;i++){
		int t;
		scanf("%d",&t);
		pv[t].push_back(i);
	}
	
	dfs(1,0);
	cout<<sz[1]+1-dp[1]<<endl;		
	return 0;
}

 

咆哮_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CodeForces - 1153D. Serval and Rooted Tree（树状dp）
weixin_43896680的博客
04-17 178
D. Serval and Rooted Tree Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before. As a talented boy in mathematics, he likes to play with number...
树形DP-我的学习笔记
最新发布
05-17
就是赚个积分啊
Serval and Rooted Tree(树形dp）
木静音yy的博客
03-20 989
LINK 题目： 样例： 样例解释： 题意： 现有一棵树（根节点为1），树上每个结点上有一个flag值 （flag=0 ：表示这个点的权值是所有子节点权值中的最小值；flag=1：表示这个点的权值是所有子节点权值中的最大值）。 有k个叶子节点，可以给每一个叶子节点安排1——k中的值且每个值只能放置一次。 问：根节点值的最大值是多少。 思路： 想复杂了，看了一下大神们的题解，只能说：nb哇！！！ 运用树形dp。 dp[i]：i结点值最大时需要叶子的数量； 在每个叶子节点上dp[叶子]=1（只要叶子自己
Serval and Rooted Tree CodeForces - 1153D（树形dp）
starlet_kiss的博客
10-15 194
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before. As a talented boy in mathematics, he likes to play with numbers. This time, he wants to ...
Serval and Rooted Tree
1999
04-18 306
D. Serval and Rooted Tree time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output Now Serval is a junior high school student in Japari Mi...
Codeforces 1153 D Serval and Rooted Tree
xiji333的博客
04-17 385
http://codeforces.com/problemset/problem/1153/D Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before. As a talented boy in mathematics, he l...
树形DP（动态规划）.pptx
01-12
树形动态规划（Tree Dynamic Programming, 简称树形DP）是一种在树结构上进行优化决策的方法，常用于解决与树形结构相关的最优化问题。在这个特定的问题中，我们面临的是一个聚会组织的问题，目标是找到使得幽默系数...
树形DP的讲解
03-27
ACM之树形DP，利用子节点的信息维护父节点信息，想在区域赛拿奖的童鞋就抱走吧
区间DP概率DP树形DP插头DP
09-05
区间DP概率DP树形DP插头DP，每种DP一道典型例题，有助于初学者
树形DP浅略总结
05-13
D. Serval and Rooted Tree(思维+树形dp+二分辅助)
代码笔记本
04-13 142
https://codeforces.com/problemset/problem/1153/D 思路：参考issue https://issue-is-vegetable.blog.csdn.net/article/details/107760491?utm_medium=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-1.control&dist_request_id=
D. Serval and Rooted Tree
newhonor
04-14 335
http://codeforces.com/contest/1153/problem/D 题意：n个节点的树，叶子可以任意分别给1~k（k为叶子个数）的值，每个节点有操作min，max分别取其子树的最小和最大的值； 问根节点1最大多少； 思路：每个节点记录它能表示的它叶子数量的最小的值（排序后最靠近前面的，第k大的数），min时就是只能是子树的叶子的数量了；max时就能是儿子最小的了（最靠前...
【CodeForces - 1153D】Serval and Rooted Tree（树形dp）
xuanweiace的博客
04-23 480
题干： Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before. As a talented boy in mathematics, he likes to play with numbers. This time, he wan...
cf 551 div2 D——Serval and Rooted Tree （树形DP）
Q755100802的博客
04-30 206
题目链接：http://codeforces.com/contest/1153/problem/D D. Serval and Rooted Tree time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output Now ...
#551 (Div. 2)___D Serval and Rooted Tree —— 树dp
Scar_Halo
04-15 198
题目链接：点我啊╭(╯^╰)╮ 题目大意：      一棵树，每个叶子有一个 111~kkk 的数字，不重复且共有 kkk 个叶子，每个非叶子结点有一个 minminmin 或 maxmaxmax 操作，代表从它的子节点中进行 minminmin 操作或者 maxmaxmax 操作，问根节点的最大值是多少？？？ 解题思路：   &nbsp...
Codeforces Round #551 (Div. 2) D. Serval and Rooted Tree （思维 + dp）
Amo丶
04-16 226
传送门：https://codeforces.com/contest/1153/problem/D D. Serval and Rooted Tree time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output Now ...
Codeforces Round #551 (Div. 2)D. Serval and Rooted Tree
资深罚时选手
04-14 624
D. Serval and Rooted Tree time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output Now Serval is a junior high school student in Japari Mi...
【Codeforces Round #551 (Div. 2) D.Serval and Rooted Tree】树形DP
lajiyuan的博客
04-15 264
链接 Codeforces Round #551 (Div. 2) D.Serval and Rooted Tree 题意 给你一棵树，每个点上有一个flag,如果flag=0，表示这个点的权值是所有子节点权值中的最小值。如果flag=1，表示这个点的权值是所有子节点权值中的最大值。如果一共有k个子节点，我们可以给每一个子节点安排一个1-k中的权值，但是每个权值只能使用一次，现在想知道根节点权值...
Robot Cleaner I 暴力模拟+标记剪枝
还我笑颜
04-14 414
题目链接：点击查看 题意：按照题意进行即可 题解：注意标记，vis[i][j] i表示对坐标的哈希，j表示当前计算的x，值为之前得到多少汽油了，因为如果再次经过这个位置，两次经过的中间得到多汽油，并且改变了图中的2，所以要继续走，知道，走到一个位置，汽油数不增加，然后就是注意一些剪枝 #include<bits/stdc++.h> using namespace std; ty...
python树形dp
04-08
在Python中，可以使用递归或者迭代的方式实现树形DP。 树形DP的基本思想是，从树的叶子节点开始，逐层向上计算每个节点的状态，并利用已经计算过的节点状态来更新当前节点的状态。这样可以通过自底向上的方式，逐步...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值