洛谷 【动态规划3】区间与环形动态规划

最新推荐文章于 2022-09-12 17:59:08 发布
最新推荐文章于 2022-09-12 17:59:08 发布
阅读量277 收藏
点赞数
分类专栏： 洛谷题目 文章标签： 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43975891/article/details/106752343
版权

题单链接

P1220 关路灯

  • 参考《算法竞赛入门经典 ( S e c o n d   E d i t i o n )   P 293   U V a 1336 (Second\ Edition)\ P293 \ UVa1336 (Second Edition) P293 UVa1336》
  • 在任意时刻，已关的灯一定是一个连续的区间
  • f [ i ] [ j ] [ k ] f[i][j][k] f[i][j][k]表示关上了灯 [ i , j ] [i,j] [i,j]，且当前位置在 k k k, k = 0 k=0 k=0表示在左端点i， k = 1 k=1 k=1表示在右端点j
  • f [ i ] [ j ] [ 0 ] = m i n ( f [ i + 1 ] [ j ] [ 0 ] + ( p o s [ i + 1 ] − p o s [ i ] ) ∗ ( s u m [ i ] + s u m [ n ] − s u m [ j ] ) , f [ i + 1 ] [ j ] [ 1 ] + ( a [ j ] − a [ i ] ) ∗ ( s u m [ i ] + s u m [ n ] − s u m [ j ] ) ) ; f[i][j][0] = min ( f[i+1][j][0] + ( pos[i+1] - pos[i] ) * ( sum[i] + sum[n] - sum[j] ) , f[i+1][j][1] + ( a[j]-a[i] ) * ( sum[i]+sum[n]-sum[j]) ); f[i][j][0]=min(f[i+1][j][0]+(pos[i+1]−pos[i])∗(sum[i]+sum[n]−sum[j]),f[i+1][j][1]+(a[j]−a[i])∗(sum[i]+sum[n]−sum[j]));
  • f [ i ] [ j ] [ 1 ] = m i n ( f [ i ] [ j − 1 ] [ 0 ] + ( p o s [ j ] − p o s [ i ] ) ∗ ( s u m [ i − 1 ] + s u m [ n ] − s u m [ j − 1 ] ) , f [ i ] [ j − 1 ] [ 1 ] + ( a [ j ] − a [ j − 1 ] ) ∗ ( s u m [ i − 1 ] + s u m [ n ] − s u m [ j − 1 ] ) ) ; f[i][j][1] = min ( f[i][j-1][0] + ( pos[j] - pos[i] ) * ( sum[i-1] + sum[n] - sum[j-1] ) , f[i][j-1][1] + ( a[j]-a[j-1] ) * ( sum[i-1] + sum[n] - sum[j-1] ) ); f[i][j][1]=min(f[i][j−1][0]+(pos[j]−pos[i])∗(sum[i−1]+sum[n]−sum[j−1]),f[i][j−1][1]+(a[j]−a[j−1])∗(sum[i−1]+sum[n]−sum[j−1]));
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int n,c,f[60][60][2],sum[60],inf=1e7;
struct lamp{
	int p,c;
}s[60];
int main(){
	cin>>n>>c;
	for(int i=1;i<=n;i++){
		cin>>s[i].p>>s[i].c;
		sum[i]=sum[i-1]+s[i].c;		
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			f[i][j][0]=f[i][j][1]=inf;
		}
	}	
	f[c][c][0]=f[c][c][1]=0; 
	for(int len=2;len<=n;len++){
		for(int i=1;i+len-1<=n;i++){
			int j=i+len-1;
			f[i][j][0]=min(f[i+1][j][0]+(s[i+1].p-s[i].p)*(sum[n]-(sum[j]-sum[i])),
						   f[i+1][j][1]+(s[j].p-s[i].p)*(sum[n]-(sum[j]-sum[i])));
			f[i][j][1]=min(f[i][j-1][0]+(s[j].p-s[i].p)*(sum[n]-(sum[j-1]-sum[i-1])),
						   f[i][j-1][1]+(s[j].p-s[j-1].p)*(sum[n]-(sum[j-1]-sum[i-1])));
		}
	}
	cout<<min(f[1][n][0],f[1][n][1])<<endl;
}

P3205 [HNOI2010]合唱队

  • f [ i ] [ j ] [ k ] f[i][j][k] f[i][j][k]表示区间 [ i , j ] [i,j] [i,j]的方案数，当 k = 0 k=0 k=0时表示从左边加入，当 k = 1 k=1 k=1时表示从右边加入。
  • f [ i ] [ j ] [ 0 ] + = f [ i + 1 ] [ j ] [ 0 ] , h [ i ] < h [ i + 1 ] f[i][j][0]+=f[i+1][j][0],h[i]<h[i+1] f[i][j][0]+=f[i+1][j][0],h[i]<h[i+1]
  • f [ i ] [ j ] [ 0 ] + = f [ i + 1 ] [ j ] [ 1 ] , h [ i ] < h [ j ] f[i][j][0]+=f[i+1][j][1],h[i]<h[j] f[i][j][0]+=f[i+1][j][1],h[i]<h[j]
  • f [ i ] [ j ] [ 1 ] + = f [ i ] [ j − 1 ] [ 0 ] , h [ j ] > h [ i ] f[i][j][1]+=f[i][j-1][0],h[j]>h[i] f[i][j][1]+=f[i][j−1][0],h[j]>h[i]
  • f [ i ] [ j ] [ 1 ] + = f [ i ] [ j − 1 ] [ 1 ] , h [ j ] > h [ j − 1 ] f[i][j][1]+=f[i][j-1][1],h[j]>h[j-1] f[i][j][1]+=f[i][j−1][1],h[j]>h[j−1]
  • 只有一个人时方案只有一种，默认从左边加入，初始化时 f [ i ] [ i ] [ 0 ] = 1 f[i][i][0]=1 f[i][i][0]=1
#include<iostream>
#include<algorithm>
using namespace std;
int n,h[1010],mod=19650827,f[1010][1010][2];
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>h[i];
		f[i][i][0]=1;
	}
	for(int len=1;len<=n;len++){
		for(int i=1;i+len-1<=n;i++){
			int j=i+len-1;
			if(h[i]<h[i+1]) f[i][j][0]+=f[i+1][j][0];
			if(h[i]<h[j]) f[i][j][0]+=f[i+1][j][1];
			if(h[j]>h[j-1]) f[i][j][1]+=f[i][j-1][1];
			if(h[j]>h[i]) f[i][j][1]+=f[i][j-1][0];
			f[i][j][0]%=mod;f[i][j][1]%=mod;
		}
	}
	cout<<(f[1][n][0]+f[1][n][1])%mod<<endl;
}

P1880 [NOI1995]石子合并

  • 拆环为链
  • f [ i ] [ j ] f[i][j] f[i][j]表示区间 [ i , j ] [i,j] [i,j]的最大得分， g [ i ] [ j ] g[i][j] g[i][j]表示区间 [ i , j ] [i,j] [i,j]的最小得分
  • f [ i ] [ j ] = s u m [ i ] [ j ] + m a x ( f [ i ] [ k ] + f [ k + 1 ] [ j ] ) , i ≤ k < j f[i][j]=sum[i][j]+max(f[i][k]+f[k+1][j]),i\leq k<j f[i][j]=sum[i][j]+max(f[i][k]+f[k+1][j]),i≤k<j
  • g [ i ] [ j ] = s u m [ i ] [ j ] + m i n ( g [ i ] [ k ] + g [ k + 1 ] [ j ] ) , i ≤ k < j g[i][j]=sum[i][j]+min(g[i][k]+g[k+1][j]),i\leq k<j g[i][j]=sum[i][j]+min(g[i][k]+g[k+1][j]),i≤k<j
#include<iostream>
#include<algorithm>
using namespace std;
int n,a[210],sum[210],f[210][210],g[210][210],inf=1e9,maxans,minans=inf;
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
		a[n+i]=a[i];
	}
	for(int i=1;i<=2*n-1;i++){
		sum[i]=sum[i-1]+a[i];
	}
	for(int len=2;len<=n;len++){
		for(int i=1;i+len-1<=2*n-1;i++){
			int j=i+len-1;
			g[i][j]=inf;
			for(int k=i;k<j;k++){
				f[i][j]=max(f[i][j],f[i][k]+f[k+1][j]+sum[j]-sum[i-1]);
				g[i][j]=min(g[i][j],g[i][k]+g[k+1][j]+sum[j]-sum[i-1]);	
			}			
		} 
	}
	for(int i=1;i<=n;i++){
		maxans=max(maxans,f[i][i+n-1]);
		minans=min(minans,g[i][i+n-1]); 
	}
	cout<<minans<<endl<<maxans<<endl;	
}

P1063 能量项链

  • f [ i ] [ j ] = h e a d [ i ] ∗ h e a d [ k + 1 ] ∗ h e a d [ j ] + m a x ( f [ i ] [ k ] + f [ k + 1 ] [ j ] ) f[i][j]=head[i]*head[k+1]*head[j]+max(f[i][k]+f[k+1][j]) f[i][j]=head[i]∗head[k+1]∗head[j]+max(f[i][k]+f[k+1][j])
#include<iostream>
#include<algorithm>
using namespace std;
int head[300],f[300][300];
int n,ans;
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>head[i];
		head[n+i]=head[i];
	} 
	for(int len=1;len<=n;len++){
		for(int i=1;i+len-1<=2*n-1;i++){
			int j=i+len-1;
			for(int k=i;k<j;k++){
				f[i][j]=max(f[i][j],head[i]*head[k+1]*head[j+1]+f[i][k]+f[k+1][j]);
			}
			ans=max(ans,f[i][j]);
		}
	}	
	cout<<ans<<endl;
}

P1005 矩阵取数游戏(60分)

  • 每一行是独立的，单独求每一行的最大求和即可。
  • d p [ i ] [ j ] dp[i][j] dp[i][j]表示区间 [ i , j ] [i,j] [i,j]尚未被选择的最大值
  • d p [ i ] [ j ] = m a x ( d p [ i − 1 ] [ j ] + 2 m − ( j − i ) + 1 ∗ a [ i − 1 ] , d p [ i ] [ j + 1 ] ∗ 2 m − ( j − i ) + 1 ∗ a [ j + 1 ] ) dp[i][j]=max(dp[i-1][j]+2^{m-(j-i)+1}*a[i-1],dp[i][j+1]*2^{m-(j-i)+1}*a[j+1]) dp[i][j]=max(dp[i−1][j]+2m−(j−i)+1∗a[i−1],dp[i][j+1]∗2m−(j−i)+1∗a[j+1])
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int n,m,a[90];
long long dp[90][90],sum,ans;
long long quick_pow(long long a,long long x){
	long long ans=1;
	while(x){
		if(x&1) ans=ans*a;
		a=a*a;
		x>>=1;
	}
	return ans;
}
int main(){
	cin>>n>>m;
	while(n--){
		memset(dp,0,sizeof dp);
		ans=0;
		for(int i=1;i<=m;i++) cin>>a[i];
		for(int i=1;i<=m;i++){
			for(int j=m;j>=i;j--){
				long long x=quick_pow(2,m-(j-i)-1);
				dp[i][j]=max(dp[i][j],max(dp[i-1][j]+x*a[i-1],dp[i][j+1]+x*a[j+1])); 
			}
		}
		for(int i=1;i<=m;i++){
			ans=max(ans,dp[i][i]+quick_pow(2,m)*a[i]);
		}
		sum+=ans;
	}
	cout<<sum<<endl;
}

P3146 [USACO16OPEN]248 G

  • f [ i ] [ j ] f[i][j] f[i][j]表示区间 [ i , j ] [i,j] [i,j]中的元素全部合并所得到的最大数值
#include<iostream>
#include<algorithm>
using namespace std;
int n,a[250],f[250][250],ans;
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];f[i][i]=a[i];
	}
	for(int len=2;len<=n;len++){
		for(int i=1;i+len-1<=n;i++){
			int j=i+len-1;
			for(int k=i;k<j;k++){
				if(f[i][k]==f[k+1][j]){
					f[i][j]=max(f[i][j],f[i][k]+1);
					ans=max(ans,f[i][j]);
				}
			}
		}
	}
	cout<<ans<<endl;
}

P4170 [CQOI2007]涂色

f [ i ] [ j ] f[i][j] f[i][j]表示区间 [ i , j ] [i,j] [i,j]的最少涂色次数
f [ i ] [ j ] = { 1 , i = = j m i n ( f [ i + 1 ] [ j ] , f [ i ] [ j − 1 ] , s [ i ] = = s [ j ] m i n ( f [ i ] [ k ] + f [ k + 1 ] [ j ] ) , k ∈ [ i , j − 1 ] , s [ i ] ≠ s [ j ] f[i][j]=\left\{ \begin{aligned} 1,i==j\\ min(f[i+1][j],f[i][j-1],s[i]==s[j] \\ min(f[i][k]+f[k+1][j]),k\in[i,j-1],s[i]\neq s[j] \end{aligned} \right. f[i][j]=⎩⎪⎨⎪⎧​1,i==jmin(f[i+1][j],f[i][j−1],s[i]==s[j]min(f[i][k]+f[k+1][j]),k∈[i,j−1],s[i]​=s[j]​

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
string s;
int n,f[60][60],inf=1e9;
int main(){
	cin>>s;n=s.length();s.insert(0," ");
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			f[i][j]=inf;
		}
	} 
	for(int i=1;i<=n;i++){
		f[i][i]=1;
	}
	for(int len=2;len<=n;len++){
		for(int i=1;i+len-1<=n;i++){
			int j=i+len-1;			
			if(s[i]==s[j]) f[i][j]=min(f[i+1][j],f[i][j-1]);
			else{
				for(int k=i;k<j;k++){
					f[i][j]=min(f[i][j],f[i][k]+f[k+1][j]);
				}
			}
		}
	}
	cout<<f[1][n]<<endl;
}

CF607B Zuma

  • f [ i ] [ j ] f[i][j] f[i][j]表示区间 [ i , j ] [i,j] [i,j]的最少合并时间
  • f [ i ] [ j ] = { f [ i + 1 ] [ j − 1 ] , a [ i ] = = a [ j ] m i n ( f [ i ] [ j ] , f [ i ] [ k ] + f [ k + 1 ] [ j ] ) f[i][j]=\left\{ \begin{aligned} f[i+1][j-1],a[i]==a[j]\\ min(f[i][j],f[i][k]+f[k+1][j]) \end{aligned} \right. f[i][j]={f[i+1][j−1],a[i]==a[j]min(f[i][j],f[i][k]+f[k+1][j])​
  • 初始化 f [ i ] [ i ] = 1 f[i][i]=1 f[i][i]=1, f [ i ] [ i + 1 ] = { 1 , a [ i ] = = a [ i + 1 ] 2 , a [ i ] ≠ a [ i + 1 ] f[i][i+1]=\left\{ \begin{aligned} 1,a[i]==a[i+1]\\ 2,a[i]\neq a[i+1] \end{aligned} \right. f[i][i+1]={1,a[i]==a[i+1]2,a[i]​=a[i+1]​
#include<iostream>
#include<algorithm>
using namespace std;
int n,a[600],f[600][600],inf=2e9;
void init(){
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			f[i][j]=inf;
		}
	}
	for(int i=1;i<=n;i++){
		f[i][i]=1;	
	}
	for(int i=1;i<n;i++){
		if(a[i]==a[i+1]) f[i][i+1]=1;
		else f[i][i+1]=2;
	}		
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++) cin>>a[i];
	init();
	for(int len=3;len<=n;len++){
		for(int i=1;i+len-1<=n;i++){
			int j=i+len-1;
			if(a[i]==a[j]) f[i][j]=f[i+1][j-1];
			for(int k=i;k<j;k++)
				f[i][j]=min(f[i][j],f[i][k]+f[k+1][j]);						
		}
	}
	cout<<f[1][n]<<endl;
}
Catmull
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
动态规划之环形处理
qq_42376883的博客
06-17 564
在许多环形结构的问题中，我们都能通过枚举法，选择一个位置把环断开，变成线性结构从而进行求解，但是往往这种枚举的方式时间复杂度比较大，所以在动态规划问题中往往用二次DP法，断环为链法来避免枚举...
区间&环形动态规划
jiahonghao2002的博客
02-20 517
区间&环形动态规划 区间动态规划 主要思路：定义数组dp[i][j]dp[i][j]dp[i][j]为子区间[i,j][i,j][i,j]的最优解，然后建立动态规划方程，枚举的变量一般为距离，也就是j−i+1j-i+1j−i+1。 例题待补充。 环形动态规划 主要思路：定义数组dp[i][j]dp[i][j]dp[i][j]为子区间[i,j][i,j][i,j]的最优解，然后建立动态规划方程，枚举的变量一般为距离，也就是j−i+1j-i+1j−i+1。与区间动态规划不同的是，通常将一个环剪开变成一个
洛谷题单【动态规划3】区间与环形动态规划
Tracy_yi的博客
09-12 334
【动态规划3】区间与环形动态规划
环形结构上的动态规划问题的基本处理方式
hnjzsyjyj的专栏
09-02 1086
环形结构上的动态规划问题，是一种特殊的区间动态规划问题。由于存在“环形后效性”，所以不满足动态规划算法的“无后效性”约束条件。故常将环形结构上的动态规划问题，通过“断环为链”策略转化为线性动态规划问题求解。所谓“无后效性”，即“未来与过去无关”。所谓“断环为链”策略，即“把环断开为链，然后复制一倍接在末尾”。示意图如下： ...
动态规划——石子合并（区间与环形动态规划）
linjiayina的博客
10-09 260
题目链接 题目描述 在一个圆形操场的四周摆放 N 堆石子,现要将石子有次序地合并成一堆.规定每次只能选相邻的 2 堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。 试设计出一个算法,计算出将 N 堆石子合并成 1 堆的最小得分和最大得分。 输入格式 数据的第 1 行是正整数 N，表示有 N 堆石子。 第 2 行有 N 个整数，第 i 个整数 ai 表示第 i 堆石子的个数。 输出格式 输出共 2 行，第 1 行为最小得分，第 2 行为最大得分。 输入输出样例 输入 4 4 5 9 4 输出 43
动态规划的一些简单问题课件
11-02
动态规划初步，包括引入，01背包，分组背包，完全背包，线性dp，树形dp，区间dp，环形dp
动态规划解石子合并问题
04-25
动态规划解石子合并问题，其中石子呈环形排列。源程序为c++代码。
语音识别动态分配内存空间--环形buffer
07-10
本算法用于导航语音识别功能，创建一个内存池，接收A模块的发过来的语音数据，再被动被B模块读取语音数据，可以动态分配环形buffer，保证读写数据线程互不干扰，且不需要加锁操作，算法精简高效。
双归属环形网络拓扑规划算法设计
01-19
本文研究了一种高效的双归属环形网络拓扑规划算法，提出了在满环与非满环间调整节点的启发式搜索算法，当节点数在1 500个以内时，本算法都能很快求解，而现有算法通常只能处理几百个节点的中等规模网络。本文首先给...
echart 3D环形图 动画效果
12-18
利用echart实现的3D环形图表，底部带有动画效果
石子合并 动态规划（环形）
Fisher的博客
12-04 4966
1、问题描述：问题来源 NWPU noj 1148 在一个圆形操场的四周摆放着n堆石子(n 4 4 5 9 score: 0 8 5 9 score: 8 13 9 score: 8 + 13 = 21 22 score: 8 + 13 + 22 = 43 2、输入 可能有多组测试数据。 当输入n=0时结束! 第一行为石子堆数n(1 3、输出 合并的最
Vijos P1218 数字游戏（动态规划，环形DP）
qq_35855297的博客
08-24 1602
环状DP，都要用到破环为链，其实很多方法都是相通的
环形石子合并问题（动态规划）（洛谷P1880）
sortmin的博客
04-17 5307
                    环形石子合并问题（动态规划）传统的石子合并问题为：有N堆石子，现要将石子有序的合并成一堆，规定如下：每次只能移动相邻的2堆石子合并，合并花费为新合成的一堆石子的数量，求将这N堆石子合并成一堆的总花费最小（或最大）。这类问题类似区间DP的解法，设dp[i][j]为合并从i到j的最小总花费，那么预处理出前缀和，转移方程为dp[i][j]=max(dp[i][k]...
动态规划经典问题
yangchuankai's blog
09-04 4398
动态规划经典问题 目录 一、最长公共子序列O(mn) 二、最优排序二叉树O(n3) 三、最长上升子序列O(nlogn) 四、最优三角剖分O(n3) 五、最大m子段和O(mn) 六、0-1背包问题O(min{nc, 2n, n1.44n}) 七、最优排序二叉树O(n2) 八、最优合并问题O(nlogn) 一、最长公共子序列 Longest Common Su
环形m段最大子段和 题解动态规划DP
魔神翼
09-02 2928
http://acm.hunnu.edu.cn/online/?action=problem&type=show&id=10581环形m段最大子段和Time Limit: 5000ms, Special Time Limit:15000ms, Memory Limit:65536KB Total submit users: 3, Accepted users: 3 Problem 10581 : No special judgementProblem description  我想你已经做出了一维的最大子段
环形结构上的动态规划问题的两种基本处理方式：
_Griefs
08-24 509
一、 执行两次DP，第一次在任意位置把环断开成链，按照线性问题求解。 第二次通过适当的条件和赋值，保证计算的状态等价于把断开的位置强制相连。 Naptime POJ - 2228： Goneril is a very sleep-deprived cow. Her day is partitioned into N (3 <= N <= 3,830) equal time period...
[poj 2228][tyvj1963] Naptime｛环形结构动态规划｝
Nowed
08-20 299
题目 http://www.joyoi.cn/problem/tyvj-1963 http://poj.org/problem?id=2228 解题思路 代码 #include&amp;amp;lt;cstdio&amp;amp;gt; #include&amp;amp;lt;cstring&amp;amp;gt; #include&amp;amp;lt;algorithm&amp;amp;gt;
简单动态规划—断环成链
Logan
05-20 707
f[i][k]表示第i人传球k次  的方法数。特殊处理边界数据#include&lt;stdio.h&gt; int f[99][99]; int main() { int i,k,n,m; scanf("%d%d",&amp;n,&amp;m); f[1][0]=1; for(k=1;k&lt;=m;k++) { f[1][k]=f[2][...
动态规划的介绍
ZSS1753936255的博客
08-16 803
动态规划就是一种用来解决最优化问题的算法思想。简单来说，动态规划将一个复杂的问题分解成若干个子问题，通过综合子问题的最优解来得到原问题的最优解。需要注意的是，动态规划会将每个求解的子问题的解都记录下来。这样当下次碰到同样的子问题的时候 ，直接使用之前记录的结果。而不是重复计算。      动态递归的递归写法 先来讲解递归写法。通过这部分内容的学习，就是为了让我理解如何记录子问题的解，来避免下...
环形石子合并问题动态规划思路
最新发布
01-05
环形石子合并问题可以使用动态规划来解决。下面是解决该问题的动态规划思路： 1. 定义状态：设dp[i][j]表示合并第i堆到第j堆石子所能得到的最小得分和最大得分。 2. 状态转移方程：对于dp[i][j]，可以考虑最后一次...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值