【LOJ2586】「APIO2018」选圆圈

最新推荐文章于 2019-06-19 20:34:00 发布
最新推荐文章于 2019-06-19 20:34:00 发布
阅读量716 收藏
点赞数
分类专栏： 【OJ】LOJ 【类型】做题记录 【数据结构】KD-Tree 【算法】旋转坐标系
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39972971/article/details/80416185
版权

【题目链接】

【思路要点】

  • 将坐标系以原点为中心旋转一定角度，对圆心建立KDTree。
  • 模拟题目中的过程，利用KDTree的子树信息进行剪枝。
  • 最坏时间复杂度\(O(N^2)\)，期望时间复杂度\(O(NLogN)\)。

【代码】

/*Double Version, Faster but Lower in Precision*/
#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
const double INF = 1e99;
const double eps = 1e-2;
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 ch = getchar();
	for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -f;
	for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '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("");
}
struct circle {double x, y; int r, home; };
struct range {double Maxx, Maxy, Minx, Miny; };
struct Node {
	int lc, rc, ans;
	circle info;
	range rng;
} a[MAXN];
circle c[MAXN], now;
int n, cmptype, root, size, home[MAXN];
inline bool outside(int root) {
	if (now.x + now.r < a[root].rng.Minx - eps || now.x - now.r > a[root].rng.Maxx + eps) return true;
	if (now.y + now.r < a[root].rng.Miny - eps || now.y - now.r > a[root].rng.Maxy + eps) return true;
	return false;
}
inline double sqr(const double x) {return x * x; }
inline bool inside(int root) {
	double dist = sqr(now.x - a[root].info.x) + sqr(now.y - a[root].info.y);
	return dist <= sqr(now.r + a[root].info.r) + eps;
}
void update(int root) {
	if (a[root].ans == 0) {
		a[root].rng.Minx = a[root].info.x - a[root].info.r;
		a[root].rng.Maxx = a[root].info.x + a[root].info.r;
		a[root].rng.Miny = a[root].info.y - a[root].info.r;
		a[root].rng.Maxy = a[root].info.y + a[root].info.r;
	} else {
		a[root].rng.Minx = a[root].rng.Miny = INF;
		a[root].rng.Maxx = a[root].rng.Maxy = -INF;
	}
	if (a[root].lc != 0) {
		int tmp = a[root].lc;
		chkmax(a[root].rng.Maxx, a[tmp].rng.Maxx);
		chkmax(a[root].rng.Maxy, a[tmp].rng.Maxy);
		chkmin(a[root].rng.Minx, a[tmp].rng.Minx);
		chkmin(a[root].rng.Miny, a[tmp].rng.Miny);
	}
	if (a[root].rc != 0) {
		int tmp = a[root].rc;
		chkmax(a[root].rng.Maxx, a[tmp].rng.Maxx);
		chkmax(a[root].rng.Maxy, a[tmp].rng.Maxy);
		chkmin(a[root].rng.Minx, a[tmp].rng.Minx);
		chkmin(a[root].rng.Miny, a[tmp].rng.Miny);
	}
}
bool work(int root) {
	if (outside(root)) return false;
	bool used = false;
	if (a[root].ans == 0 && inside(root)) a[root].ans = now.home, used = true;
	if (a[root].lc) used |= work(a[root].lc);
	if (a[root].rc) used |= work(a[root].rc);
	if (used) update(root);
	return used;
}
bool cmp(const circle &a, const circle &b) {
	if (cmptype) {
		if (a.x == b.x) return a.y < b.y;
		else return a.x < b.x;
	} else {
		if (a.y == b.y) return a.x < b.x;
		else return a.y < b.y;
	}
}
bool cnp(const circle &a, const circle &b) {
	if (a.r == b.r) return a.home < b.home;
	else return a.r > b.r;
}
void build(int &root, int l, int r, bool type) {
	root = ++size;
	cmptype = type;
	int mid = (l + r) / 2;
	nth_element(c + l, c + mid, c + r + 1, cmp);
	a[root].info = c[mid];
	home[c[mid].home] = root;
	if (mid > l) build(a[root].lc, l, mid - 1, type ^ true);
	if (mid < r) build(a[root].rc, mid + 1, r, type ^ true);
	update(root);
}
int main() {
	read(n);
	for (int i = 1; i <= n; i++) {
		read(c[i].x), read(c[i].y), read(c[i].r), c[i].home = i;
		double tmpx = c[i].x * 0.6 - c[i].y * 0.8;
		double tmpy = c[i].y * 0.6 + c[i].x * 0.8;
		c[i].x = tmpx, c[i].y = tmpy;
	}
	build(root, 1, n, true);
	sort(c + 1, c + n + 1, cnp);
	for (int i = 1; i <= n; i++) {
		if (a[home[c[i].home]].ans) continue;
		now = c[i];
		work(root);
	}
	for (int i = 1; i <= n; i++)
		write(a[home[i]].ans), putchar(' ');
	return 0;
}
#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
const long double INF = 1e99;
const long double eps = 1e-7;
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 ch = getchar();
	for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -f;
	for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '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("");
}
struct circle {long double x, y; int r, home; };
struct range {long double Maxx, Maxy, Minx, Miny; };
struct Node {
	int lc, rc, ans;
	circle info;
	range rng;
} a[MAXN];
circle c[MAXN], now;
int n, cmptype, root, size, home[MAXN];
inline bool outside(int root) {
	if (now.x + now.r < a[root].rng.Minx - eps || now.x - now.r > a[root].rng.Maxx + eps) return true;
	if (now.y + now.r < a[root].rng.Miny - eps || now.y - now.r > a[root].rng.Maxy + eps) return true;
	return false;
}
inline long double sqr(const long double x) {return x * x; }
inline bool inside(int root) {
	long double dist = sqr(now.x - a[root].info.x) + sqr(now.y - a[root].info.y);
	return dist <= sqr(now.r + a[root].info.r) + eps;
}
void update(int root) {
	if (a[root].ans == 0) {
		a[root].rng.Minx = a[root].info.x - a[root].info.r;
		a[root].rng.Maxx = a[root].info.x + a[root].info.r;
		a[root].rng.Miny = a[root].info.y - a[root].info.r;
		a[root].rng.Maxy = a[root].info.y + a[root].info.r;
	} else {
		a[root].rng.Minx = a[root].rng.Miny = INF;
		a[root].rng.Maxx = a[root].rng.Maxy = -INF;
	}
	if (a[root].lc != 0) {
		int tmp = a[root].lc;
		chkmax(a[root].rng.Maxx, a[tmp].rng.Maxx);
		chkmax(a[root].rng.Maxy, a[tmp].rng.Maxy);
		chkmin(a[root].rng.Minx, a[tmp].rng.Minx);
		chkmin(a[root].rng.Miny, a[tmp].rng.Miny);
	}
	if (a[root].rc != 0) {
		int tmp = a[root].rc;
		chkmax(a[root].rng.Maxx, a[tmp].rng.Maxx);
		chkmax(a[root].rng.Maxy, a[tmp].rng.Maxy);
		chkmin(a[root].rng.Minx, a[tmp].rng.Minx);
		chkmin(a[root].rng.Miny, a[tmp].rng.Miny);
	}
}
bool work(int root) {
	if (outside(root)) return false;
	bool used = false;
	if (a[root].ans == 0 && inside(root)) a[root].ans = now.home, used = true;
	if (a[root].lc) used |= work(a[root].lc);
	if (a[root].rc) used |= work(a[root].rc);
	if (used) update(root);
	return used;
}
bool cmp(const circle &a, const circle &b) {
	if (cmptype) {
		if (a.x == b.x) return a.y < b.y;
		else return a.x < b.x;
	} else {
		if (a.y == b.y) return a.x < b.x;
		else return a.y < b.y;
	}
}
bool cnp(const circle &a, const circle &b) {
	if (a.r == b.r) return a.home < b.home;
	else return a.r > b.r;
}
void build(int &root, int l, int r, bool type) {
	root = ++size;
	cmptype = type;
	int mid = (l + r) / 2;
	nth_element(c + l, c + mid, c + r + 1, cmp);
	a[root].info = c[mid];
	home[c[mid].home] = root;
	if (mid > l) build(a[root].lc, l, mid - 1, type ^ true);
	if (mid < r) build(a[root].rc, mid + 1, r, type ^ true);
	update(root);
}
int main() {
	read(n);
	for (int i = 1; i <= n; i++) {
		read(c[i].x), read(c[i].y), read(c[i].r), c[i].home = i;
		long double tmpx = c[i].x * 0.6 - c[i].y * 0.8;
		long double tmpy = c[i].y * 0.6 + c[i].x * 0.8;
		c[i].x = tmpx, c[i].y = tmpy;
	}
	build(root, 1, n, true);
	sort(c + 1, c + n + 1, cnp);
	for (int i = 1; i <= n; i++) {
		if (a[home[c[i].home]].ans) continue;
		now = c[i];
		work(root);
	}
	for (int i = 1; i <= n; i++)
		write(a[home[i]].ans), putchar(' ');
	return 0;
}
/*Long Double Version, Slower but Higher in Precision*/
#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
const long double INF = 1e99;
const long double eps = 1e-5;
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 ch = getchar();
	for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -f;
	for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '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("");
}
struct circle {long double x, y; int r, home; };
struct range {long double Maxx, Maxy, Minx, Miny; };
struct Node {
	int lc, rc, ans;
	circle info;
	range rng;
} a[MAXN];
circle c[MAXN], now;
int n, cmptype, root, size, home[MAXN];
inline bool outside(int root) {
	if (now.x + now.r < a[root].rng.Minx - eps || now.x - now.r > a[root].rng.Maxx + eps) return true;
	if (now.y + now.r < a[root].rng.Miny - eps || now.y - now.r > a[root].rng.Maxy + eps) return true;
	return false;
}
inline long double sqr(const long double x) {return x * x; }
inline bool inside(int root) {
	long double dist = sqr(now.x - a[root].info.x) + sqr(now.y - a[root].info.y);
	return dist <= sqr(now.r + a[root].info.r) + eps;
}
void update(int root) {
	if (a[root].ans == 0) {
		a[root].rng.Minx = a[root].info.x - a[root].info.r;
		a[root].rng.Maxx = a[root].info.x + a[root].info.r;
		a[root].rng.Miny = a[root].info.y - a[root].info.r;
		a[root].rng.Maxy = a[root].info.y + a[root].info.r;
	} else {
		a[root].rng.Minx = a[root].rng.Miny = INF;
		a[root].rng.Maxx = a[root].rng.Maxy = -INF;
	}
	if (a[root].lc != 0) {
		int tmp = a[root].lc;
		chkmax(a[root].rng.Maxx, a[tmp].rng.Maxx);
		chkmax(a[root].rng.Maxy, a[tmp].rng.Maxy);
		chkmin(a[root].rng.Minx, a[tmp].rng.Minx);
		chkmin(a[root].rng.Miny, a[tmp].rng.Miny);
	}
	if (a[root].rc != 0) {
		int tmp = a[root].rc;
		chkmax(a[root].rng.Maxx, a[tmp].rng.Maxx);
		chkmax(a[root].rng.Maxy, a[tmp].rng.Maxy);
		chkmin(a[root].rng.Minx, a[tmp].rng.Minx);
		chkmin(a[root].rng.Miny, a[tmp].rng.Miny);
	}
}
bool work(int root) {
	if (outside(root)) return false;
	bool used = false;
	if (a[root].ans == 0 && inside(root)) a[root].ans = now.home, used = true;
	if (a[root].lc) used |= work(a[root].lc);
	if (a[root].rc) used |= work(a[root].rc);
	if (used) update(root);
	return used;
}
bool cmp(const circle &a, const circle &b) {
	if (cmptype) {
		if (a.x == b.x) return a.y < b.y;
		else return a.x < b.x;
	} else {
		if (a.y == b.y) return a.x < b.x;
		else return a.y < b.y;
	}
}
bool cnp(const circle &a, const circle &b) {
	if (a.r == b.r) return a.home < b.home;
	else return a.r > b.r;
}
void build(int &root, int l, int r, bool type) {
	root = ++size;
	cmptype = type;
	int mid = (l + r) / 2;
	nth_element(c + l, c + mid, c + r + 1, cmp);
	a[root].info = c[mid];
	home[c[mid].home] = root;
	if (mid > l) build(a[root].lc, l, mid - 1, type ^ true);
	if (mid < r) build(a[root].rc, mid + 1, r, type ^ true);
	update(root);
}
int main() {
	read(n);
	for (int i = 1; i <= n; i++) {
		read(c[i].x), read(c[i].y), read(c[i].r), c[i].home = i;
		long double tmpx = c[i].x * 0.6 - c[i].y * 0.8;
		long double tmpy = c[i].y * 0.6 + c[i].x * 0.8;
		c[i].x = tmpx, c[i].y = tmpy;
	}
	build(root, 1, n, true);
	sort(c + 1, c + n + 1, cnp);
	for (int i = 1; i <= n; i++) {
		if (a[home[c[i].home]].ans) continue;
		now = c[i];
		work(root);
	}
	for (int i = 1; i <= n; i++)
		write(a[home[i]].ans), putchar(' ');
	return 0;
}

cz_xuyixuan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
APIO2018 T2T3 题解 陈俊锟 吕欣 张瑞喆
07-26
第二题 重复下列算法： 每次选出半径最大的圆 删除和它有交的所有圆 这里有交指圆盘公共区域不为 0 求每个圆是哪一次被删除的 第三题 先从简单的题开始 给出一张无向图 求有多少 (
Loj X:创建逻辑电路-开源
07-04
Loj X 是一个开源项目，专注于提供一个平台，让人们能够创建和设计逻辑电路，从而实现基本的计算功能，甚至构建小型的完整处理器。这个工具集成了各种元件，如逻辑门、存储器和程序读取器，使得用户可以构建出复杂的...
「APIO2018」选圆圈
weixin_33919941的博客
05-10 214
传送门 Description 有\(n\)个圆，每次找到这些圆中半径最大中的编号最小的圆，删除ta及与其有交集的所有圆。 对于每个圆，求出它是被哪一个圆删除的。 Solution K-D Tree 每个点表示这个圆的外接矩形 排序后直接暴力搜索 相当于在搜索过程中进行了剪枝 复杂度玄学 要对全图坐标进行旋转 这题的\(eps\)不要开得太大，\(1e-3\)就行了，不然会莫名的W...
LOJ2586 APIO2018 选圆圈
weixin_34319640的博客
01-17 132
考前挣扎 KD树好题！ 暴力模拟 通过kd树的结构把子树内的圈圈框起来 然后排个序根据圆心距 <= R1+R2来判断是否有交点 然后随便转个角度就可以保持优越的nlgn啦 卡精度差评 必须写eps差评 //Love and Freedom. #include<cstdio> #include<cstring> #include<algorith...
「APIO2018选圆圈」
weixin_30497527的博客
12-14 141
「APIO2018选圆圈」 题目描述 在平面上，有 \(n\) 个圆，记为 \(c_1, c_2, \ldots, c_n\) 。我们尝试对这些圆运行这个算法： 找到这些圆中半径最大的。如果有多个半径最大的圆，选择编号最小的。记为 \(c_i\) 。 删除 \(c_i\) 及与其有交集的所有圆。两个圆有交集当且仅当平面上存在一个点，这个点同时在这两个圆的圆周上或圆内。 重复上面两个步骤直到所有...
[APIO2018] Circle selection 选圆圈(假题解)
Cyhlnj
05-30 701
题面 自己去LOJLOJLOJ上找 Sol 直接排序然后KDTreeKDTreeKDTree查询 然后发现TLETLETLE了 然后把点旋转一下，就过了。。 # include &lt;bits/stdc++.h&gt; # define IL inline # define RG register # define Fill(a, b) memset(a, b, sizeof(a))...
log4j配置，jar包
06-01
**日志框架Log4j详解** Log4j是Apache组织提供的一款开源的日志记录框架，广泛应用于Java应用程序中。它的核心功能是为开发者提供一种灵活、高效的方式来记录应用程序运行过程中的各种信息，如错误、警告、调试信息...
mybaits 架包
01-30
MyBatis 是一款著名的Java持久层框架，它简化了数据库操作与对象之间的映射工作，提供了灵活的SQL映射和事务管理。MyBatis-3.3.0 是该框架的一个稳定版本，它包含了对SQL的动态构造能力，以及对XML配置和注解方式的...
up_717085_google-api-php-client_71loj.rar
12-22
标题中的"up_717085_google-api-php-client_71loj.rar"表明这是一个关于Google API PHP客户端的压缩文件，其中包含了用于与Google API交互的PHP代码示例。这个工具通常用于开发人员在PHP环境中访问和利用Google的...
scicloj.github.com：Scicloj网站
02-08
scicloj.github.com：Scicloj网站
APIO2018T1 New Home 题解 吕欣
07-26
题目大意 在一个数轴上： 给定 N 个商店，每个商店有一个开业时间、关门时间、坐标和销售物品的种类 同时有 M 个询问，每个询问给你一个时间 t[i] 和地点 d[i]，试求在 t[i] 时刻，一个住在 d[i] 的人，为了买某种商品最远需要跑多长距离。
APIO 2018选圆圈
weixin_30670925的博客
06-30 130
#include<cstdio> #include<algorithm> #include<cstring> #include<iostream> #include<queue> #include<cmath> #define sqr(x) (x) * (x) #define M 300005 using ...
【loj2586】【APIO2018】选圆圈
weixin_33739523的博客
04-30 110
题目 有 \(n\) 个圆$c_1,c_2, \cdots , c_n $，执行如下的操作： 找到剩下的半径最大的圆删除并删除所有和它有交的其他并没有被删除的圆； 求每个圆是被那个圆删除的； $1 \le n \le 3 \times 10^5 $ ; 描述 kdt做法： 记录每个圆围成的举行作为剪枝，直接模拟删除； 记得旋转一下，然后eps开1e-3就好; 搬运一下$n log^2n $做法...
LOJ 2586 「APIO2018」选圆圈——KD树
weixin_34220834的博客
04-12 132
题目：https://loj.ac/problem/2586 只会 19 分的暴力。 y 都相等，仍然按直径从大到小做。如果当前圆没有被删除，那么用线段树把 [ x-r , x+r ] 都打上它的标记。 看当前圆有没有被删除，只要看 x-r 和 x+r 两个位置上的标记就行了。因为被删除的话当前圆的直径更小，有相交的话， x-r 或 x+r 一定在对方内部。可以 x-r 和 x+r 分别在...
APIO2018 Circle selection 选圆圈
dieyi9889的博客
04-01 184
APIO2018 Circle selection 选圆圈 题意: 题目传送门 题解： 似乎网上题解都是KDTree啊…… 反正似乎裸的KDTree，稍微旋转一下角度，似乎就不会被卡到\(n^2\)了……不过如果\(1e9\)的\(double\)平方一下会爆精，开个\(long \ \ double\)苟过去…… Code： #include <bits/stdc++.h&gt...
洛谷4631 [APIO2018] Circle selection 选圆圈 （KD树）
y_immortal的博客 QwQ(qdez_ymh)
01-16 344
qwq纪念AC450 一开始想这个题想复杂了。 首先，正解的做法是比较麻烦的。 qwqq 那么就不如来一点暴力的东西，看到平面上点的距离的题，不难想到KD−TreeKD-TreeKD−Tree 我们用类似平面最近点对那个题一样的维护方式，对于一个子树内部，分别维护每一个维度的最大值和最小值，还有半径的最大值。 然后sortsortsort一遍，从半径大到小依次queryqueryquery，每次q...
bzoj5465 [APIO 2018] 选圆圈 kd树
olahiuj的博客
03-02 255
Description 在平面上，有 n 个圆，记为 c_1, c_2, \ldots, c_n 。我们尝试对这些圆运行这个算法： 找到这些圆中半径最大的。如果有多个半径最大的圆，选择编号最小的。记为 c_i 。 删除 ci 及与其有交集的所有圆。两个圆有交集当且仅当平面上存在一个点，这个点同时在这两个圆的圆周上或圆内。 （如果平面上存在一个点被这两个圆所包含，我们称这两个圆有交集。一个点被一...
luogu P4631 [APIO2018] Circle selection 选圆圈
weixin_30527143的博客
06-19 113
传送门 那个当前半径最大的圆可以用堆维护.这道题一个想法就是优化找和当前圆有交的圆的过程.考虑对于所有圆心建KD-tree,然后在树上遍历的找这样的点.只要某个点子树内的点构成的矩形区域到当前圆心的最近距离\(>2\)倍半径就不用找了 然而在loj上过不去,这时就可以用一个很鸡贼的优化,对于所有点绕原点旋转一定角度,然后就跑的过了(可能是全在一条直线上建KD-tree会出锅(雾)).稍微注意...
[APIO2018] Circle selection 选圆圈
weixin_30408165的博客
07-15 69
Description 给出 \(n\) 个圆 \((x_i,y_i,r_i)\) 每次重复以下步骤: 找出半径最大的圆,并删除与这个圆相交的圆 求出每一个圆是被哪个圆删除的 Solution \(kd-tree\) 搞一下 维护能够围住所有圆的最小矩形 然后模拟题意,枚举半径最大的圆 查询时就判断询问的圆是否与这个矩形有交,有交就递归下去 #include<bits/stdc++.h&gt...
有源汇有上下界的最小流（LOJ117）
最新发布
06-11
这是一个IT类问题。该问题可以使用网络流算法解决。首先用 Dinic 或 ISAP 算法求出最大流，然后根据最大流的值和边的上下界，构造一个新图，使得原图中的每条边都对应着新图中的一些流量限制。具体地，对于一条容量为$c$，下界为$l$，上界为$u$的边$(u,v)$，我们在新图中从$u$向$v$连一条容量为$u-l$的边和一条容量为$u-l$，费用为$c$的边，再从源点向$u$连一条容量为$l$的边，费用为$0$，最后从$v$向汇点连一条容量为$l$的边，费用为$0$。在新图上跑一遍费用流，如果总流量等于原图的最大流，则新图中的最小费用即为所求最小流，否则原图不存在满足上下界的流。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值