练贪心！贪心！贪心！

最新推荐文章于 2024-09-12 23:55:58 发布
最新推荐文章于 2024-09-12 23:55:58 发布
阅读量665 收藏 1
点赞数
分类专栏： 总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heheda_is_an_OIer/article/details/49862745
版权
今天模拟赛好水的一道贪心还想了半天，所以我要练！练！练！
bzoj 1052 覆盖
用三个等大的正方形覆盖所有点，使正方形边长最小
二分边长，贪心判定：用一个最小的矩形覆盖所有点，则第一个正方形的一个顶点一定是矩形的一个顶点，第二个正方形在剩下的点中这个性质依然成立。 
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>

#define ll long long
#define inf 1e9
#define eps 1e-10
#define md
#define N 20010
using namespace std;
struct point { int x,y;} p[N];
int vis[N];
int n,A,B,C,D;
bool jd(int x,int y,int len)
{
	//printf("	jd: %d %d %d\n",x,y,len);
	int A=inf,B=-inf,C=-inf,D=inf;
	for (int i=1;i<=n;i++)
	{
		if (vis[i]==1) continue;
		if (x<=p[i].x&&p[i].x<=x+len&&y<=p[i].y&&p[i].y<=y+len) vis[i]=2;
		else
		{
			A=min(A,p[i].x); B=max(B,p[i].x);
			C=max(C,p[i].y); D=min(D,p[i].y);
		}
	}
	//for (int i=1;i<=n;i++) printf("%d ",vis[i]); printf("\n");
	//printf("		abcd: %d %d %d %d\n",A,B,C,D);
	if (A==inf||(B-A<=len&&C-D<=len)) return 1; else return 0;
}

bool solve(int x,int y,int len)
{
	//printf("solve: %d %d %d\n",x,y,len);
	memset(vis,0,sizeof(vis));
	int A=inf,B=-inf,C=-inf,D=inf;
	for (int i=1;i<=n;i++)
	{
		if (x<=p[i].x&&p[i].x<=x+len&&y<=p[i].y&&p[i].y<=y+len) vis[i]=1;
		else
		{
			A=min(A,p[i].x); B=max(B,p[i].x);
			C=max(C,p[i].y); D=min(D,p[i].y);
		}
	}
	if (A==inf) return 1;
	if (jd(A,D,len)) return 1;
	if (jd(A,C-len,len)) return 1;
	if (jd(B-len,D,len)) return 1;
	if (jd(B-len,C-len,len)) return 1;
	return 0;
}
	
bool ok(int len)
{
	if (solve(A,D,len)) return 1;
	if (solve(A,C-len,len)) return 1;
	if (solve(B-len,D,len)) return 1;
	if (solve(B-len,C-len,len)) return 1;
	return 0;
}
int main()
{
	scanf("%d",&n);
	A=inf; B=-inf; C=-inf; D=inf;
	for (int i=1;i<=n;i++)
	{
		scanf("%d%d",&p[i].x,&p[i].y);
		A=min(A,p[i].x); B=max(B,p[i].x);
		C=max(C,p[i].y); D=min(D,p[i].y);
	}
	int l=1,r=inf;
	while (l!=r)
	{
		int mid=(l+r)>>1;
		if (ok(mid)) r=mid; else l=mid+1;
	}
	printf("%d\n",l);
	return 0;
}
bzoj 2811 覆盖
一个01序列，要求有的区间必须全是0，有的区间必须有1，询问哪些点一定是1.
首先将必须是0的区间删掉，如果这时只剩k个点，直接输出。
通过单调栈留下一些互不包含的区间。
要使放的1最少，一定是依次枚举每个区间，如果当前区间内没有1，就在区间的右端点放上1.然后明显其它的点都是可放可不放的。
用f[i],g[i]分别表示如此做从左往右/从右往左前i个区间放了多少个1.
枚举每一个右端点放1的区间，如果将这个1左移一位之后需要的点数大于k，那么这个点一定要放1，否则不就可以放在左移一位的位置上了吗？
那么如何判断是否大于k？
在i之前的最右面的不覆盖i-1的区间t1的f值加上在i之后最左面的不覆盖i-1的区间t2的g值，再加上i-1的位置放上的1，这样所有的区间都满足要求。也就是如果f[t1]+g[t2]+1>k，就输出第i个区间的右端点。
注意寻找包含区间是最左面的q[i].r>=pos 和最右边的 q[i].l<=pos。 
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>

#define ll long long
#define inf 1e9
#define eps 1e-10
#define md
#define N 100010
using namespace std;
struct data { int l,r,c;} q[N],a[N];
int c[N],is[N],ql[N],qr[N],f[N],g[N];
int n;
bool cmp(data a,data b) { return a.l==b.l?a.r>b.r:a.l<b.l;}
void add(int x,int d)
{
	for (;x<=n;x+=x&(-x)) c[x]+=d;
}
int qsum(int x)
{
	int ans=0;
	for (;x;x-=x&(-x)) ans+=c[x];
	return ans;
}
int main()
{
	int K,m;
	scanf("%d%d%d",&n,&K,&m);
	for (int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&a[i].l,&a[i].r,&a[i].c);
		if (a[i].c==0)
		{
			add(a[i].l,1); add(a[i].r+1,-1);
		}
	}
	int w=0;
	for (int i=1;i<=n;i++)
	{
	  if (qsum(i)==0)
	  {
	  	w++; is[w]=i; ql[i]=w; qr[i]=w;
	  }
	}
	if (w==K) { for (int i=1;i<=K;i++) printf("%d\n",is[i]); return 0;}
	ql[n+1]=inf; for (int i=n;i;i--) if (!ql[i]) ql[i]=ql[i+1];
	for (int i=1;i<=n;i++) if (!qr[i]) qr[i]=qr[i-1];
	//for (int i=1;i<=n;i++) printf("%d %d  ",ql[i],qr[i]); printf("\n");
	int top=0;
	for (int i=1;i<=m;i++) { a[i].l=ql[a[i].l]; a[i].r=qr[a[i].r];} 
	//for (int i=1;i<=m;i++) printf("%d %d %d\n",a[i].l,a[i].r,a[i].c); printf("\n");
	sort(a+1,a+m+1,cmp);
	for (int i=1;i<=m;i++)
	{
		if (a[i].c)
		{
			if (a[i].l>a[i].r) continue;
			while (top&&q[top].l<=a[i].l&&a[i].r<=q[top].r) top--;
			q[++top]=a[i];
		}
	}
	//for (int i=1;i<=top;i++) printf("%d %d\n",q[i].l,q[i].r);
	//q[top+1].l=q[top+1].r=inf;
	int mn=0,mx=inf;
	for (int i=1;i<=top;i++)
	{
		if (mn<q[i].l) { mn=q[i].r; f[i]=f[i-1]+1;}
		  else f[i]=f[i-1];
	}
	for (int i=top;i;i--)
	{
		if (mx>q[i].r) { mx=q[i].l; g[i]=g[i+1]+1;}
		  else g[i]=g[i+1];
	}
	//for (int i=1;i<=top;i++) printf("%d ",f[i]); printf("\n");
	//for (int i=1;i<=top;i++) printf("%d ",g[i]); printf("\n");
	bool hv=0;
	for (int i=1;i<=top;i++)
	{
		if (q[i].l==q[i].r)
		{
			printf("%d\n",is[q[i].l]);
			hv=1;
			continue;
		}
		if (f[i]==f[i-1]) continue;
		else
		{
			int pos=q[i].r-1;
			int l=0,r=top+1;
			while (l!=r)
			{
				int mid=(l+r+1)>>1;
				if (q[mid].r<pos) l=mid; else r=mid-1;
			}
			int t1=l;
			l=t1; r=top+1;
			while (l!=r)
			{
				int mid=(l+r)>>1;
				if (q[mid].l>pos) r=mid; else l=mid+1;
			}
			int t2=l;
			if (f[t1]+g[t2]+1>K)
			{
				printf("%d\n",is[q[i].r]);
				hv=1;
			}
		}
	}
	if (!hv) printf("-1\n");
	return 0;
}
bzoj 1367 sequence
练贪心！贪心！贪心！ - zc - zc的博客
首先对于递增序列，a[i]减去i，然后就变成不下降序列。这样z数组就是几段单调递增的连续的数，就像1122234455这样。然后如果第i段数的中位数小于第i-1段数，那么就合并这两个区间，然后这个区间的答案变成这个区间的中位数。这个操作可以用可并堆维护。 因为第i个区间的中位数单调不降，所以只需要维护最大的size/2个数 
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>

#define ll long long
#define inf 1e9
#define eps 1e-10
#define md
#define N 1000010
using namespace std;
int a[N],v[N],lx[N],rx[N],sz[N],dis[N],root[N],L[N],R[N];
struct left_tree
{
	int top(int x)
	{
		return v[x];
	}
	int merge(int x,int y)
	{
		if (!x) return y;
		if (!y) return x;
		if (v[x]<v[y]) swap(x,y);
		rx[x]=merge(rx[x],y);
		sz[x]=sz[lx[x]]+sz[rx[x]]+1;
		if (dis[rx[x]]>dis[lx[x]]) swap(lx[x],rx[x]);
		dis[x]=dis[rx[x]]+1;
		return x;
	}
} heap;

int main()
{
	int n;
	scanf("%d",&n);
	for (int i=1;i<=n;i++) { scanf("%d",&a[i]); a[i]-=i; }
	int top=0;
	for (int i=1;i<=n;i++)
	{
		sz[i]=dis[i]=1; lx[i]=rx[i]=0; v[i]=a[i];
		root[++top]=i; L[top]=R[top]=i;
		while (top>1&&heap.top(root[top-1])>heap.top(root[top]))
		{
			top--;
			root[top]=heap.merge(root[top],root[top+1]);
			R[top]=R[top+1];
			int tot=R[top]-L[top]+1;
			while (sz[root[top]]*2>tot+1) root[top]=heap.merge(lx[root[top]],rx[root[top]]);
		}
		//for (int j=1;j<=top;j++) printf("L: %d  R: %d mid: %d\n",L[j],R[j],heap.top(root[j])); printf("\n");
	}
	ll ans=0;
	for (int i=1;i<=top;i++)
	{
		int mid=heap.top(root[i]); //printf("\nL:%d R:%d mid: %d\n",L[i],R[i],mid);
		for (int j=L[i];j<=R[i];j++) ans+=abs(a[j]-mid); //printf("%d %d   ",a[j],mid);
	}//printf("\n");
	printf("%lld\n",ans);
	return 0;
}
bzoj 2288 礼物
从一个序列中选出至少m个区间，使他们的和最大
表示看到这道题的第一反应是那道被讲了好多遍的用线段树维护增广路
首先将连续的正数合并，连续的负数合并，答案等于所有正数的和。
维护一个堆，每次找出绝对值最小的区间，答案减去这个绝对值，然后将这个区间，它左面的区间，它右面的区间合并。这样子，堆中的元素就是选与不选交错，正数与负数交错（因为合并前两边数的绝对值大于这个数）。
选择一个负数，相当于选上这段区间，选择一个正数，相当于不选这个区间，这都能使区间数减一。
考虑边界，第一个和最后一个区间出堆之后，如果是正数，就去掉这个区间，答案减去。如果是负数，不但不会减少区间数，还会使答案变小，所以直接忽略
删除任意一个数，不想手写堆，写了set
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<set>
#define ll long long
#define inf 1e9
#define eps 1e-10
#define md
#define N 100010
using namespace std;
int a[N],q[N],pre[N],ne[N];
struct data { int sm,pos,ab; };
struct cmp
{
bool operator () (data a,data b)
{
return a.ab==b.ab? a.pos<b.pos:a.ab<b.ab;
}
};
set<data,cmp> st;
int main()
{
int n,m;
scanf("%d%d",&n,&m);
int w=0;
for (int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
if (a[i]==0) { i--; n--; continue; }
if (a[i]*a[i-1]>0) q[w]+=a[i];
else q[++w]=a[i];
}
n=w; int ans=0,tot=0;
memset(a,0,sizeof(a));
for (int i=1;i<=n;i++)
{
a[i]=q[i];
if (a[i]>0) { ans+=a[i]; tot++; }
pre[i]=i-1; ne[i]=i+1;
data x=(data) { a[i],i,abs(a[i])}; st.insert(x); //printf("insert: %d\n",x.ab);
}
//for (set<data,cmp>::iterator i=st.begin();i!=st.end();i++) printf("%d ",(*i).ab); printf("\n");
if (tot<=m)
{
printf("%d\n",ans);
return 0;
}
while (tot>m)
{
data x=*st.begin();
int pos=x.pos,sm=x.sm; //printf("erase: %d %d\n",pos,sm);
int L=pre[pos],R=ne[pos];
if (L<1)
{
pre[R]=pre[pos];
if (sm>0) { tot--; ans-=x.ab; st.erase(x); }
else { st.erase(x); }
}
else if (R>n)
{
ne[L]=ne[pos];
if (sm>0) { tot--; ans-=x.ab; st.erase(x); }
else { st.erase(x); }
}
else
{
ans-=x.ab;
a[pos]=a[L]+a[R]+a[pos];
st.erase(x);
data y=(data) {a[L],L,abs(a[L])}; st.erase(y);
y=(data) {a[R],R,abs(a[R])}; st.erase(y);
x.sm=a[pos]; x.ab=abs(a[pos]); st.insert(x);
pre[pos]=pre[L]; ne[pre[L]]=pos;
ne[pos]=ne[R]; pre[ne[R]]=pos;
tot--;
}
}
printf("%d\n",ans);
return 0;
}
bzoj 4198 荷马史诗
这是一道裸的k叉哈夫曼树，每次找到权值最小的k个数合并成一个新节点，答案加上这些权值和。
要求深度最小，只需要让深度最小的先出堆。
然后将点数补成(k-1)*d+1 
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#define ll long long
#define inf 1e9
#define eps 1e-10
#define md
#define N 100500
using namespace std;
struct data { ll dt; int dep; } a[N];
struct cmp
{
	bool operator () (data a,data b) { return a.dt==b.dt?a.dep>b.dep:a.dt>b.dt;}
};
priority_queue<data,vector<data>,cmp> q;
int main()
{
	int n,k; 
	scanf("%d%d",&n,&k);
	for (int i=1;i<=n;i++) { scanf("%lld",&a[i].dt); a[i].dep=1;} 
	while (k!=2&&(n%(k-1))!=1) { n++; a[n].dep=a[n].dt=0; }
	for (int i=1;i<=n;i++) q.push(a[i]);
	ll ans=0;
	while (q.size()!=1)
	{
		ll sum=0; int mxdep=0;
		data x;
		for (int i=1;i<=k;i++)
		{
			x=q.top(); q.pop(); //printf("pop: %lld %d\n",x.dt,x.dep);
			sum+=x.dt; mxdep=max(mxdep,x.dep);
		}
		x.dt=sum; x.dep=mxdep+1; ans+=sum;
		q.push(x);
	}
	printf("%lld\n%d\n",ans,(q.top()).dep-1);
	return 0;
}

heheda_is_an_OIer
关注
专栏目录
贪心
j1124911538的博客
07-21 912
                                                贪心 先奉上一段千古名言：                 模拟只会猜题意, 贪心只能过样例, 数学上来先打表, DP一般看规律。 组合数学靠运气, 计算几何瞎暴力, 图论一顿套模板, 数论只会GCD。   好了言归正传,我们来讲一下贪心的概念：          贪心是一种策略...
贪心练习题
NK小米
04-02 202
好久没发微博了，主要是没时间。 今天整理一下发出来。 这篇文章中的代码都用了O2优化——头文件下一行。 首先是最经典的排队打水不同点在于是多个水龙头，题目就不用描述了。直接给代码 #include<bits/stdc++.h> #pragma GCC optimize(2) using namespace std; int n, r, sum = 0; int t[1001],w[1001]; int main() { cin>>n>>r; for (int i=
用贪心算法解决背包问题
2301_76572283的博客
05-22 2002
设有背包问题时实例n=7，m=15，（w0，w1，...，w6）=（2，3，5，7，1，4，1），物品装入背包的收益为：（p0，p1，...，p6）=（10，5，15，7，6，18，13）。先选入1号物品，再选入2号物品，但由于背包的容量剩余20-15=5，因此2号物品装入1/2，0号物品不装入，这样得到的解为（x0，x1，x2）=（0，1，1/2），它的总收益为31.5，总收益最大。贪心算法只是一种算法，它是基于贪心策略来编写的算法，贪心算法可以看作是贪心策略的具象化，算法是具体的，策略是模糊的。
贪心算法讲解
学代码的咸鱼的博客
04-30 4172
一些贪心算法的练习题！
详解贪心算法
最新发布
Weiki的博客
09-12 1201
算法：贪心算法
贪心算法、分治算法和动态规划的区别 贪心算法和动态规划.pdf
04-08
贪心算法、分治算法和动态规划的区别 贪心算法、分治算法和动态规划是三种常用的算法设计策略，每种算法都有其特点和应用场景。下面我们将对这三种算法进行详细的比较和分析。 分治算法 分治算法是一种将原问题...
RogerPoirier.github.io:我的贪心网站！
05-15
【标题】"RogerPoirier.github.io:我的贪心网站！"揭示了这是一份与个人网站相关的项目，由GitHub用户RogerPoirier创建。这个网站可能是他的个人作品集、博客或者是用来展示技术能力的平台。GitHub上的项目通常用于...
贪心算法1
08-03
贪心算法是一种优化策略，它在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而希望导致结果是全局最好或最优。贪心算法的特点是不考虑问题的整体最优解，而是每一步都追求局部最优解，希望这些...
贪心算法和动态规划以及分治法的区别？ (1) 贪心算法和动态规划.pdf
04-08
贪心算法、动态规划和分治法的区别 贪心算法是局部最优解的算法，它通过从上往下，从顶部一步一步最优，得到最后的结果。贪心算法顾名思义，就是做出在当前看来是最好的结果，它不从整体上加以考虑，也就是局部最优...
实验2装箱问题-贪心算法
05-23
实验2装箱问题-贪心算法 在本实验中，我们将学习贪心算法的设计和实现，以解决装箱问题。贪心算法是一种常用的近似算法，通过选择当前最优解来逐步构建解决方案。 问题描述 装箱问题是计算机科学中的一类经典问题...
CTSC&&APIO2016 旅游记&&被坑记
heheda_is_an_OIer的博客
05-10 3122
在帝都将近十天，回家之际，有一丝急迫，也有一丝眷恋。 5.1 CTSC day0         坐前一天晚上的火车，很早就到达了北京，倒了3班地铁+一班公交到达了目的地，被yts大爷领着绕了一个大圈才到宾馆，累成狗。         宾馆很高级，房间里面有70元一瓶的水，冰箱里还有各种饮料（当然是喝不起的啦），床软的可怕。睡了1个小时，人还是虚的，背了一点板子。         中午被叫
蒟蒻的noip2015滚粗记
heheda_is_an_OIer的博客
11-16 2313
oi就是一场实力与运气的博弈——题记        也不知道这会不会是自己的最后一年noip，也不知道2016夏绵阳见是什么样子。但是，第三年的noip，还是值得回味的。 Day 0        又是一个阴雨连绵日，和往常不一样的是我弃掉了周五上午的课，回家学(tui)习(fei)。花了一个小时交上了屯题，在学校群里装了装逼。喝了一大碗羊汤，就出发了。        在车上，我们一对一对
heheda练数据结构
heheda_is_an_OIer的博客
11-20 2289
联赛结束，自己的码力已经下降了不知多少个档次，再加上最近空闲时间比较多，我就开启了这个可以说最费时间的专题。 //话说我未完成的数论专题还会继续的。 最近看了以下知识点： 线段树套线段树 线段树套平衡树 准备学习： 替罪羊树 块状链表 复习： 树链剖分 树状数组套线段树 一些高级的线段树 可持久化tire 可并堆 bzoj 2957 楼房重建 给定第一象限的n
SDOI2016r1游记
heheda_is_an_OIer的博客
04-12 1831
做梦一般，SDOIR1就过去了，成绩不错，但总有一些小的细节不是太如意。 Day0 早上10点的火车，在车上和同学聊了一些奇奇怪怪的题，就到了济南，然后报道。感觉自己整个人都hai起来了。晚上写了一道题，背背板子，就睡觉了。 Day1 抽签，发现我们学校只有我,Oxer,davidxu在第二考场，但是感觉外校的神犇好多呀。 进入考场，敲完头文件、对拍之后就不知道干什么了，干坐了10分钟，
WC2016——还是认真练码力吧
heheda_is_an_OIer的博客
02-05 1486
从绵阳回来也好几天了，一直不忍心面对自己烂成狗的比赛成绩，但是该总结还是要总结的，顺便列一列之后的计划 游记 第一次去四川，走之前一个月就缠着老师说要去成都爽一发，然后就去吃了好多好吃的，也发现自认为不能吃辣的我还是蛮能吃的。老师推荐的辣牛肉，超级够味的成都火锅，尤其是白菜！！！还有很多甜品：三大炮，菠萝饭，还有很多叫不上名字的好吃的。最好玩的是那里的东西都愿意加上个姓，例如赖汤圆、钟水饺，还
主席树&树状数组套主席树
heheda_is_an_OIer的博客
11-16 1228
主席树是一种利用前缀和维护形如（l主席树的最经典应用是维护区间第k小值，大体思路是维护root[r]-root[l-1]范围内的线段树，用各种方法乱搞。带修改：高能的树状数组套主席树（更疯狂的nlog^2(n)的空间复杂度）。树状数组的每一个节点维护的是一段区间，我们将这每一个区间建成一颗线段树（利用主席树降一点内存和时间）。这时候修改只需要修改logn个线段树即可，时间复杂度log^2(n)。注
第一篇博文，总结这一年的比赛
heheda_is_an_OIer的博客
11-16 869
看到学校里各大神犇 wyw,zzb,dms开了博客之后，蒟蒻我也忍不住了（我会说一个半月前在东营我就想开博客了吗？）     noip2014 ——高中首战  一场上古时期的比赛。 那时的我真的好弱，连bird的正解都想不到，还写挂了35分…… 总体发挥还可以，没什么遗憾的。   sdoi2015 round1 day1： t1 想到正解又把自己否定了，30min+敲完暴力。 看第
容斥原理
heheda_is_an_OIer的博客
11-16 845
容斥原理主要有三种题型：小学生容斥，合法的方案数，...等于k的方案数。大体思路是先利用各种稀奇古怪的方法求出包含不合法或者重复计算了的，但是比较好求的东西，然后套以下三种方法：小学生容斥就是统计一些东西，再减去重复统计的。合法的方案数就是ans1-ans2+ans3-ans4……等于k的方案数就是  for (int i=n;i>k;i--)     for (int j=1;j
heheda的数论专题练习
heheda_is_an_OIer的博客
11-16 696
膜拜sd数论之神yts1999bzoj 2956 模积和这是bzoj第300道题，纪念一下再说其实并不难，把n%i变成n-(n/i)*i，然后不考虑i!=j就是n^2*m^2-n^2*sigma( (m/j)*j )-m^2*sigma( (n/i)*i )+sigma(i*j*(n/i)*(m/j)) i是从1到n枚举，j是从1到m枚举减去i=j情况n^2*m-n*sigma( (m/i)*i
贪心算法详解与应用
“贪心算法ppt”是一份详细讲解贪心算法的PPT，内容包括了贪心算法的概念、应用以及如何使用贪心算法解决问题的方法。 贪心算法是一种在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而希望导致...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值