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

最新推荐文章于 2021-02-23 18:54:43 发布
最新推荐文章于 2021-02-23 18:54:43 发布
阅读量846 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 【类型】做题记录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39972971/article/details/103709069
本文详细分析了IOI集训队在Atcoder Grand Contest系列中的多道算法题目，包括Choosing Points、Walking on a Tree、Addition and Andition等，涉及图论、二分图染色、树的遍历、高精度运算等多个算法知识点，提供了解题思路和复杂度分析。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Atcoder Grand Contest 25

Problem D. Choosing Points

考虑对于给定点集 SSS 和输入 D1,D2D_1,D_2D1​,D2​ ，计算一个大小不小于 S4\frac{S}{4}4S​ 的独立集 work(S,D1,D2)work(S,D_1,D_2)work(S,D1​,D2​) 。

对于 D1,D2D_1,D_2D1​,D2​ 均为奇数的情况，可以直接对点集二分图染色。

对于 D1,D2D_1,D_2D1​,D2​ 存在一个奇数的情况，不妨设为 D1D_1D1​ ，可以对点集二分图染色，对得到的两个新点集 A,BA,BA,B 重新计算 work(A,D2),work(B,D2)work(A,D_2),work(B,D_2)work(A,D2​),work(B,D2​) ，取较大者。

对于 D1,D2D_1,D_2D1​,D2​ 存在一个模 444 余 222 的数的情况，不妨设为 D1D_1D1​ ，则 D1D_1D1​ 必定是两个奇数的平方和，同样可以对点集进行条纹染色，对得到的两个新点集 A,BA,BA,B 重新计算 work(A,D2),work(B,D2)work(A,D_2),work(B,D_2)work(A,D2​),work(B,D2​) ，取较大者。

否则，即 D1,D2D_1,D_2D1​,D2​ 均为 444 的倍数，可以将点集分为四份，分别计算 work(T,D12,D22)work(T,\frac{D_1}{2},\frac{D_2}{2})work(T,2D1​​,2D2​​) ，合并得到的点集即可。

时间复杂度 O(N2LogN)O(N^2LogN)O(N2LogN) 。

实际上，通过上述过程，我们也可以发现对于单独的 DDD ，得到的图是一张二分图，因此，对 D1,D2D_1,D_2D1​,D2​ 分别二分图染色，取四份中较大的一份即可。

时间复杂度 O(N3)O(N^3)O(N3) 。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
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;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
vector <pair <int, int>> work(vector <pair <int, int>> input, int a) {
	if (input.size() <= 1) return input;
	vector <pair <int, int>> ans;
	if (a % 2) {
		int cnt[2] = {0, 0};
		for (auto x : input) cnt[(x.first + x.second) & 1]++;
		int home = cnt[0] > cnt[1] ? 0 : 1;
		for (auto x : input) if ((x.first + x.second) % 2 == home) ans.push_back(x);
		return ans;
	}
	if (a % 4) {
		int cnt[2] = {0, 0};
		for (auto x : input) cnt[x.first & 1]++;
		int home = cnt[0] > cnt[1] ? 0 : 1;
		for (auto x : input) if (x.first % 2 == home) ans.push_back(x);
		return ans;
	}
	vector <pair <int, int>> nxt, tmp;
	nxt.clear(); for (auto x : input) if (x.first % 2 == 0 && x.second % 2 == 0) nxt.emplace_back(x.first / 2, x.second / 2);
	tmp = work(nxt, a / 4); for (auto x : tmp) ans.emplace_back(x.first * 2, x.second * 2);
	nxt.clear(); for (auto x : input) if (x.first % 2 == 0 && x.second % 2 == 1) nxt.emplace_back(x.first / 2, x.second / 2);
	tmp = work(nxt, a / 4); for (auto x : tmp) ans.emplace_back(x.first * 2, x.second * 2 + 1);
	nxt.clear(); for (auto x : input) if (x.first % 2 == 1 && x.second % 2 == 0) nxt.emplace_back(x.first / 2, x.second / 2);
	tmp = work(nxt, a / 4); for (auto x : tmp) ans.emplace_back(x.first * 2 + 1, x.second * 2);
	nxt.clear(); for (auto x : input) if (x.first % 2 == 1 && x.second % 2 == 1) nxt.emplace_back(x.first / 2, x.second / 2);
	tmp = work(nxt, a / 4); for (auto x : tmp) ans.emplace_back(x.first * 2 + 1, x.second * 2 + 1);
	return ans;
}
vector <pair <int, int>> work(vector <pair <int, int>> input, int a, int b) {
	if (input.size() <= 1) return input;
	vector <pair <int, int>> ans;
	if (a % 2 && b % 2) {
		int cnt[2] = {0, 0};
		for (auto x : input) cnt[(x.first + x.second) & 1]++;
		int home = cnt[0] > cnt[1] ? 0 : 1;
		for (auto x : input) if ((x.first + x.second) % 2 == home) ans.push_back(x);
		return ans;
	}
	if (a % 2) swap(a, b);
	if (b % 2) {
		vector <pair <int, int>> nxt1, nxt2;
		for (auto x : input) {
			if ((x.first + x.second) & 1) nxt1.push_back(x);
			else nxt2.push_back(x);
		}
		vector <pair <int, int>> tmp1 = work(nxt1, a);
		vector <pair <int, int>> tmp2 = work(nxt2, a);
		if (tmp1.size() > tmp2.size()) return tmp1;
		else return tmp2;
	}
	if (a % 4) swap(a, b);
	if (b % 4) {
		vector <pair <int, int>> nxt1, nxt2;
		for (auto x : input) {
			if (x.first & 1) nxt1.push_back(x);
			else nxt2.push_back(x);
		}
		vector <pair <int, int>> tmp1 = work(nxt1, a);
		vector <pair <int, int>> tmp2 = work(nxt2, a);
		if (tmp1.size() > tmp2.size()) return tmp1;
		else return tmp2;
	}
	vector <pair <int, int>> nxt, tmp;
	nxt.clear(); for (auto x : input) if (x.first % 2 == 0 && x.second % 2 == 0) nxt.emplace_back(x.first / 2, x.second / 2);
	tmp = work(nxt, a / 4, b / 4); for (auto x : tmp) ans.emplace_back(x.first * 2, x.second * 2);
	nxt.clear(); for (auto x : input) if (x.first % 2 == 0 && x.second % 2 == 1) nxt.emplace_back(x.first / 2, x.second / 2);
	tmp = work(nxt, a / 4, b / 4); for (auto x : tmp) ans.emplace_back(x.first * 2, x.second * 2 + 1);
	nxt.clear(); for (auto x : input) if (x.first % 2 == 1 && x.second % 2 == 0) nxt.emplace_back(x.first / 2, x.second / 2);
	tmp = work(nxt, a / 4, b / 4); for (auto x : tmp) ans.emplace_back(x.first * 2 + 1, x.second * 2);
	nxt.clear(); for (auto x : input) if (x.first % 2 == 1 && x.second % 2 == 1) nxt.emplace_back(x.first / 2, x.second / 2);
	tmp = work(nxt, a / 4, b / 4); for (auto x : tmp) ans.emplace_back(x.first * 2 + 1, x.second * 2 + 1);
	return ans;
}
int main() {
	int n, a, b; read(n), read(a), read(b);
	vector <pair <int, int>> input;
	for (int i = 0; i < n * 2; i++)
	for (int j = 0; j < n * 2; j++)
		input.emplace_back(i, j);
	vector <pair <int, int>> res = work(input, a, b); int cnt = 0;
	for (auto x : res) if (++cnt <= n * n) printf("%d %d\n", x.first, x.second);
	return 0;
}

Problem E. Walking on a Tree

显然，记 cic_ici​ 表示第 iii 条边被覆盖的次数，显然答案存在上界 ∑imin⁡{ ci,2}\sum_{i}\min\{c_i,2\}∑i​min{ ci​,2} 。

考虑构造方案取到该上界，对于叶子节点 iii ，令其父边被覆盖次数为 xxx 。
若 x≤1x\leq 1x≤1 ，显然，可以删去节点 iii 。

考虑 x≥2x\geq 2x≥2 的情况，任取两条覆盖该点的路径 (a,i),(i,b)(a,i),(i,b)(a,i),(i,b) 。
则若要使得 iii 被覆盖两次， (a,i),(i,b)(a,i),(i,b)(a,i),(i,b) 的方向必须不同。
考虑 (a,i),(i,b)(a,i),(i,b)(a,i),(i,b) 的交 (i,c)(i,c)(i,c) ， (i,c)(i,c)(i,c) 上的边都被覆盖了两次，在后续过程中都不需要继续考虑。
考虑 (i,c)(i,c)(i,c) 外的部分，可以发现 a→c,c→ba\rightarrow c,c\rightarrow ba→c,c→b 等价于 a→ba\rightarrow ba→b ，而 b→c,c→ab\rightarrow c,c\rightarrow ab→c,c→a 等价于 b→ab\rightarrow ab→a ，因此可以加入 (a,b)(a,b)(a,b) 代替上述两条路径参与后续计算。

由此，我们构造了一种方案。

时间复杂度 O(N×(N+M))O(N\times (N+M))O(N×(N+M)) 。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 5e3 + 5;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
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;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
vector <int> a[MAXN];
int depth[MAXN], father[MAXN];
int n, m, tot, ans, x[MAXN], y[MAXN];
bool used[MAXN], ok[MAXN], res[MAXN];
int nowx[MAXN], nowy[MAXN], f[MAXN], g[MAXN];
void dfs(int pos, int fa) {
	depth[pos] = depth[fa] + 1;
	father[pos] = fa;
	for (auto x : a[pos])
		if (x != fa) dfs(x, pos);
}
void mark(int a, int b, int c, int d) {
	static int cnt[MAXN];
	memset(cnt, 0, sizeof(cnt));
	while (a != b) {
		if (depth[a] < depth[b]) swap(a, b);
		cnt[a]++, a = father[a];
	}
	while (c != d) {
		if (depth[c] < depth[d]) swap(c, d);
		cnt[c]++, c = father[c];
	}
	for (int i = 1; i <= n; i++)
		ok[i] |= cnt[i] >= 2;
}
void work(int pos, int fa) {
	for (auto x : a[pos])
		if (x != fa) work(x, pos);
	if (pos != 1) {
		int cnt = 0;
		for (int i = 1; i <= tot; i++)
			if (!used[i]) cnt += (nowx[i] == pos) ^ (nowy[i] == pos);
		ans += min(max(cnt, ok[pos] * 2), 2);
		if (cnt <= 1 || ok[pos]) {
			for (int i = 1; i <= tot; i++)
				if (!used[i]) {
					if (nowx[i] == pos) nowx[i] = fa;
					if (nowy[i] == pos) nowy[i] = fa;
				}
			return;
		}
		vector <int> points;
		for (int i = 1; i <= tot; i++)
			if (!used[i] && ((nowx[i] == pos) ^ (nowy[i] == pos))) {
				points.push_back(i);
			}
		int a = points[0], b = points[1];
		mark(nowx[a], nowy[a], nowx[b], nowy[b]);
		used[a] = used[b] = true;
		if (nowx[a] == pos && nowx[b] == pos) {
			tot++, f[tot] = -a, g[tot] = -b;
			x[tot] = y[a], nowx[tot] = nowy[a];
			y[tot] = y[b], nowy[tot] = nowy[b];
		}
		if (nowy[a] == pos && nowx[b] == pos) {
			tot++, f[tot] = a, g[tot] = -b;
			x[tot] = x[a], nowx[tot] = nowx[a];
			y[tot] = y[b], nowy[tot] = nowy[b];
		}
		if (nowx[a] == pos && nowy[b] == pos) {
			tot++, f[tot] = -a, g[tot] = b;
			x[tot] = y[a], nowx[tot] = nowy[a];
			y[tot] = x[b], nowy[tot] = nowx[b];
		}
		if (nowy[a] == pos && nowy[b] == pos) {
			tot++, f[tot] = a, g[tot] = b;
			x[tot] = x[a], nowx[tot] = nowx[a];
			y[tot] = x[b], nowy[tot] = nowx[b];
		}
		for (int i = 1; i <= tot; i++)
			if (!used[i]) {
				if (nowx[i] == pos) nowx[i] = fa;
				if (nowy[i] == pos) nowy[i] = fa;
			}
	}
}
int main() {
	read(n), read(m), tot = m;
	for (int i = 1; i <= n - 1; i++) {
		int x, y; read(x), read(y);
		a[x].push_back(y);
		a[y].push_back(x);
	}
	for (int i = 1; i <= m; i++) {
		read(x[i]), read(y[i]);
		nowx[i] = x[i];
		nowy[i] = y[i];
	}
	dfs(1, 0);
	work(1, 0);
	writeln(ans);
	for (int i = tot; i >= 1; i--) {
		if (!used[i]) res[i] = true;
		if (i > m) {
			int a = abs(f[i]), b = abs(g[i]);
			res[a] = res[i] ^ (x[i] != x[a]);
			res[b] = res[i] ^ (y[i] != y[b]);
		}
	}
	for (int i = 1; i <= m; i++)
		if (res[i]) printf("%d %d\n", x[i], y[i]);
		else printf("%d %d\n", y[i], x[i]);
	return 0;
}

Problem F. Addition and Andition

令 Si,TiS_i,T_iSi​,Ti​ 表示两个高精度数从最低位开始的第 iii 位。

定义一次对 iii 的进位操作如下：
首先，令 Si=Ti=2S_i=T_i=2Si​=Ti​=2 。
若 Si=2S_i=2Si​=2 或 Ti=2T_i=2Ti​=2 ，将其变为 000 ，并对下一位 +1+1+1 ，令 i=i+1i=i+1i=i+1 ，否则，结束进位操作。

定义一次加法操作如下：
从大到小对于每一个 Si=T1=1S_i=T_1=1Si​=T1​=1 的 iii ，进行进位操作。

题目要求我们进行 KKK 次加法操作。

考虑如下过程，从大到小对于每一个 Si=T1=1S_i=T_1=1Si​=T1​=1 的 iii ，进行 KKK 次如下操作 (1)(1)(1) ：
找到最小的 j≥ij\geq ij

最低0.47元/天 解锁文章

200万优质内容无限畅学
【集训队作业】IOI 2020 集训队作业 试题泛做 13
cz_xuyixuan的博客
01-18 947
Codeforces 679E Bear and Bad Powers of 42 不难发现数列中的元素不可能达到很大，我们只需要考虑 424242 的前若干个幂。 考虑没有赋值操作的做法，则可用线段树维护区间中最接近 424242 的下一个幂的数与这个幂的差值，在区间加时，只需要在线段树上 DFS 找到差值变负的位置更新其与 424242 下一个幂的差值即可。 由于一个数导致进行 DFS 的次数...
ioi2020集训队作业_IOI2020 集训队作业 Part 1
weixin_39845113的博客
12-24 441
CF504EMisha and LCP on Tree直接树剖，变成一堆重链，然后用 SA 求 LCP。时间复杂度 \(O((n+q)\log n)\)。看起来细节就很多，以后补。CF505EMr. Kitayuta vs. Bamboos最大值最小，二分答案。倒过来看，一开始有 \(n\) 条高度都为 \(x\) 的竹子。共 \(m\) 天，每天开始，第 \(i\) 条竹子会往下缩 \(a_i\...
IOI2020集训队作业-24,25,26,27,28
这个博客已经搬到了：zhongyuwei.github.io
01-08 389
24.2 AGC035F Two Histograms 考虑如何建立从可能得到的矩阵到((l1,l2⋯lm),(k1,k2,⋯kn))((l_1,l_2\cdots l_m),(k_1,k_2,\cdots k_n))((l1​,l2​⋯lm​),(k1​,k2​,⋯kn​))的映射。 如果确定了(k1,k2,⋯kn)(k_1,k_2,\cdots k_n)(k1​,k2​,⋯kn​)，显然(l1...
ioi2020集训队作业_IOI2020集训队作业
weixin_36150766的博客
02-23 418
跟着做一下，不是自己独立思考出来的会打个$\Xi$。(然后全是$\Xi$AGC023E不会，再说。AGC023F感觉怎么写个假贪心就过了啊。感性理解一下，肯定$0$越靠前越好，但可能出现一个子树有$0$又有$1$，那怎么办呢？考虑从单个节点开始，合并出一个又一个连通块，最终合并成一棵树。记录这个连通块里的$0$的个数与$1$的个数，那么我们可以在每次合并的时候算出这次合并所产生的逆序对数。那合并的...
集训队作业
01-14
我的集训队作业(codeforces)，没写完……
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日更新。这些论文通常...
【集训队作业】IOI 2020 集训队作业 试题泛做 12
cz_xuyixuan的博客
01-18 560
Codeforces 634F Orchestra 若枚举矩形的上下边界，则问题显然可以 O(n)O(n)O(n) 解决。 那么，考虑枚举矩形的上边界，再从上到下枚举矩形的下边界，则我们需要一边插入点，一边动态维护上面问题的答案。若直接实现，需要使用平衡树。 事实上，我们可以从下到上枚举矩形的下边界，则只需要链表就可以维护了。 时间复杂度 O(r2+rnk)O(r^2+rnk)O(r2+rnk) ...
IOI国家集训队论文集
11-17
包括IOI中国国家集训队从1999年到2017年的论文 部分目录： 国家集训队1999论文集 陈宏：《数据结构的选择与算法效率——从IOI98试题PICTURE谈起》 来煜坤：《把握本质，灵活运用——动态规划的深入探讨》 齐鑫：...
【集训队作业】IOI 2020 集训队作业 试题泛做 1
cz_xuyixuan的博客
12-26 1831
Atcoder Grand Contest 20 Problem D. Min Max Repetition 不妨设 A≤BA\leq BA≤B ，对于 A>BA>BA>B 的情况，可以将序列倒置，并将所有的 A 和 B 取反，然后当做 A≤BA\leq BA≤B 的情况处理。 由题设，我们要求最长的相同字符长度不超过 L=⌈AB+1⌉L=\lceil\frac{A}{B+1}\...
IOI2020 集训队作业
mayaohua
11-01 3386
终于开始做集训队作业了，预感到了集训被吊打的前景。 cf549E cf674G arc103_f cf594E agc034_f agc030_d cf575E agc035_c agc026_f cf607E agc038_e agc030_c cf611G agc034_d agc024_f cf571E cf696F arc093_e cf573...
ioi2018集训队作业1
12-26
希望喜欢算法的童鞋一起学习大佬们的思维。IOI是国际信息学奥林匹克竞赛，此文档是中国IOI2018集训队的作业题。
【集训队作业】IOI 2020 集训队作业 试题泛做 10
cz_xuyixuan的博客
12-26 822
Codeforces 576D Flights for Regular Customers 考虑由一个时刻 iii 可达的点集 SiS_iSi​ 计算时刻 i+1i+1i+1 可达的点集 Si+1S_{i+1}Si+1​ ，这可以由每个时刻可用的边集计算，其本质是一次矩阵乘法。 因此，使用快速幂和 bitset 优化之，可以得到一个时间复杂度 O(MLogV×N3w)O(MLogV\times \...
IOI2020国家集训队作业 Part 1
qq_38253946的博客
10-14 618
别我为啥2021的都出来了才写2020的
【集训队作业】IOI 2020 集训队作业 试题泛做 11
cz_xuyixuan的博客
01-18 682
Codeforces 590E Birthday 首先，可以用 AC 自动机计算出字符串的包含关系。 注意到包含关系构成了一个偏序集，剩余的问题本质上是要求出最长反链。 由 Dilworth 定理，可以得到，最长反链的大小在数值上等于最小链划分的大小。 这里，最小链划分指的是将偏序集划分为尽可能少的元素两两可比的子集，这样的子集称为链。 传递闭包后，最小链划分可以转化为 DAG 上的最小路径覆盖问...
IOI2020集训队作业-12 (CF613E, AGC033E, AGC022D)
这个博客已经搬到了：zhongyuwei.github.io
11-26 493
A - CF613E Puzzle Lover Sol 合法的序列一定是下面这样的形式： 其中第二部分要求只能够向上、下、右走。 第一部分和第三部分可以用哈希/SA快速判断是否可以匹配，第二部分只能从第iii列走到第i+1i+1i+1列，分三个阶段进行dpdpdp就可以了。 考虑第二部分从右往左的情况，我们可以将www翻转然后再计算一次。 注意只有第一部分或只有第三部分将会被数两遍（不翻转www...
IOI2020集训队作业-7 (CF573E, CF704E, ARC103D)
这个博客已经搬到了：zhongyuwei.github.io
11-06 595
A - CF573E Bear and Bowling 题意 定义一个长度为mmm的序列s1,s2⋯sms_1,s_2\cdots s_ms1​,s2​⋯sm​的价值为∑i=1mi⋅si\sum_{i=1}^m i \cdot s_i∑i=1m​i⋅si​。 有一个长度为nnn的数列a1,a2⋯ana_1,a_2\cdots a_na1​,a2​⋯an​。你需要选出这个序列的一个子序列（可以为空也...
IOI2020集训队作业-16 (CF605E, AGC031E, AGC028D)
这个博客已经搬到了：zhongyuwei.github.io
12-05 370
A - CF605E Intergalaxy Trips Sol 设iii号点到达nnn需要的期望天数是fif_ifi​。 每个点的策略一定是：钦定一个集合SSS，等到SSS里面至少有一个点和它连通的时候，走SSS中的、与它连通的、到nnn的期望距离最小的点。显然不在SSS中的点到nnn的期望距离要大于SSS中的点，否则这种钦定SSS的方法一定是不优秀的。 对于一个点uuu来说，如果它选的集合是S...
【集训队作业】IOI 2020 集训队作业 试题泛做 7
cz_xuyixuan的博客
12-26 531
Codeforces 504E Misha and LCP on Tree 在树上进行字符串哈希即可。 本题的第 11 个测试点卡了利用自然溢出的字符串哈希。 时间复杂度 O(NLogN+MLogN)O(NLogN+MLogN)O(NLogN+MLogN) 。 #include<bits/stdc++.h> using namespace std; const int MAXN = 3...
IOI2007中国国家队集训算法作业
"IOI2007第二轮作业是一份针对IOI2007中国国家集训队的算法讨论任务，由教练刘汝佳布置，要求队员在2007年4月30日前完成。作业的核心在于深入探讨算法，而非简单的编程实现。作业提交需发送至指定邮箱。作业内容包含...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值