【集训队作业】IOI 2020 集训队作业 试题泛做 12

最新推荐文章于 2022-07-19 13:51:14 发布
最新推荐文章于 2022-07-19 13:51:14 发布
阅读量476 收藏 1
点赞数
分类专栏： 【OJ】CodeForces 【类型】做题记录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39972971/article/details/104033519
版权
这篇博客详细解析了IOI 2020集训队作业中的多个Codeforces竞赛题目，包括Orchestra、Bear and Paradox、Bear and Chemistry等，涉及动态规划、图论和数据结构等算法，介绍了如何在不同场景下优化算法以达到高效解决方案，如利用平衡树、链表、后缀树等数据结构。
摘要由CSDN通过智能技术生成

Codeforces 634F Orchestra

若枚举矩形的上下边界，则问题显然可以 O ( n ) O(n) O(n) 解决。

那么，考虑枚举矩形的上边界，再从上到下枚举矩形的下边界，则我们需要一边插入点，一边动态维护上面问题的答案。若直接实现，需要使用平衡树。

事实上，我们可以从下到上枚举矩形的下边界，则只需要链表就可以维护了。

时间复杂度 O ( r 2 + r n k ) O(r^2+rnk) O(r2+rnk) 。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3005;
typedef long long ll;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
int r, c, n, k, home[MAXN];
int x[MAXN], y[MAXN], pre[MAXN], nxt[MAXN];
vector <int> a[MAXN];
bool cmp(int a, int b) {
	return y[a] < y[b];
}
int main() {
	read(r), read(c), read(n), read(k);
	for (int i = 1; i <= n; i++) {
		read(x[i]), read(y[i]), home[i] = i;
		a[x[i]].push_back(i);
	}
	y[n + 1] = 0, y[n + 2] = c + 1;
	sort(home + 1, home + n + 1, cmp);
	home[0] = n + 1, home[n + 1] = n + 2;
	ll ans = r * (r + 1ll) * c * (c + 1ll) / 4;
	for (int p = 1; p <= r; p++) {
		for (int i = 1; i <= n + 1; i++) {
			pre[home[i]] = home[i - 1];
			nxt[home[i - 1]] = home[i];
		}
		ll sum = 0;
		for (int i = n + 1; i != n + 2; i = nxt[i]) {
			int len = y[nxt[i]] - y[i];
			sum += (len - 1ll) * len / 2;
			for (int j = nxt[i], cnt = 1; j != n + 2 && cnt <= k - 1; j = nxt[j], cnt++)
				sum += len * (y[nxt[j]] - y[j]);
		}
		pre[n + 1] = n + 1, nxt[n + 2] = n + 2;
		for (int i = 1; i <= p - 1; i++) {
			for (auto x : a[i]) {
				int pos = x;
				for (int j = 1; j <= k; j++)
					pos = pre[pos];
				int qos = pos;
				for (int j = 1; j <= k; j++)
					qos = nxt[qos];
				while (pos != x && qos != n + 2) {
					sum += (y[nxt[pos]] - y[pos]) * (y[nxt[qos]] - y[qos]);
					pos = nxt[pos];
					qos = nxt[qos];
				}
				int p = pre[x], s = nxt[x];
				nxt[p] = s, pre[s] = p;
			}
		}
		for (int i = r; i >= p; i--) {
			ans -= sum;
			for (auto x : a[i]) {
				int pos = x;
				for (int j = 1; j <= k; j++)
					pos = pre[pos];
				int qos = pos;
				for (int j = 1; j <= k; j++)
					qos = nxt[qos];
				while (pos != x && qos != n + 2) {
					sum += (y[nxt[pos]] - y[pos]) * (y[nxt[qos]] - y[qos]);
					pos = nxt[pos];
					qos = nxt[qos];
				}
				int p = pre[x], s = nxt[x];
				nxt[p] = s, pre[s] = p;
			}
		}
	}
	cout << ans << endl;
	return 0;
}

Codeforces 639E Bear and Paradox

考虑确定最优策略，由调整法，可以证明， i i i 应当排在 j j j 之前当且仅当 p j t i < p i t j p_jt_i<p_it_j pj​ti​<pi​tj​ ；而对于 p j t i = p i t j p_jt_i=p_it_j pj​ti​=pi​tj​ ， i , j i,j i,j 的顺序是任意的。

那么，二分答案，考虑判断答案 c c c 是否合法。

则要求对于分数 x , y   ( x < y ) x,y\ (x<y) x,y (x<y) ，分数为 x x x 的题目可能的最大分数不超过分数为 y y y 的题目的最小分数，不难发现只要检查相邻的分数之间的偏序关系就可以了。

时间复杂度 O ( N L o g V ) O(NLogV) O(NLogV) 。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const double eps = 1e-10;
typedef long long ll;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
double sumt, pre[MAXN]; int Min[MAXN], Max[MAXN];
int n, a[MAXN], b[MAXN], p[MAXN], t[MAXN];
bool cmp(int x, int y) {
	return p[x] < p[y];
}
bool cnp(int x, int y) {
	return 1ll * t[x] * p[y] < 1ll * t[y] * p[x];
}
bool check(double c) {
	double last;
	for (int i = 1, nxt; i <= n; i = nxt + 1) {
		nxt = i; while (nxt + 1 <= n && p[b[i]] == p[b[nxt + 1]]) nxt++;
		if (i != 1) {
			for (int j = i; j <= nxt; j++) {
				double cur = p[b[j]] * (1 - c * pre[Max[b[j]]] / sumt);
				if (cur < last) return false;
			}
		}
		last = 0;
		for (int j = i; j <= nxt; j++)
			chkmax(last, p[b[j]] * (1 - c * (pre[Min[b[j]] - 1] + t[b[j]]) / sumt));
	}
	return true;
}
int main() {
	read(n);
	for (int i = 1; i <= n; i++)
		a[i] = b[i] = i;
	for (int i = 1; i <= n; i++)
		read(p[i]);
	for (int i = 1; i <= n; i++)
		read(t[i]), sumt += t[i];
	sort(a + 1, a + n + 1, cnp);
	sort(b + 1, b + n + 1, cmp);
	for (int i = 1; i <= n; i++)
		pre[i] = pre[i - 1] + t[a[i]];
	for (int i = 1, nxt; i <= n; i = nxt + 1) {
		nxt = i; while (nxt + 1 <= n && 1ll * p[a[i]] * t[a[nxt + 1]] == 1ll * t[a[i]] * p[a[nxt + 1]]) nxt++;
		for (int j = i; j <= nxt; j++) {
			Min[a[j]] = i;
			Max[a[j]] = nxt;
		}
	}
	double l = 0, r = 1;
	while (l + eps < r) {
		double mid = (l + r) / 2;
		if (check(mid)) l = mid;
		else r = mid;
	}
	printf("%.10lf\n", (l + r) / 2);
	return 0;
}

Codeforces 639F Bear and Chemistry

首先，题目的要求等价于给定的点集在同一边双连通分量内。

将给定的原图缩点，则剩余部分是一片森林。

对于每个询问，将涉及到的点取出，建立虚树，再在虚树上运行 Tarjan 计算答案即可。

时间复杂度 O ( N + M + ∑ ( n i + m i ) L o g N ) O(N+M+\sum(n_i+m_i)LogN) O(N+M+∑(ni​+mi​)LogN) 。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
const int MAXLOG = 20;
typedef long long ll;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
vector <int> a[MAXN], b[MAXN], c[MAXN], d[MAXN];
int n, m, q, f[MAXN], x[MAXN], y[MAXN];
int father[MAXN][MAXLOG], depth[MAXN];
int timer, dfn[MAXN], cnt, num[MAXN];

bool instack[MAXN]; ll online;
int Timer, Dfn[MAXN], Low[MAXN];
int top, Stack[MAXN], tot, belong[MAXN];
void tarjan(int pos, int fa) {
	Low[pos] = Dfn[pos] = ++Timer;
	Stack[++top] = pos;
	instack[pos] = true;
	for (unsigned i = 0; i < c[pos].size(); i++) {
		if (d[pos][i] == fa) continue;
		if (Dfn[c[pos][i]] == 0) {
			tarjan(c[pos][i], d[pos][i]);
			Low[pos] = min(Low[pos], Low[c[pos][i]]);
		} else if (instack[c[pos][i]]) Low[pos] = min(Low[pos], Dfn[c[pos][i]]);
	}
	if (Low[pos] == Dfn[pos]) {
		int tmp = Stack[top--];
		belong[tmp] = ++tot;
		instack[tmp] = false;
		while (tmp != pos) {
			tmp = Stack[top--];
			belong[tmp] = tot;
			instack[tmp] = false;
		}
	}
}

int find(int x) {
	if (f[x] == x) return x;
	else return f[x] = find(f[x]);
}
int lca(int x, int y) {
	if (depth[x] < depth[y]) swap(x, y);
	for (int i = MAXLOG - 1; i >= 0; i--)
		if (depth[father[x][i]] >= depth[y]) x = father[x][i];
	if (x == y) return x;
	for (int i = MAXLOG - 1; i >= 0; i--)
		if (father[x][i] != father[y][i]) {
			x = father[x][i];
			y = father[y][i];
		}
	return father[x][0];
}
void addedge(int x, int y) {
	static int ind = 0; ind++;
	c[x].push_back(y);
	d[x].push_back(ind);
	c[y].push_back(x);
	d[y].push_back(ind);
}
inline int func(int x) {
	x = (x + online) % n;
	if (x == 0) x = n;
	return x;
}
void solve(int task) {
	static int vis[MAXN], points[MAXN];
	static int pos[MAXN], x[MAXN], y[MAXN];
	int n, m, cnt = 0; read(n), read(m);
	auto mark = [&] (int x) {
		if (vis[x] != task) {
			vis[x] = task;
			points[++cnt] = x;
		}
		if (vis[num[x]] != task) {
			vis[num[x]] = task;
			points[++cnt] = num[x];
		}
	};
	for (int i = 1; i <= n; i++) {
		read(pos[i]), pos[i] = func(pos[i]);
		mark(pos[i] = find(pos[i]));
	}
	for (int i = 1; i <= m; i++) {
		read(x[i]), read(y[i]);
		x[i] = func(x[i]);
		y[i] = func(y[i]);
		mark(x[i] = find(x[i]));
		mark(y[i] = find(y[i]));
	}
	sort(points + 1, points + cnt + 1, [&] (int x, int y) {return dfn[x] < dfn[y];});
	int top = 0, cmt = cnt; static int Stack[MAXN];
	for (int i = 1; i <= cnt; i++) {
		int x = points[i];
		if (num[points[i - 1]] != num[points[i]]) {
			while (top >= 2) {
				addedge(Stack[top], Stack[top - 1]);
				top--;
			}
			Stack[top = 1] = x;
		} else {
			while (top >= 2 && depth[lca(x, Stack[top])] <= depth[Stack[top - 1]]) {
				addedge(Stack[top], Stack[top - 1]);
				top--;
			}
			if (lca(x, Stack[top]) == Stack[top]) Stack[++top] = x;
			else {
				int y = lca(x, Stack[top]);
				points[++cmt] = y;
				addedge(Stack[top], y);
				Stack[top] = y;
				Stack[++top] = x;
			}
		}
	}
	while (top >= 2) {
		addedge(Stack[top], Stack[top - 1]);
		top--;
	}
	for (int i = 1; i <= m; i++)
		addedge(x[i], y[i]);
	for (int i = 1; i <= cnt; i++)
		if (Dfn[points[i]] == 0) tarjan(points[i], 0);
	bool ans = true;
	for (int i = 1; i <= n; i++)
		ans &= belong[pos[i]] == belong[pos[1]];
	if (ans) puts("YES"), online += task;
	else puts("NO");
	
	tot = Timer = 0;
	for (int i = 1; i <= cmt; i++) {
		c[points[i]].clear();
		d[points[i]].clear();
		Dfn[points[i]] = 0;
	}
}
void dfs(int pos, int fa) {
	father[pos][0] = fa;
	depth[pos] = depth[fa] + 1;
	for (auto x : a[pos])
		if (x != fa) dfs(x, pos);
}
void work(int pos, int fa, int cur) {
	depth[pos] = depth[fa] + 1;
	father[pos][0] = fa;
	dfn[pos] = ++timer, num[pos] = cur;
	for (int i = 1; i < MAXLOG; i++)
		father[pos][i] = father[father[pos][i - 1]][i - 1];
	for (unsigned i = 0; i < b[pos].size(); i++)
		if (b[pos][i] != fa) work(b[pos][i], pos, cur);
}
int main() {
	read(n), read(m), read(q);
	for (int i = 1; i <= n; i++)
		f[i] = i;
	static bool non[MAXN];
	for (int i = 1; i <= m; i++) {
		read(x[i]), read(y[i]);
		int tx = find(x[i]);
		int ty = find(y[i]);
		if (tx == ty) non[i] = true;
		else {
			f[tx] = ty;
			a[x[i]].push_back(y[i]);
			a[y[i]].push_back(x[i]);
		}
	}
	for (int i = 1; i <= n; i++)
		f[i] = i;
	for (int i = 1; i <= n; i++)
		if (father[i][0] == 0) dfs(i, 0);
	for (int i = 1; i <= m; i++)
		if (non[i]) {
			int tx = find(x[i]), ty = find(y[i]);
			while (tx != ty) {
				if (depth[tx] < depth[ty]) swap(tx, ty);
				f[tx] = find(father[tx][0]), tx = find(tx);
			}
		}
	for (int i = 1; i <= n; i++)
	for (auto x : a[i]) if (find(i) != find(x)) b[find(i)].push_back(find(x));
	for (int i = 1; i <= n; i++)
		if (find(i) == i && dfn[i] == 0) {
			work(i, 0, i);
		}
	for (int i = 1; i <= q; i++)
		solve(i);
	return 0;
}

Codeforces 666D Chain Reaction

首先枚举各个机器人与正方形的四个角落的对应关系。

若四个机器人移动的横竖方向一致，则我们可以确定正方形的边长 L L L ，问题即为给定 a 1 , a 2 , a 3 , a 4 a_1,a_2,a_3,a_4 a1​,a2​,a3​,a4​ ，选取 x x x ，最小化 m a x { ∣ a i + [ i ≤ 2 ] L − x ∣ } max\{|a_i+[i\leq 2]L-x|\} max{ ∣ai​+[i≤2]L−x∣} 。
令 a 1 = a 1 + L , a 2 = a 2 + L a_1=a_1+L,a_2=a_2+L a1​

最低0.47元/天 解锁文章
cz_xuyixuan
关注
专栏目录
IOI国家集训队论文集
11-17
包括IOI中国国家集训队从1999年到2017年的论文 部分目录： 国家集训队1999论文集 陈宏：《数据结构的选择与算法效率——从IOI98试题PICTURE谈起》 来煜坤：《把握本质，灵活运用——动态规划的深入探讨》 齐鑫：...
#USACO2020铜级赛第三题暴力解法记录一下
weixin_46671186的博客
07-28 947
哈哈
第九天作业：
youraiai的博客
07-19 301
第九天作业
Problem : [Usaco2010 Nov]Race Results
Zhao_Chongyan的博客
01-31 314
Problem : [Usaco2010 Nov]Race Results Time Limit: 1 Sec Memory Limit: 128 MB Description 奶牛们成功的举行了第一届马拉松大赛!!! 这里有N(1&lt;=N&lt;=5000)只奶牛的成绩,每一个成绩用三个整数表示, 即小时数(0 &lt;= 小时数 &lt;= 99)分钟数(0 &lt;= 分钟数 &lt;...
usaco--race3
WoniuGe
12-30 495
木有参考题解，第一问蛮简单的，数据小，暴力过。 第二问看了题解也还是不明白，就自己想了，参考刘汝佳求无向图割点的pre数组，只不过这道题的pre数组用宽搜求出，至于为什么，哥给不出证明，只能在脑袋里想想是对的，这种感觉很无奈的。 枚举第一问得到的答案的每个点，假设这个点是C（不明白指代的看代码），从C点开始往下深搜，如果又搜回到了C点，而且中途经过的点最小pre值小于C点的pre值，C点就不是
USACO race3
weixin_30808693的博客
01-28 81
　　这个题的第一问的意思是让你求出从0 走到 N必须走的点集的集合， 第二问的意识是判断被一个点分开的两个子图有没有公共边， 对于第一问我们去掉i后如果发现无法从0走向N那么i就是要求得点， 第二问可以用种子填充， 如果发现有一些点被染到了两种颜色那么这个点就是不满足条件的点。代码如下： /* ID: m1500293 LANG: C++ PROG: ...
IOI国家集训队论文1999-2021(缺2020)-2021.08.03.rar
08-03
标题中的“IOI国家集训队论文1999-2021(缺2020)-2021.08.03.rar”指的是一个包含国际奥林匹克信息学竞赛（IOI）国家集训队从1999年至2021年（除了2020年）论文的压缩文件，该文件于2021年8月3日更新。这些论文通常...
ioi2018集训队作业1
12-26
希望喜欢算法的童鞋一起学习大佬们的思维。IOI是国际信息学奥林匹克竞赛，此文档是中国IOI2018集训队的作业题。
IOI2020中国国家候选队论文集 非正式版1
08-03
【标题】：“IOI2020中国国家候选队论文集 非正式版1” 【描述】：本文主要探讨了分散层叠算法在优化经典分块问题中的应用，这是一种加速多序列二分查找的技术。 【部分内容】：分散层叠算法，又称为Fractional ...
国家集训队2019论文集_国家集训队2019论文集pdf_国家集训队2019_
10-03
《国家集训队2019论文集》是汇集了2019年度我国信息技术领域国家集训队成员的研究成果的珍贵文献。这份PDF文档包含了众多高质量的技术论文，旨在展示国内顶尖IT人才在人工智能、大数据、云计算、网络安全、物联网、...
编程序实现设有10个学生的成绩分别为85、62、64、79、82、99、100、78、88、86，试编制一个子程序统计60~69分，70~79分 ,80~89分，90~99分及100分的人数，分别存放到S6,S7,S8,S9及S10单元中。
03-13
编程序实现设有10个学生的成绩分别为85、62、64、79、82、99、100、78、88、86，试编制一个子程序统计60~69分，70~79分 ,80~89分，90~99分及100分的人数，分别存放到S6,S7,S8,S9及S10单元中。
USACO 2020年1月铜级比赛题解报告
小树学信奥
02-19 2225
T1 Word Processor 题目 http://www.usaco.org/index.php?page=viewproblem2&cpid=987 分析 判断每一行加上新单词后的长度（空格不计算在长度之内），若加上新单词后长度超过K，则新单词要另起一行。注意每行的最后一个单词右边不能有空格。 AC代码 #include <iostream> #include <...
USACO算法系列三十五——race3
止于至善
12-31 474
<br />      题目：http://www.nocow.cn/index.php/Translate:USACO/race3<br />     寻找从起点s到达终点t的必经路径。和寻找中间点，中间点满足后半段路程不能回到前半段路程。<br />     必经节点，假设节点不存在，如果能从s点走到t，则不是必经路径，否则是。<br />     中间点，前半段走到中间点，所有点标为RED，从中间点走到t点，所有节点标为BLUE，如果出现BLUE覆盖RED，则不是中间点。<br />     采用的都
【比赛】USACO 20 Dec
qq_35739643的博客
12-23 1019
USACO 20 DEC游记 文章目录USACO 20 DEC游记BronzeA.Do You Know Your ABCs?B. Daisy ChainsC.Stuck in a RutSilverA.CowntagionB.Rectangular PastureC.Stuck in a RutGoldA.Replication碎碎念 目前只有本人考场ac的题目，其他会随后补上 Bronze A.Do You Know Your ABCs? 简单题 发现七个数加和正好是4(A+B+C)4(A+B+C)4(
USACO 2020 US Open Platinum 题解
ohweonfire的博客
03-31 1452
A 可以发现只要轮廓线是递减的，并且角上被选中即可，其他的位置都可选可不选。于是可以简单地dp这个轮廓线，从左上方每次向右或向下走即可，复杂度 O(n2)O(n^2)O(n2) 。 B 显然一个排列的答案是环长的LCM。由于是求乘积，可以把每个质因子 ppp 分开考虑，于是我们相当于要对所有排列对应的环长 l1,⋯lkl_1,\cdots l_kl1​,⋯lk​ 求 $\max ord_p(l_i...
USACO 2019 December Contest, Silver 题解
帅比王的博客
12-17 2164
1.MooBuzz Description Farmer John 的奶牛们最近成为了一个简单的数字游戏“FizzBuzz”的狂热玩家。这个游戏的规则很简单：奶牛们站成一圈，依次从一开始报数，每头奶牛在轮到她的时候报一个数。如果一头奶牛将要报的数字是 3 的倍数，她应当报“Fizz”来代替这个数。如果一头奶牛将要报的数字是 5 的倍数，她应当报“Buzz”来代替这个数。如果一头奶牛将要报的数字是 ...
USACO 2020~2021 February Contest GOLD 题解(1)
Layomiiety的博客
03-07 974
USACO 2020~2021 三月黄金组 题解（1）1. Stone Game 1. Stone Game Bessie and Elsie are playing a game with N (1≤N≤105) piles of stones, where the i-th pile has ai stones for each 1≤i≤N (1≤ai≤106). The two cows alternate turns, with Bessie going first. First, Bessie
[USACO2020Dec铜组第二题] 雏菊(Daisy Chains)
ycy的博客
12-25 1436
题目描述 每天，作为她绕农场行走的一部分，奶牛 Bessie 会经过她最喜爱的草地，其中种有 N 朵花（五颜六色的雏菊），编号为 1…N（1≤N≤100），排列成一行。花 i 有 pi 朵花瓣（1≤pi≤1000）。 作为一名崭露头角的摄影家，Bessie 决定给这些花拍些照片。具体地说，对于每一对满足 1≤i≤j≤N 的花 (i,j)，Bessie 会给从花 i 到花 j 之间的所有花（包括 i 和 j）拍一张照。 后来 Bessie 查看这些照片时注意到有些照片里存在「平均」的花——一朵恰好有 P 朵.
【SSL 1119】【USACO 2.4 】牛的旅行【最短路 FLoyed】
ssllyr
01-17 266
Description 农民John的农场里有很多牧区。有的路径连接一些特定的牧区。一片所有连通的牧区称为一个牧场。但是就目前而言，你能看到至少有两个牧区不连通。这样，农民John就有多个牧区了。 　　John想在农场里添加一条路径(注意，恰好一条)。对这条路径有以下限制： 　　一个牧场的直径就是牧场中最远的两个牧区的距离(本题中所提到的所有距离指的都是最短的距离)。考虑如下的有5个牧区的牧场，牧...
IOI2015中国集训队：算法准备与泛做任务详解
IOI2015中国国家集训队第一次作业旨在提升参赛选手的算法技能和竞赛准备能力。作业分为两个部分，分别是试题准备和试题泛做。 第一部分：试题准备（截止日期11月10日） 1. 任务要求：每位选手需翻译三道题目，包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值