HDU-3416 Marriage Match IV(最短路+最大流)

最新推荐文章于 2020-07-26 00:03:03 发布
最新推荐文章于 2020-07-26 00:03:03 发布
阅读量288 收藏 1
点赞数 1
分类专栏： 优秀算法总结 网络流 最、次、K短路 HDU 文章标签： 最大流 最短路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yo_bc/article/details/78083939
版权
HDU 同时被 3 个专栏收录
92 篇文章 0 订阅
订阅专栏
优秀算法总结
84 篇文章 6 订阅
订阅专栏
网络流
20 篇文章 0 订阅
订阅专栏

题意：

starvae在A城市想去B城市看他若干个女朋友，有m条有向边连着n个城市，但是他想走最短路，但每条路只能走一次，他想知道他能走多少条完全不同最短路去看他的女朋友们。

思路：

这题我们只能先把所有的最短路径求出来，然后把每条带权的路变成容量为1的网络边，然后求一个最大流即可。

怎么抽离出所有的最短路径呢，可以通过只求一次求从A到B的最短路，然后枚举每条边，判断是否满足dis[v] == dis[u]+1，然后建立网络图，虽然仍会有多余的边，但该流向B点的仍然会流向B点，不该流向B点的仍然不会流向B点。

也可以通过跑两次最短路，求出A点到所有点的最短路dis[0][i]，和B点到所有点的最短路(反向边去求)dis[1][i]，然后枚举每条边，判断是否满足dis[0][u]+dis[1][v]+w[u][v] == dis[0][B]，然后建立网络图，这样所有的边恰好都是最短路径上的边了。(只能该方法处理出所有具体的最短路径)

也可以通过一个pre数组在dijistra算法上记录最短路径的走向，最后通过A点走过去也能得到所有的最短路径(也会有多余的)。

另外dinic会超时，SAP才可以过，以后乖乖用SAP吧...

代码1：

#include <algorithm>  
#include <iostream>  
#include <string.h>  
#include <cstdio>  
#include <queue>  
using namespace std;  
const int inf = 0x3f3f3f3f;  
const int maxn = 1005;  
const int maxm = 200005;
struct node{int v, w, next;} edge[maxm];  
int dis[maxn], pre[maxn], rec[maxn], head[maxn], gap[maxn], now[maxn];  
int t, n, m, no, up;  
int S, T;
queue<int> q;

struct node1
{
	int v, w, next;
	bool operator<(const node1 k)const
	{
		return w > k.w;
	}
} edge1[maxm];
int no1, head1[maxn];
int vis1[maxn], dis1[maxn];
priority_queue<node1> q1;
void init1()
{
	no1 = 0;
	memset(head1, -1, sizeof head1);
}
inline void add1(int u, int v, int w)
{
	edge1[no1].v = v; edge1[no1].w = w;
	edge1[no1].next = head1[u]; head1[u] = no1++;
}

inline void add(int u, int v, int w)  
{  
    edge[no].v = v; edge[no].w = w;  
    edge[no].next = head[u]; head[u] = no++;  
    edge[no].v = u; edge[no].w = 0;  
    edge[no].next = head[v]; head[v] = no++;  
}  
inline void pre_init()  
{  
    no = 0;
    memset(head, -1, sizeof head);  
}  
void init(int S, int T)  
{  
    memset(gap, 0, sizeof gap);  
    memset(dis, 0x3f, sizeof dis);  
    for(int i = 0; i <= n; ++i)   
    now[i] = head[i];
    while(!q.empty()) q.pop();  
    dis[T] = 0; q.push(T);  
    while(!q.empty()) 
    {  
        int tp = q.front(); q.pop();  
        ++gap[dis[tp]];  
        int k = head[tp];  
        while(k != -1)  
        {  
            if(dis[edge[k].v] == inf && edge[k^1].w)  
            {  
                dis[edge[k].v] = dis[tp]+1;  
                q.push(edge[k].v);  
            }  
            k = edge[k].next;  
        }  
    }  
}  
int SAP(int S, int T)  
{  
	up = n;
    int ans = 0, flow = inf, top = S;  
    pre[S] = S; init(S, T);  
    while(dis[S] < up)
    {
        if(top == T)  
        {  
            ans += flow;  
            while(top != S)
            {  
                edge[rec[top]].w -= flow;  
                edge[rec[top]^1].w += flow;  
                top = pre[top];  
            }  
            flow = inf;  
        }  
        int k = now[top];  
        while(k != -1)  
        {  
            int v = edge[k].v;  
            if(edge[k].w && dis[top] == dis[v]+1)  
            {  
                flow = min(flow, edge[k].w);  
                pre[v] = top; rec[v] = k;  
                now[top] = k; top = v;  
                break;  
            }  
            k = edge[k].next;  
        }  
        if(k == -1)  
        {  
            int mind = up;  
            if(--gap[dis[top]] == 0) break;
            int k = now[top] = head[top];
            while(k != -1)  
            {  
                if(edge[k].w && mind>dis[edge[k].v]) mind = dis[edge[k].v];  
                k = edge[k].next;  
            }  
            ++gap[dis[top] = mind+1];  
            top = pre[top];  
        }  
    }  
    return ans;  
} 

void DJ()
{
	while(!q1.empty()) q1.pop();
	memset(vis1, 0, sizeof vis1);
	memset(dis1, 0x3f, sizeof dis1);
	q1.push((node1){S, 0, -1});
	dis1[S] = 0;
	while(!q1.empty())
	{
		node1 tp = q1.top(); q1.pop();
		int u = tp.v;
		if(vis1[u]) continue;
		vis1[u] = 1;
		for(int k = head1[u]; k+1; k = edge1[k].next)
		{
			int v = edge1[k].v;
			if(dis1[v] > dis1[u]+edge1[k].w)
			{
				dis1[v] = dis1[u]+edge1[k].w;
				q1.push((node1){v, dis1[v], -1});
			}
		}
	}
}
void work()
{
	DJ();
	for(int i = 1; i <= n; ++i)
	for(int k = head1[i]; k+1; k = edge1[k].next)
	{
		int v = edge1[k].v;
		if(dis1[v] == dis1[i]+edge1[k].w)
		add(i, v, 1); 
	} 
	printf("%d\n", SAP(S, T)); 
}

int main()  
{ 
    for(scanf("%d", &t); t--;)
	{
		scanf("%d %d", &n, &m);
		init1(); pre_init();  
		for(int i = 1; i <= m; ++i)
		{
			int u, v, w;
			scanf("%d %d %d", &u, &v, &w);
			if(u == v) continue;
			add1(u, v, w);
		}
		scanf("%d %d", &S, &T);
		work();
	}
    return 0;  
}


代码2：

#include <algorithm>  
#include <iostream>  
#include <string.h>  
#include <cstdio>  
#include <queue>  
using namespace std;  
const int inf = 0x3f3f3f3f;  
const int maxn = 1005;  
const int maxm = 200005;
struct node{int v, w, next;} edge[maxm];  
int dis[maxn], pre[maxn], rec[maxn], head[maxn], gap[maxn], now[maxn];  
int t, n, m, no, up;  
int S, T;
queue<int> q;

struct node1
{
	int u, v, w, next;
	bool operator<(const node1 k)const
	{
		return w > k.w;
	}
} edge1[2][maxm];
int no1[2], head1[2][maxn];
int vis1[2][maxn], dis1[2][maxn];
priority_queue<node1> q1[2];
void init1()
{
	no1[0] = no1[1] = 0;
	memset(head1[0], -1, sizeof head1[0]);
	memset(head1[1], -1, sizeof head1[1]);
}
inline void add1(int key, int u, int v, int w)
{
	edge1[key][no1[key]].u = u; 
	edge1[key][no1[key]].v = v; 
	edge1[key][no1[key]].w = w;
	edge1[key][no1[key]].next = head1[key][u]; 
	head1[key][u] = no1[key]++;
}

inline void add(int u, int v, int w)  
{  
    edge[no].v = v; edge[no].w = w;  
    edge[no].next = head[u]; head[u] = no++;  
    edge[no].v = u; edge[no].w = 0;  
    edge[no].next = head[v]; head[v] = no++;  
}  
inline void pre_init()  
{  
    no = 0;
    memset(head, -1, sizeof head);  
}  
void init(int S, int T)  
{  
    memset(gap, 0, sizeof gap);  
    memset(dis, 0x3f, sizeof dis);  
    for(int i = 0; i <= n; ++i)   
    now[i] = head[i];
    while(!q.empty()) q.pop();  
    dis[T] = 0; q.push(T);  
    while(!q.empty()) 
    {  
        int tp = q.front(); q.pop();  
        ++gap[dis[tp]];  
        int k = head[tp];  
        while(k != -1)  
        {  
            if(dis[edge[k].v] == inf && edge[k^1].w)  
            {  
                dis[edge[k].v] = dis[tp]+1;  
                q.push(edge[k].v);  
            }  
            k = edge[k].next;  
        }  
    }  
}  
int SAP(int S, int T)  
{  
	up = n;
    int ans = 0, flow = inf, top = S;  
    pre[S] = S; init(S, T);  
    while(dis[S] < up)
    {
        if(top == T)  
        {  
            ans += flow;  
            while(top != S)
            {  
                edge[rec[top]].w -= flow;  
                edge[rec[top]^1].w += flow;  
                top = pre[top];  
            }  
            flow = inf;  
        }  
        int k = now[top];  
        while(k != -1)  
        {  
            int v = edge[k].v;  
            if(edge[k].w && dis[top] == dis[v]+1)  
            {  
                flow = min(flow, edge[k].w);  
                pre[v] = top; rec[v] = k;  
                now[top] = k; top = v;  
                break;  
            }  
            k = edge[k].next;  
        }  
        if(k == -1)  
        {  
            int mind = up;  
            if(--gap[dis[top]] == 0) break;
            int k = now[top] = head[top];
            while(k != -1)  
            {  
                if(edge[k].w && mind>dis[edge[k].v]) mind = dis[edge[k].v];  
                k = edge[k].next;  
            }  
            ++gap[dis[top] = mind+1];  
            top = pre[top];  
        }  
    }  
    return ans;  
} 

void DJ(int key)
{
	while(!q1[key].empty()) q1[key].pop();
	memset(vis1[key], 0, sizeof vis1[key]);
	memset(dis1[key], 0x3f, sizeof dis1[key]);
	if(key == 0)
	{
		q1[key].push((node1){-1, S, 0, -1});
		dis1[key][S] = 0;
	}
	else
	{
		q1[key].push((node1){-1, T, 0, -1});
		dis1[key][T] = 0;
	}
	while(!q1[key].empty())
	{
		node1 tp = q1[key].top(); q1[key].pop();
		int u = tp.v;
		if(vis1[key][u]) continue;
		vis1[key][u] = 1;
		for(int k = head1[key][u]; k+1; k = edge1[key][k].next)
		{
			int v = edge1[key][k].v;
			if(dis1[key][v] > dis1[key][u]+edge1[key][k].w)
			{
				dis1[key][v] = dis1[key][u]+edge1[key][k].w;
				q1[key].push((node1){-1, v, dis1[key][v], -1});
			}
		}
	}
}
void work()
{
	DJ(0); DJ(1);
	int noo = no1[0];
	for(int i = 0; i < noo; ++i)
	{
		int u = edge1[0][i].u, v = edge1[0][i].v;
		if(dis1[0][u]+dis1[1][v]+edge1[0][i].w  == dis1[0][T])
		add(u, v, 1); 
	} 
	printf("%d\n", SAP(S, T)); 
}

int main()  
{ 
    for(scanf("%d", &t); t--;)
	{
		scanf("%d %d", &n, &m);
		init1(); pre_init();  
		for(int i = 1; i <= m; ++i)
		{
			int u, v, w;
			scanf("%d %d %d", &u, &v, &w);
			if(u == v) continue;
			add1(0, u, v, w);
			add1(1, v, u, w); 
		}
		scanf("%d %d", &S, &T);
		work();
	}
    return 0;  
}


代码3：

#include <unordered_set>
#include <algorithm>  
#include <iostream>  
#include <string.h>  
#include <cstdio>  
#include <queue>  
using namespace std;  
const int inf = 0x3f3f3f3f;  
const int maxn = 1005;  
const int maxm = 200005;
struct node{int v, w, next;} edge[maxm];  
int dis[maxn], pre[maxn], rec[maxn], head[maxn], gap[maxn], now[maxn];  
int t, n, m, no, up;  
int S, T;
queue<int> q;

struct node1
{
	int v, w, next;
	bool operator<(const node1 k)const
	{
		return w > k.w;
	}
} edge1[maxm];
int no1, head1[maxn];
int vis1[maxn], dis1[maxn];
unordered_set<int> G[maxn];
priority_queue<node1> q1;
queue<int> Q;
void init1()
{
	no1 = 0;
	memset(head1, -1, sizeof head1);
}
inline void add1(int u, int v, int w)
{
	edge1[no1].v = v; edge1[no1].w = w;
	edge1[no1].next = head1[u]; head1[u] = no1++;
}

inline void add(int u, int v, int w)  
{  
    edge[no].v = v; edge[no].w = w;  
    edge[no].next = head[u]; head[u] = no++;  
    edge[no].v = u; edge[no].w = 0;  
    edge[no].next = head[v]; head[v] = no++;  
}  
inline void pre_init()  
{  
    no = 0;
    memset(head, -1, sizeof head);  
}  
void init(int S, int T)  
{  
    memset(gap, 0, sizeof gap);  
    memset(dis, 0x3f, sizeof dis);  
    for(int i = 0; i <= n; ++i)   
    now[i] = head[i];
    while(!q.empty()) q.pop();  
    dis[T] = 0; q.push(T);  
    while(!q.empty()) 
    {  
        int tp = q.front(); q.pop();  
        ++gap[dis[tp]];  
        int k = head[tp];  
        while(k != -1)  
        {  
            if(dis[edge[k].v] == inf && edge[k^1].w)  
            {  
                dis[edge[k].v] = dis[tp]+1;  
                q.push(edge[k].v);  
            }  
            k = edge[k].next;  
        }  
    }  
}  
int SAP(int S, int T)  
{  
	up = n;
    int ans = 0, flow = inf, top = S;  
    pre[S] = S; init(S, T);  
    while(dis[S] < up)
    {
        if(top == T)  
        {  
            ans += flow;  
            while(top != S)
            {  
                edge[rec[top]].w -= flow;  
                edge[rec[top]^1].w += flow;  
                top = pre[top];  
            }  
            flow = inf;  
        }  
        int k = now[top];  
        while(k != -1)  
        {  
            int v = edge[k].v;  
            if(edge[k].w && dis[top] == dis[v]+1)  
            {  
                flow = min(flow, edge[k].w);  
                pre[v] = top; rec[v] = k;  
                now[top] = k; top = v;  
                break;  
            }  
            k = edge[k].next;  
        }  
        if(k == -1)  
        {  
            int mind = up;  
            if(--gap[dis[top]] == 0) break;
            int k = now[top] = head[top];
            while(k != -1)  
            {  
                if(edge[k].w && mind>dis[edge[k].v]) mind = dis[edge[k].v];  
                k = edge[k].next;  
            }  
            ++gap[dis[top] = mind+1];  
            top = pre[top];  
        }  
    }  
    return ans;  
} 

void DJ()
{
	while(!q1.empty()) q1.pop();
	memset(vis1, 0, sizeof vis1);
	memset(dis1, 0x3f, sizeof dis1);
	q1.push((node1){S, 0, -1});
	dis1[S] = 0;
	while(!q1.empty())
	{
		node1 tp = q1.top(); q1.pop();
		int u = tp.v;
		if(vis1[u]) continue;
		vis1[u] = 1;
		for(int k = head1[u]; k+1; k = edge1[k].next)
		{
			int v = edge1[k].v;
			if(dis1[v] > dis1[u]+edge1[k].w)
			{
				dis1[v] = dis1[u]+edge1[k].w;
				G[v].clear();
				G[v].insert(u);
				q1.push((node1){v, dis1[v], -1});
			}
			else if(dis1[v] == dis1[u]+edge1[k].w) G[v].insert(u);
		}
	}
}
void work()
{
	DJ();
	while(!Q.empty()) Q.pop();
	memset(vis1, 0, sizeof vis1);
	Q.push(S); vis1[S] = 1;
	while(!Q.empty())
	{
		int u = Q.front(); Q.pop();
		for(int k = head1[u]; k+1; k = edge1[k].next)
		{
			int v = edge1[k].v;
			if(G[v].find(u) != G[v].end() && dis1[v] == dis1[u]+edge1[k].w)
			{
				add(u, v, 1);
				if(!vis1[edge1[k].v])
				vis1[v] = 1, Q.push(v);
			}
		}
	}
	printf("%d\n", SAP(S, T)); 
}

int main()  
{ 
    for(scanf("%d", &t); t--;)
	{
		scanf("%d %d", &n, &m);
		init1(); pre_init();  
		for(int i = 1; i <= m; ++i)
		{
			int u, v, w;
			scanf("%d %d %d", &u, &v, &w);
			if(u == v) continue;
			add1(u, v, w);
		}
		scanf("%d %d", &S, &T);
		work();
	}
    return 0;  
}


继续加油~

薄层
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU-3416-Marriage Match IV(不相交最短路径数目）
qq_42576687的博客
02-03 460
HDU3416 题意： 有n个城市，m条边，a到b耗费为c，为单向边。要求从s到t的最短路径有多少条，每一条边只能走一次。 思路:把每条最短路经过的边加到网络流的图中,跑一个最大流就是条数,因为不相交,则边容量为1. #include &amp;amp;amp;amp;lt;cstdio&amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;lt;queue&amp;amp;amp;amp;gt; #include &
HDU - 3416 Marriage Match IV （最大流）
静静地码
08-03 900
题目大意：有个人要从A城市去B城市，每条路只允许走一次，问能走几次最短路解题思路：这题的话，难点就是怎么知道是不是最短路了 首先，先求出到B最短路，这也顺便求出了所有点到B的最短距离 接着求出到A的最短路 这样就能得到两个数组了,假设d1[u]代表u节点到A城市的最短路d2[v]代表v节点到城市B的最短距离 如果满足d1[u] + dis[u][v] + d2[v] == d1[v]的话，那
HDU3416 Marriage Match IV —— 最短路径 + 最大流
alince20008的博客
12-30 146
题目链接：https://vjudge.net/problem/HDU-3416 Marriage Match IV Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 4710Accepted Submission...
HDU-3416 Marriage Match IV （最短路+最大流）
帅帅的博客
08-17 321
Marriage Match IV 题目链接：Marriage Match IV HDU - 3416 题意 给你一个图，问有多少条不同的最短路，有重边并且可当作分开的两边，其多条最短路之间不能有任何相同的边 思路 开始时，看到了每条边只能经过一次，我想到了费用流，可惜这里的数据不小，N为1000，M为1e5，按照费用流平均复杂度，F * E * log（v） 毫无疑问会T，那么...
HDU 3416 Marriage Match IV
枫叶回忆
05-17 1127
<br />2011-05-17<br />21:01:42Marriage Match IV<br />Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)<br />Total Submission(s): 709    Accepted Submission(s): 188<br /><br />Problem DescriptionDo not sincere non-interfere
最短路（HDU-2544）.rar
09-16
《最短路问题详解》 在计算机科学领域，最短路问题是一个经典的图论问题，其目标是寻找网络中两点间路径的最小成本。这个问题在众多应用中都有所体现，如交通规划、通信网络设计、社交网络分析等。在本篇内容中，...
HDU-2000-2099.rar_hdu
09-19
HDU（杭州电子科技大学在线评测系统）是一个知名的编程竞赛平台，为编程爱好者提供了大量的算法题目进行练习和比赛。这个名为"HDU-2000-2099.rar_hdu"的压缩包包含了该平台从2000到2099共100道题目的源代码。这些...
HDU-2000-2099.zip_hdu2000
09-23
【标题】"HDU-2000-2099.zip_hdu2000" 是一个包含杭电（Hangzhou Dianzi University）ACM竞赛题目解题报告的压缩包，覆盖了编号从2000到2099的题目。这个资源对于学习算法、提高编程技巧以及准备ACM/ICPC（国际大学...
HDU 3416
tanmlh的专栏
07-23 549
Marriage Match IV Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 2470    Accepted Submission(s): 742 Problem Description Do not si
HDU 3416 Marriage Match IV（最短路+最大流）
Remilia's
11-11 885
HDU 3416 Marriage Match IV 题目链接 题意：给一个有向图，给定起点终点，问最多多少条点可以重复，边不能重复的最短路 思路：边不能重复，以为着每个边的容量就是1了，最大流问题，那么问题只要能把最短路上的边找出来，跑一下最大流即可，判断一条边是否是最短路上的边，就从起点和终点各做一次dijstra，求出最短路距离后，如果一条边满足d1[u] + d2[v]
Marriage Match IV
sky123博客
05-14 163
Do not sincere non-interference。 Like that show, now starvae also take part in a show, but it take place between city A and B. Starvae is in city A and girls are in city B. Every time starvae can get to city B and make a data with a girl he likes. But ther
Marriage Match IV （最大流+最短路+Dijkstra）
sdau20163940的博客
02-09 365
Do not sincere non-interference。 Like that show, now starvae also take part in a show, but it take place between city A and B. Starvae is in city A and girls are in city B. Every time starvae can get ...
【Q - Marriage Match IV】
Masker
05-30 219
思路： 最短路找出允许走的路，然后跑一遍网络流找出从源点到汇点有多少流量。 Dijkstra，Dinic（Edmonds-Karp会TLE）。 (第一道网络流，后续会写总结。) 代码： Dijkstra+Edmonds-Karp：TLE #include <iostream> #include <queue> #include <cstring> #in...
Marriage Match IV (hdu 3416 网络流+spfa最短路)
@you！
04-25 1149
题意：有n个城市m条边，告诉起点和终点，问从起点到终点不走重复边的最短路有多少条。 思路：求最短路的条数可以用最大流，建图时要去掉不是最短路上的边，判断某条边是不是最短路上的边：如果满足dist1[u] + dist2[v] + E1[i].len = dist1[End]则可以说明该边是最短路上的边，其中 dist1[] 为各点到起点的最短距离，dist2[] 为各点到终点的最短距离。
HDU 3416 Marriage Match IV（最短路+最大流（sap））
不要錯過才珍惜
08-17 266
题目地址 题意：在城市A的男孩想去跟城市B的女孩约会，不过他去城市B必须走A->B最短路，并且走过的路不可以再走，问他最多能看这个女孩多少次。 思路：看到他们我就想是不是用最大流最小费用类似的去写，但是我发现是要求条数，而且只能是最短路，所以我在上面加了条件，但是TLE了，所以我看别人博客，发现是先把最短路上所有的边重新建一个图，这是我觉得蛮好的一个方法：makemap
Marriage Match IV（最短路+网络流）
naiue的博客
07-26 173
题意：N个点M条边的有向图，给定起点S和终点T，求每条边都不重复的S–>T的最短路有多少条。 第一步：求出最短路 若d[u]+w == d[v]。那么e就是最短路上的一条边。 spfa会被卡常，建议改用dijikstra 第二步：求出最大流 每条边都不重复的××，老网络流模型了 求解S到T的最大流。将所求得的最短路的边，建新图，每条边的流量都是1。再用dinik求出S到T的最大流，即最终答案。 code： #include<bits/stdc++.h> #define ll long lo
hdu-1569(网络流)-最大点权独立集
最新发布
05-30
这是一道经典的网络流问题，可以使用最小割模型进行建模。 首先，将所有点拆成两个点，分别表示该点被选中和不被选中两种状态。对于每个点，如果它被选中，则将它的点权加入最终结果中。接下来，对于每条边 $(u,v)$...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值