[IOI2018]-day1 简要题解

最新推荐文章于 2020-02-17 09:28:08 发布
最新推荐文章于 2020-02-17 09:28:08 发布
阅读量499 收藏
点赞数 1
文章标签： IOI2018
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/VictoryCzt/article/details/85704346
版权

因为只有4种字母，且只能询问 n + 2 n+2 n+2次，那么我们需要平均一次就要确定一位。

而询问的串长，最长为 4 × n 4\times n 4×n，所以每次对于一个要确定的字母我们可以直接输出四种情况。但是这样需要2次确定一位，所以我们需要进一步优化。

首先，我们可以花两步确定第一位：

询问"AB"，如果返回的值大于0，则就是"AB"中的一个，然后就输出一个"A"，如果返回值为1，那么开头就是"A"，否则为"B"。如果不是"AB"，那么就是"XY"，所以输出"X"，和"AB"同样的判断方法，那么就可以知道第一位。

对于后面的每一位，我们要尽量做到一次询问确定一位。由于开头的那一位不会在后面再次出现，那么我们只剩下三种选择。

举个例子说明：

假如开头是"A"，那么下一位可能为"B,X,Y"，而如果每次只增加一位的话，就还要花费一个操作去确定，所以我们增加两位：“BB”,“BX”,“BY”，这样如果返回值没有增加，下一位就不是"B"，但是如果增加了两个，那么下一位就是"B"，如果不是"B"的话，还要判断"X,Y"，由于"A"不能再出现，所以我们再加一个"XA"，这样如果返回值只增加了一个，那么下一位就是"X"，否则没增加就是"Y"。

所以直接模拟，而到了最后一位，直接按照开始的方法，在剩下三种情况中花费两个操作判断一下即可。

代码（交互）：

#include "combo.h"
using namespace std;

string Nex(char a,int id){
	if(a=='A'){
		if(id==1) return "BB";
		if(id==2) return "BX";
		if(id==3) return "BY";
		if(id==4) return "XA";
	}else if(a=='B'){
		if(id==1) return "AA";
		if(id==2) return "AX";
		if(id==3) return "AY";
		if(id==4) return "XB";
	}else if(a=='X'){
		if(id==1) return "AA";
		if(id==2) return "AB";
		if(id==3) return "AY";
		if(id==4) return "BX";
	}else if(a=='Y'){
		if(id==1) return "AA";
		if(id==2) return "AB";
		if(id==3) return "AX";
		if(id==4) return "BY";		
	}
}
string Ok(char a,int con,int bef){
	if(a=='A'){
		if(con==bef){
			return "Y";
		}else if(con==bef+1){
			return "X";
		}else if(con==bef+2){
			return "B";
		}
	}else if(a=='B'){
		if(con==bef){
			return "Y";
		}else if(con==bef+1){
			return "X";
		}else if(con==bef+2){
			return "A";
		}		
	}else if(a=='X'){
		if(con==bef){
			return "Y";
		}else if(con==bef+1){
			return "B";
		}else if(con==bef+2){
			return "A";
		}		
	}else if(a=='Y'){
		if(con==bef){
			return "X";
		}else if(con==bef+1){
			return "B";
		}else if(con==bef+2){
			return "A";
		}		
	}
}
string End(char a,int id){
	if(a=='A'){
		if(id==1){
			return "B";
		}else if(id==2){
			return "X";
		}else if(id==3){
			return "Y";
		}
	}else if(a=='B'){
		if(id==1){
			return "A";
		}else if(id==2){
			return "X";
		}else if(id==3){
			return "Y";
		}		
	}else if(a=='X'){
		if(id==1){
			return "A";
		}else if(id==2){
			return "B";
		}else if(id==3){
			return "Y";
		}		
	}else if(a=='Y'){
		if(id==1){
			return "A";
		}else if(id==2){
			return "B";
		}else if(id==3){
			return "X";
		}				
	}
}
string guess_sequence(int N){
	string st="";
	string pre="AB";
	int con=press(pre);
	if(!con){
		con=press("X");
		if(con) st="X";
		else st="Y";
	}else{
		con=press("A");
		if(con) st="A";
		else st="B";
	}
	pre=st;
	if(N==1) return pre;
	for(int i=2;i<=N-1;i++){
		string ask="";
		for(int j=1;j<=4;j++)ask+=pre+Nex(st[0],j);
		con=press(ask);
		pre+=Ok(st[0],con,i-1);
	}
	string last=pre+End(st[0],1)+pre+End(st[0],2);
	con=press(last);
	if(con==N-1){
		last=pre+End(st[0],3);
	}else{
		last=pre+End(st[0],1);
		con=press(last);
		if(con==N-1){
			last=pre+End(st[0],2);
		}
	}
    return last;
}

开始我想的是，对于一个前缀 0 ∼ L 0\sim L 0∼L，我们维护里面最左下角的点和最右上角的点，然后每次询问我们就判断每个前缀数的个数是不是等于所在矩形区间的大小，为了支持快速查询修改，外面再套一个树，或者用主席树之类的，但是就是十分复杂，且复杂度为 O ( n l o g 2 n ) O(nlog^2n) O(nlog2n)的，是无法通过所有数据的。

所以我们转换思路，对于一个前缀 0 ∼ L 0\sim L 0∼L如果它形成了一个矩形，那么与其相交的所有 2 × 2 2\times 2 2×2的子矩形要么是只有两个相交，要么是全部在里面，要么是只有一个相交，而一个的只有矩形的四个顶点，而三个相交的又不存在，但是2，4个的个数不确定，所以我们就只维护对于一个前缀 0 ∼ L 0\sim L 0∼L的所在格子形成的图形与其相交的所有 2 × 2 2\times 2 2×2的子矩形中 1 , 3 1,3 1,3的个数，如果合法的话必须只有 4 , 0 4,0 4,0个。

这个可以先预处理出来，然后用权值线段树维护即可，每次修改就交换然后线段树上改这两个点周围包含它的 2 × 2 2\times 2 2×2的子矩形即可，复杂度 O ( n l o g n ) O(nlogn) O(nlogn)。

#include "seats.h"

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int M=1e6+10;

vector <int> mp[M];
int rr[M],cc[M];
int B1[M],B3[M];
int n,m;
struct node{
	int b1,b3;
	node(){}
	node(int a,int b):b1(a),b3(b){}
	bool operator <(const node &a)const{
		return b1<a.b1||(b1==a.b1&&b3<a.b3);
	}
	node operator +(const node &a)const{
		return node(b1+a.b1,b3+a.b3);	
	}
	bool operator ==(const node &a)const{
		return b1==a.b1&&b3==a.b3;	
	}
	node operator +=(const node &a){return *this=*this+a;}
	bool isok(){return b1==4&&!b3;}
};

int tot,root;
node S[M<<2],lazy[M<<2];
int ls[M<<2],rs[M<<2],sum[M<<2];

void pushup(int o){
	S[o]=min(S[ls[o]],S[rs[o]]);sum[o]=0;
	if(S[o]==S[ls[o]])sum[o]+=sum[ls[o]];
	if(S[o]==S[rs[o]])sum[o]+=sum[rs[o]];
}
void pushdown(int o){
	node &now=lazy[o];
	if(now==node(0,0)) return;
	S[ls[o]]+=now;S[rs[o]]+=now;
	lazy[ls[o]]+=now;lazy[rs[o]]+=now;
	now=node(0,0);
}
void build(int &o,int l,int r){
	o=++tot;lazy[o]=node(0,0);
	if(l==r){
		S[o]=node(B1[l],B3[l]);sum[o]=1;
		return;
	}
	int mid=l+r>>1;
	build(ls[o],l,mid);
	build(rs[o],mid+1,r);
	pushup(o);
}
void update(int o,int l,int r,int L,int R,node v){
	if(L>R) return;
	if(L<=l&&r<=R){
		S[o]+=v;lazy[o]+=v;
		return;
	}
	pushdown(o);
	int mid=l+r>>1;
	if(L<=mid) update(ls[o],l,mid,L,R,v);
	if(R>mid) update(rs[o],mid+1,r,L,R,v);
	pushup(o);
}
int query(){
	if(S[root].isok()) return sum[root];
	else return 0;
}
int stk[4];
const int dx[]={0,1,0,1},dy[]={0,0,1,1};
void init(int x,int y){
	for(int i=0;i<=3;i++){
		stk[i]=mp[x+dx[i]][y+dy[i]];
	}	sort(stk,stk+4);
}
void give_initial_chart(int H, int W, std::vector<int> R, std::vector<int> C) {
	n=H,m=W;
	for(int i=0;i<=n+1;i++){
		mp[i].resize(m+2);
		for(int j=0;j<=m+1;j++){
			mp[i][j]=n*m+1;
		}
	}
	for(int i=1,sz=n*m;i<=sz;i++){
		rr[i]=R[i-1]+1;cc[i]=C[i-1]+1;
		mp[rr[i]][cc[i]]=i;
	}
	for(int i=0;i<=n;i++)for(int j=0;j<=m;j++){
		init(i,j);
		++B1[stk[0]];--B1[stk[1]];
		++B3[stk[2]];--B3[stk[3]];
	}
	for(int i=1,sz=n*m;i<=sz;i++){
		B1[i]+=B1[i-1];
		B3[i]+=B3[i-1];
	}
	build(root,1,n*m);
}
void New(int x,int y,int v){
	init(x,y);
	update(root,1,n*m,stk[0],stk[1]-1,node(v,0));
	update(root,1,n*m,stk[2],stk[3]-1,node(0,v));
}
const int tx[]={0,-1,0,-1},ty[]={0,0,-1,-1};
void Up(int x,int y,int v){
	for(int i=0;i<=3;i++)
		New(x+tx[i],y+ty[i],-1);
	mp[x][y]=v;
	for(int i=0;i<=3;i++)
		New(x+tx[i],y+ty[i],1);
}
int swap_seats(int a, int b) {
	++a;++b;
	int v1=mp[rr[a]][cc[a]],v2=mp[rr[b]][cc[b]];
	swap(rr[a],rr[b]);swap(cc[a],cc[b]);
	Up(rr[a],cc[a],v1);
	Up(rr[b],cc[b],v2);
	return query();
}

由于每次每种形态不能去和能去的都是一个编号的前缀或者后缀，所以我们考虑将图转换成两个重构树，一个是编号小的向大的，另一个是编号大的向小的。

然后一个前缀就对应了小的向大的树上的一个子树，后缀就对应了大的向小的上面的一个子树，每次用类似二维数点的方式判断这两个子树集合是否有交，有交就证明可以在这里变成狼人到达终点，否则就不行。

将询问离线，在两个树上的dfs序上，就可以用树状数组来求答案啦。

这里的重构树的方法类似于kruskal重构树，所以用个并查集来建就好了。

#include "werewolf.h"

#include<cstdio>
#include<cstring>
#include<algorithm> 
#define lowbit(a) ((a)&(-(a)))
using namespace std;
const int M=1e6+1; 
const int Log=20;
struct DSU{
	int f[M];
	void init(int n){
		for(int i=0;i<=n;i++)f[i]=i;
	}
	int find(int a){return f[a]==a?a:f[a]=find(f[a]);}
	int & operator [](int a){return f[a];}
	int operator ()(int a){return find(a);}
};
int n;
struct Rebuild_Tree{
	vector <int> g[M],t[M];
	int in[M],root;
	void add(int a,int b){g[a].push_back(b);}
	void link(int a,int b){t[a].push_back(b);++in[b];}
	DSU F;
	int dfn[M],out[M],tim;
	int f[Log][M];
	void dfs(int a){
		dfn[a]=++tim;
		for(int i=1;i<Log;i++)
			f[i][a]=f[i-1][f[i-1][a]];
		for(auto v: t[a]){
			f[0][v]=a;
			dfs(v);
		}
		out[a]=tim;
	}
	void build(bool flag){
		F.init(n);
		if(flag){
			for(int i=1,u;i<=n;i++){
				for(auto v: g[i]){
					u=F(v);
					if(i!=u){
						F[u]=i;
						link(i,u);
					}
				}
			}
		}else{
			for(int i=n,u;i>=1;i--){
				for(auto v: g[i]){
					u=F(v);
					if(i!=u){
						F[u]=i;
						link(i,u);
					}
				}				
			}
		}
		for(int i=1;i<=n;i++)if(!in[i]){root=i;break;}
		dfs(root);
	}
	void Find(int a,int to,int tp,int &x,int &y){
		for(int i=Log-1;i>=0;i--){
			if(f[i][a]&&(tp?f[i][a]>=to:f[i][a]<=to)){
				a=f[i][a];
			}
		}
		x=dfn[a]-1;
		y=out[a];
	}
}T1,T2;
int bit[M];
void add(int a,int b){
	for(;a<=n;a+=lowbit(a))bit[a]+=b;
}
int query(int a){
	int res=0;
	for(;a;a-=lowbit(a))res+=bit[a];
	return res;
}
struct Ask{
	int s,t;
	Ask(){}
	Ask(int a,int b):s(a),t(b){}
};
vector <Ask> Q[M];
vector <int> ans;
int ref[M];
int a,b;
vector<int> check_validity(int N,vector<int> X,vector<int> Y,vector<int> S,vector<int> E,vector<int> L,vector<int> R) {
	n=N;
	for(int i=0,sz=X.size();i<sz;i++){
		a=X[i]+1;b=Y[i]+1;
		if(a<b)swap(a,b);
		T1.add(a,b);T2.add(b,a);
	}
	T1.build(1);
	T2.build(0);
	for(int i=0,sz=S.size(),lx,rx,ly,ry;i<sz;i++){
		T2.Find(S[i]+1,L[i]+1,1,lx,rx);
		T1.Find(E[i]+1,R[i]+1,0,ly,ry);
		Q[lx].push_back(Ask(ly,i));Q[lx].push_back(Ask(-ry,i));
		Q[rx].push_back(Ask(-ly,i));Q[rx].push_back(Ask(ry,i));
	}
	for(int i=1;i<=n;i++)
		ref[T2.dfn[i]]=T1.dfn[i];
	ans.resize(S.size());
	for(int i=1;i<=n;i++){
		add(ref[i],1);
		for(int j=0,sz=Q[i].size();j<sz;j++){
			Ask now=Q[i][j];
			int fl=now.s<0?now.s=-now.s,-1:1;
			ans[now.t]+=query(now.s)*fl;
		}
	}	
	for(int i=0,sz=ans.size();i<sz;i++)if(ans[i]>0)ans[i]=1;else ans[i]=0;
	return ans;
}
VictoryCzt
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
【LOJ2863】「IOI2018」组合动作
cz_xuyixuan的博客
09-17 745
【题目链接】 点击打开链接 【思路要点】 首先，我们可以通过 222 次操作确定第一个字符，不妨令其为 AAA 。 接下来，对于 2≤i≤N−12≤i≤N−12≤i≤N-1 若我们已经确定了前 i−1i−1i-1 个字符为 SSS ，我们询问 SBSXBSXXSXYSBSXBSXXSXYSBSXBSXXSXY ，若得到的结果为 i−1i−1i-1 ，则说明...
IOI2017 Day1 Toy Train 题解
imalyd的博客
08-06 1190
这题思维难度比较大^_^首先，对任意集合$S$，定义函数$f_A(S)$为不管B怎样A都能进入$S$的起点的集合，$f_B(S)$同理设充电站集合为$R$，则如果起点在$f_A(R)$以外B必胜（即B一定有一种策略使得火车无法进入$R$）如果$f_A(R)$为全集则A赢（不管怎样A总能使火车进入$R$）
IOI2018所有题面
09-07
IOI2018的所有题目的中文题面
[IOI2018]组合动作 题解
GKxx
02-10 337
传送门 LOJ2863 果然签到题就是好玩 首先我们可以猜2次来猜出第一个字符是什么，后面的串就和这个字符没关系了。 假设剩下的三个字符是tmp[0]，tmp[1]，tmp[2]，目前已知答案串的长度为i−1i-1i−1的前缀是ans。考虑第iii位（i≤n−1i\leq n-1i≤n−1），我们可以在ans串后面接上一个字符然后press来检查有没有获得更多的金币，但是这样的话你总共要press...
【NOI2018DAY1T1】【洛谷P4768】—归程[Return]（Kruscal重构树）
Stargazer的博客
01-27 177
传送门 重构树简单题 和PeaksPeaksPeaks相似，还要简单一些 考虑到低于水位线的边都会被淹没 那显然我们做最大生成树后树上路径就是最优的情况 多次询问考虑KruscalKruscalKruscal重构树 显然对于当前一个要求的的水位和点 我们倍增找到第一个刚好大于水位线的点 那显然答案就是该点的子树中所有叶子节点到111的最短的一条 直接最短路后树形dpdpdp预处理一下就可以了 复杂...
【题目】IOI2018 狼人
PHenning的博客
02-17 298
题目大意 给出一张NNN个点MMM条边的无向图，保证图连通。你有QQQ个行程，第iii个行程的起点是SiS_iSi​，终点是EiE_iEi​。在每个行程开始时你必须是人形，在每个行程结束时你必须是狼形，且途中只能在[Li,Ri][L_i,R_i][Li​,Ri​]内的某个点变身。问每次行程能否完成。 N⩽200000N\leqslant 200000N⩽200000，M⩽400000M\leqsl...
ioi2021-image
03-30
ioi2021-图片 安装/设置 创建一个虚拟机：2个VCPU，4 GB RAM，25 GB磁盘。 安装Ubuntu 20.04服务器。 默认设置可以正常工作（但请取消选中“将此磁盘设置为LVM组”选项）。 创建一个名为ansible的用户帐户。 ...
2IOI0-DBL-Process-Mining：埃因霍温TU 2020-2021年第三季度2IOI0 DBL-Processing Mining
02-13
标题中的“2IOI0-DBL-Process-Mining”显然指的是一个课程或者项目，它在2020-2021年第三季度在荷兰埃因霍温理工大学（Eindhoven University of Technology，简称TU Eindhoven）进行。"DBL"可能是“Data-Driven ...
IOI2017 Day1 Wiring 题解
imalyd的博客
08-06 3691
第一次写博客，感觉好激动啊~其实这题的Subtask 2很有启发意义。Subtask 2中，由于红点在蓝点左边，所以答案就是...
IOI2002-input+solution 测试数据
04-16
6. **分支限界法**：用于在有限的搜索空间中寻找最优解，如0-1背包问题、旅行商问题。 7. **数据结构**：如栈、队列、链表、树、哈希表、位运算等，它们是实现算法的基础。 8. **字符串处理**：KMP算法、Rabin-Karp...
[ioi2018 d2t1] doll - 有趣的构造题
liuzhangfeiabc的博客
09-06 822
花了4个小时终于搞懂了这题……膜拜现场各种1h以内a掉的julao。 这道题全场大概30几人ac，难度不算太高也不算太低，算是d2最简单，全场第二简单的题。 你要构造一张图，其中起点编号为0，有m个给定的普通点，编号为1~m，你还可以添加若干个特殊点（数量自己决定，这里设为s个），编号-1~-s。所有点可以有任意多条入边，但起点普通点只能有1条出边，特殊点只能有2条出边。 每个特殊点满足：当...
[loj2863] [ioi2018 d1t1] combo - 有趣的交互题
liuzhangfeiabc的博客
09-06 620
传送门：https://loj.ac/problem/2863 斗胆来一发ioi题解。 今年的d1t1是一道交互题。喜欢出交互题是ioi的一大特色之一，而国内的正式比赛中还是很少见到交互题的身影的（印象中只有wc2016和wc2018有交互题）。 虽是ioi，但难度不算大的题还是会出现的，主要也是要考虑到世界各国选手的整体水平。本题算是今年6道题中最简单的一道，全场大约有一半的选手都成功ac...
[loj2864] [ioi2018 d1t2] seats - 线段树
liuzhangfeiabc的博客
09-13 817
传送门：https://loj.ac/problem/2864 作死尝试这道全世界只有1人ac的神题。 先%一波dsgsjk，这位吊打全世界的julao可能是全世界第二个做出这题的现役oi选手。 题目大意：给定一个n*m的矩阵，矩阵中不重不漏地分布着0~n*m-1的元素。称一个大小为s的连续子矩阵是好的当且仅当其中不重不漏地出现了0~s-1的元素。每次交换矩阵中的两个元素，查询当前有多少个好...
【LOJ2864】「IOI2018」排座位
cz_xuyixuan的博客
09-18 1002
【题目链接】 点击打开链接 【思路要点】 对于一个 ttt ，将 1,2,3,...,t1,2,3,...,t1,2,3,...,t 所在方格染黑，剩余方格染白，考虑网格图中所有的 2∗22*22∗2 的正方形，那么 1,2,3,...,t1,2,3,...,t1,2,3,...,t 形成一个矩形的充要条件为： 111 、包含 111 个黑色方格 2∗22*22∗2 的正方形恰好有 4...
NOIP2018 DAY1T2 货币系统（背包？）
Michael_GLF的博客
11-10 462
传送门 【题目分析】 唉，三年OI一场空，不刷原题见祖宗。。。qwq 拿着AK巨佬dzy所说的完全背包搞了半天感觉写了个假的。。。。过了氵谷的数据。。。 其实还是很明显，如果一个数可以被其他数表示，那么可以不用。 【代码~】 #include&lt;bits/stdc++.h&gt; using namespace std; const int MAXN=3e4+10; const ...
IOI2018题解
weixin_34323858的博客
02-04 543
只有部分题解 练习赛 T2 自然还是要简单考虑了 0~n-1的排列，考虑相对的大小 我们先考虑对于前三个：a,b,c 询问a,b,询问b,c，再询问a,b,c 发现，如果三个知道两个，那么第三个可以唯一确定 所以分情况讨论一下： 1.a>b，不妨钦定a=n-1，然后得到a,b,c的值，再询问(c,d),(b,c,d)。。。就可以得到所有的值 2.a<b，不...
IOI2018退役记 + NOIP2018游记
whzzt的博客
11-22 7211
图先鸽着。 Day1 在空中感受了一下日本的特别高的森林覆盖率。认识了向导，据说878787个国家至少有13\frac{1}{3}31​的向导是中国人(向导都是筑波大学的留学生)，没有英文水平的选手甚至觉得中文比英文好用(捂脸)。 官方发了两件T恤，一件雨衣，一个made&amp;amp;amp;amp;amp;amp;amp;nbsp;in&amp;amp;amp;amp;amp;amp;amp;nbsp;China\texttt{made in China}made&amp
使用R语言的SOM算法对鸢尾花数据集进行自组织映射分析
最新发布
09-03
在数据科学中，Self-Organizing Maps (SOM) 是一种无监督学习算法，通过自组织神经网络对数据进行聚类和降维。这种算法特别适合处理高维数据，能够将复杂的数据结构映射到低维空间，以便更容易地进行分析和可视化。 首先，我们加载kohonen包，这是R语言中实现SOM算法的主要工具。如果系统中尚未安装该包，我们需要先进行安装。随后，我们使用鸢尾花数据集，这是一种经典的多特征数据集，其中包含150个样本，每个样本有4个特征（花萼长度、花萼宽度、花瓣长度和花瓣宽度），以及一个目标变量（花的品种）。为了提高聚类效果，我们首先对这些特征进行标准化处理，将数据转换为均值为0，方差为1的标准正态分布。 在设置SOM模型时，我们指定了一个5x5的六边形网格。这个网格的选择影响了SOM模型的表现，因为它决定了数据映射的细节。.......
IOI2022Day1：鲶鱼塘问题与比赛须知
"2022IOI国际信息学奥林匹克竞赛Day1" 本文主要介绍的是2022年国际信息学奥林匹克竞赛（IOI）的第一天比赛情况，涉及到的知识点主要与C++编程语言和竞赛规则有关。 首先，参赛者需要注意的是，所有的题目限制都...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

VictoryCzt

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值