Codeforces Round 976 (Div. 2)（A，B，C，D，E）并查集，区间合并，概率dp

已于 2024-10-02 20:21:56 修改
阅读量685 收藏 21
点赞数 14
分类专栏： Codeforces 文章标签： 算法 c++ 数据结构 动态规划
于 2024-10-02 20:21:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74754298/article/details/142684362
版权

比赛链接

https://codeforces.com/contest/2020

A题

思路

按照 2 2 2的整次幂从大到小枚举。

代码

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 2e5 + 5;
int n, k;
int qmi(int a, int b)
{
	int res = 1;
	while (b)
	{
		if (b & 1) res = res * a;
		b >>= 1;
		a = a * a;
	}
	return res;
}
void solve()
{
	cin >> n >> k;
	if (k == 1)
	{
		cout << n << endl;
		return;
	}
	int ans = 0;
	for (int i = 30; i >= 0; i--)
	{
		int op = qmi(k, i);
		if (op <= n && op > 0)
		{
			ans += (n / op);
			n = n - (n / op) * op;
		}
	}
	cout << ans << endl;
}
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	int test = 1;
	cin >> test;
	for (int i = 1; i <= test; i++)
	{
		solve();
	}
	return 0;
}

B题

思路

灯泡最后为开或关，与开关灯的操作次数有关。

每次开关灯的条件是包含因数 i i i，因此最后开着的灯的操作次数为偶数。

因为，只有平方数有奇数个因数，所以 [ 1 , n ] [1,n] [1,n]排除所有平方数的个数即为 k k k。

因此我们可以直接二分查找答案求解。

代码

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 2e5 + 5;
int k;
int func(int x)
{
	return x - (int)(sqrtl(x));
}
void solve()
{
	cin >> k;
	int low = 1, high = 2e18;
	while (low < high)
	{
		int mid = low + high >> 1;
		if (func(mid) >= k)
		{
			high = mid;
		}
		else low = mid + 1;
	}
	cout << high << endl;
}
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	int test = 1;
	cin >> test;
	for (int i = 1; i <= test; i++)
	{
		solve();
	}
	return 0;
}

C题

思路

所以可以从高位到低位贪心地确定 a a a的该位取什么值，然后分类讨论即可。

代码

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 2e5 + 5;
int b, c, d;
void solve()
{
	cin >> b >> c >> d;
	int ans = 0;
	bool ok = true;
	for (int j = 61; j >= 0; j--)
	{
		int bitb = (b >> j) & 1;
		int bitc = (c >> j) & 1;
		int bitd = (d >> j) & 1;
		if (bitd == 1)
		{
			if (bitb == 1 && bitc == 1)continue;
			if (bitb == 1 && bitc == 0)continue;
			if (bitb == 0 && bitc == 1) {ok = false; continue;}
			if (bitb == 0 && bitc == 0)ans += (1ll << j);
		}
		else
		{
			if (bitb == 1 && bitc == 1) {ans += (1ll << j); continue;}
			if (bitb == 1 && bitc == 0) {ok = false; continue;}
			if (bitb == 0 && bitc == 1) {ans += (1ll << j); continue;}
			if (bitb == 0 && bitc == 0)continue;
		}
	}
	if (!ok)
	{
		cout << -1 << endl;
	}
	else
	{
		cout << ans << endl;
	}
}
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	int test = 1;
	cin >> test;
	for (int i = 1; i <= test; i++)
	{
		solve();
	}
	return 0;
}

D题

思路

我们发现 d d d的大小只有 10 10 10。

我们可以将每一组 a , d , k a,d,k a,d,k视作一个区间。我们可以按照 d d d和 a % d a \% d a%d依次对每一个区间进行分组。

之后，我们按照分好的每个小组依次进行区间合并。

对于合并后的区间，我们使用并查集进行暴力缩点，最后统计连通块的数量即可。

代码

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 2e5 + 5;
int n, m;
struct DSU {
	std::vector<int> f, siz;

	DSU() {}
	DSU(int n) {
		init(n);
	}

	void init(int n) {
		f.resize(n);
		std::iota(f.begin(), f.end(), 0);
		siz.assign(n, 1);
	}

	int find(int x) {
		while (x != f[x]) {
			x = f[x] = f[f[x]];
		}
		return x;
	}

	bool same(int x, int y) {
		return find(x) == find(y);
	}

	bool merge(int x, int y) {
		x = find(x);
		y = find(y);
		if (x == y) {
			return false;
		}
		siz[x] += siz[y];
		f[y] = x;
		return true;
	}

	int size(int x) {
		return siz[find(x)];
	}
};
vector<pair<int, int>> merge(vector<pair<int, int>>&segs)
{
	vector<pair<int, int>>res;
	sort(segs.begin(), segs.end());
	int st = -2e9, ed = -2e9;
	for (auto seg : segs)
	{
		if (ed < seg.first)
		{
			if (ed != -2e9) res.push_back({st, ed});
			st = seg.first;
			ed = seg.second;
		}
		else ed = max(ed, seg.second);
	}
	if (st != 2e9) res.push_back({st, ed});
	return res;
}
void solve()
{
	cin >> n >> m;
	DSU dsu(n + 1);
	map<int, map<int, vector<pair<int, int>>>>mp1;
	map<int, set<int>>mp2;
	for (int i = 1, a, d, k; i <= m; i++)
	{
		cin >> a >> d >> k;
		if (!mp1.count(d))
		{
			mp1[d][a % d].push_back({a, a + k * d});
			mp2[d].insert(a % d);
		}
		else
		{
			if (mp2[d].count(a % d))
			{
				mp1[d][a % d].push_back({a, a + k * d});
			}
			else
			{
				mp1[d][a % d].push_back({a, a + k * d});
				mp2[d].insert(a % d);
			}
		}
	}
	for (auto mpp : mp1)
	{
		int d = mpp.first;
		for (auto val : mpp.second)
		{

			vector<pair<int, int>>op = merge(val.second);
			for (pair<int, int> & pii : op)
			{
				int a = pii.first;
				int high = pii.second;
				for (int i = a + d; i <= high; i += d)
				{
					dsu.merge(i - d, i);
				}
			}

		}
	}
	int ans = 0;
	for (int i = 1; i <= n; i++)
	{
		if (dsu.find(i) == i) ans++;
	}
	cout << ans << endl;
}
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	int test = 1;
	cin >> test;
	for (int i = 1; i <= test; i++)
	{
		solve();
	}
	return 0;
}

E题

思路

概率 d p dp dp

我们发现 a i a_{i} ai​最大为 1023 1023 1023，也就是 2 10 − 1 2^{10}-1 210−1。

我们令 d p i , j dp_{i,j} dpi,j​表示前 i i i个数，最终值为 j j j时的概率，状态转移方程为：

d p [ i ] [ j ] = d p [ i − 1 ] [ j ⊕ a [ i ] ] × p [ i ] 1 e 4 + d p [ i − 1 ] [ j ] × ( 1 − p [ i ] 1 e 4 ) dp[i][j] = dp[i-1][j \oplus a[i]] \times \frac{p[i]}{1e4} + dp[i-1][j] \times (1-\frac{p[i]}{1e4}) dp[i][j]=dp[i−1][j⊕a[i]]×1e4p[i]​+dp[i−1][j]×(1−1e4p[i]​)

代码

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 2e5 + 5;
int n;
int a[N], p[N];

using i64 = long long;
template<class T>
constexpr T power(T a, i64 b) {
    T res = 1;
    for (; b; b /= 2, a *= a) {
        if (b % 2) {
            res *= a;
        }
    }
    return res;
}

constexpr i64 mul(i64 a, i64 b, i64 p) {
    i64 res = a * b - i64(1.L * a * b / p) * p;
    res %= p;
    if (res < 0) {
        res += p;
    }
    return res;
}
template<i64 P>
struct MLong {
    i64 x;
    constexpr MLong() : x{} {}
    constexpr MLong(i64 x) : x{norm(x % getMod())} {}

    static i64 Mod;
    constexpr static i64 getMod() {
        if (P > 0) {
            return P;
        } else {
            return Mod;
        }
    }
    constexpr static void setMod(i64 Mod_) {
        Mod = Mod_;
    }
    constexpr i64 norm(i64 x) const {
        if (x < 0) {
            x += getMod();
        }
        if (x >= getMod()) {
            x -= getMod();
        }
        return x;
    }
    constexpr i64 val() const {
        return x;
    }
    explicit constexpr operator i64() const {
        return x;
    }
    constexpr MLong operator-() const {
        MLong res;
        res.x = norm(getMod() - x);
        return res;
    }
    constexpr MLong inv() const {
        assert(x != 0);
        return power(*this, getMod() - 2);
    }
    constexpr MLong &operator*=(MLong rhs) & {
        x = mul(x, rhs.x, getMod());
        return *this;
    }
    constexpr MLong &operator+=(MLong rhs) & {
        x = norm(x + rhs.x);
        return *this;
    }
    constexpr MLong &operator-=(MLong rhs) & {
        x = norm(x - rhs.x);
        return *this;
    }
    constexpr MLong &operator/=(MLong rhs) & {
        return *this *= rhs.inv();
    }
    friend constexpr MLong operator*(MLong lhs, MLong rhs) {
        MLong res = lhs;
        res *= rhs;
        return res;
    }
    friend constexpr MLong operator+(MLong lhs, MLong rhs) {
        MLong res = lhs;
        res += rhs;
        return res;
    }
    friend constexpr MLong operator-(MLong lhs, MLong rhs) {
        MLong res = lhs;
        res -= rhs;
        return res;
    }
    friend constexpr MLong operator/(MLong lhs, MLong rhs) {
        MLong res = lhs;
        res /= rhs;
        return res;
    }
    friend constexpr std::istream &operator>>(std::istream &is, MLong &a) {
        i64 v;
        is >> v;
        a = MLong(v);
        return is;
    }
    friend constexpr std::ostream &operator<<(std::ostream &os, const MLong &a) {
        return os << a.val();
    }
    friend constexpr bool operator==(MLong lhs, MLong rhs) {
        return lhs.val() == rhs.val();
    }
    friend constexpr bool operator!=(MLong lhs, MLong rhs) {
        return lhs.val() != rhs.val();
    }
};

template<>
i64 MLong<0LL>::Mod = i64(1E18) + 9;

template<int P>
struct MInt {
    int x;
    constexpr MInt() : x{} {}
    constexpr MInt(i64 x) : x{norm(x % getMod())} {}

    static int Mod;
    constexpr static int getMod() {
        if (P > 0) {
            return P;
        } else {
            return Mod;
        }
    }
    constexpr static void setMod(int Mod_) {
        Mod = Mod_;
    }
    constexpr int norm(int x) const {
        if (x < 0) {
            x += getMod();
        }
        if (x >= getMod()) {
            x -= getMod();
        }
        return x;
    }
    constexpr int val() const {
        return x;
    }
    explicit constexpr operator int() const {
        return x;
    }
    constexpr MInt operator-() const {
        MInt res;
        res.x = norm(getMod() - x);
        return res;
    }
    constexpr MInt inv() const {
        assert(x != 0);
        return power(*this, getMod() - 2);
    }
    constexpr MInt &operator*=(MInt rhs) & {
        x = 1LL * x * rhs.x % getMod();
        return *this;
    }
    constexpr MInt &operator+=(MInt rhs) & {
        x = norm(x + rhs.x);
        return *this;
    }
    constexpr MInt &operator-=(MInt rhs) & {
        x = norm(x - rhs.x);
        return *this;
    }
    constexpr MInt &operator/=(MInt rhs) & {
        return *this *= rhs.inv();
    }
    friend constexpr MInt operator*(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res *= rhs;
        return res;
    }
    friend constexpr MInt operator+(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res += rhs;
        return res;
    }
    friend constexpr MInt operator-(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res -= rhs;
        return res;
    }
    friend constexpr MInt operator/(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res /= rhs;
        return res;
    }
    friend constexpr std::istream &operator>>(std::istream &is, MInt &a) {
        i64 v;
        is >> v;
        a = MInt(v);
        return is;
    }
    friend constexpr std::ostream &operator<<(std::ostream &os, const MInt &a) {
        return os << a.val();
    }
    friend constexpr bool operator==(MInt lhs, MInt rhs) {
        return lhs.val() == rhs.val();
    }
    friend constexpr bool operator!=(MInt lhs, MInt rhs) {
        return lhs.val() != rhs.val();
    }
};

template<>
int MInt<0>::Mod = 998244353;

template<int V, int P>
constexpr MInt<P> CInv = MInt<P>(V).inv();

constexpr int P = 1000000007;
using Z = MInt<P>;

void solve()
{
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];
	}
	for (int i = 1; i <= n; i++)
	{
		cin >> p[i];
	}
	int m = 1ll << 10;
	const Z inv1e4 = Z(10000).inv();
	vector<Z>dp(m);
	dp[0] = 1;
	for (int i = 1; i <= n; i++)
	{
		vector<Z>f(m);
		for (int j = 0; j < m; j++)
		{
			f[j ^ a[i]] += dp[j] * p[i] * inv1e4;
			f[j] += dp[j] * (Z(1ll) - p[i] * inv1e4);
		}
		dp.swap(f);
	}

	Z ans = 0;
	for (int i = 0; i < m; i++)
	{
		ans += Z(1) * i * i * dp[i];
	}
	cout << ans << endl;
}
signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	int test = 1;
	cin >> test;
	for (int i = 1; i <= test; i++)
	{
		solve();
	}
	return 0;
}
FacDriftice
关注
专栏目录
Codeforces Rund 976 div2 个人题解(A~E)
Lazy_ChessPlayer的博客
09-30 1069
Codeforces Rund 976 div2 个人题解(A~E)
Codeforces Round 975 (Div. 1) D. Max Plus Min Plus Size（思维题 并查集/动态dp 线段树维护状态合并）
Code92007的博客
09-28 662
f[x][i][j][k]表示线段树的x节点，最大值有没有取到，左端点有没有选，右端点有没有选，如果最大值被包含在1 3 5里显然取1 3 5，否则换成2 4一定能取到最大值，是不劣的，对于最小值固定的话，对于1 2 3 4 5的连续段，要么贪心地取1 3 5，要么取2 4。如果存在一个连续段，使得选这个连续段中较多的那一半（奇数唯一，偶数均可）能取到最大值。则答案不需要减1，否则为了取到最大值需要反选，将答案减1。hhoppitree代码 + 官方题解。注意到最大值一定会被取到，
[题解] Codeforces Round 976 (Div. 2) A ~ E
taulee01 的博客
09-30 849
d 最大为 10, 于是对于 a[i], 考虑继承前 10 个节点往后跳跃的情况, 更新到 a[i] 上, 同时继承过来的跳跃次数减一. 这样每个点只用往前跳跃最多 10 次.发现, 运算结果不会有负数. 于是每位就自能顾得上自己, 只需要按位检查, 一旦有一位满足不了, 就输出 -1.表示前 i 位选取某些异或到一起答案是 j 的概率. 就很好转移了. 见代码. 记得滚动数组优化一下空间.首先考虑用并查集维护两个点的连通块所属关系. 但是操作太多, 会 tle.eg: jiangly 的取模机真好用!
Codeforces Round 363 Div. 1 (A,B,C,D,E,F)
weixin_30616969的博客
10-21 92
Codeforces Round 363 Div. 1 题目链接：## 点击打开链接 A. Vacations (1s, 256MB) 题目大意：给定连续 \(n\) 天，每天为如下四种状态之一： 不能进行运动或比赛 可以进行运动但不能比赛 可以进行比赛但不能运动 可以进行比赛或运动 对于每天，可以根据当天的状态选择运动，比赛或休息。但不能连续两天的选择均为运动或均为比赛。求在这 \(n\) ...
Educational Codeforces Round 87 (Rated for Div. 2) E. Graph Coloring 并查集
pubgoso的博客
05-20 148
题目链接 题意：给你一个图，你要给每个点染色（1，2，3），满足相邻点奇偶不同，且颜色数量给定。 思路： 显然这张图的所有连通块必然都是二分图，否则存在奇环的话就必然不合法。 那么先用并查集处理出所有连通块的两侧大小，用记录路径的dp处理出染2的方案就做完了。 并查集判断二分图的一些细节见：此处 #include <bits/stdc++.h> using namespace std; typedef long long LL; const int N = 2e5 + 10; #define f
Codeforces Round 923 (Div. 3)（A,B,C,D,E,F,G）
qq_45809243的博客
02-08 1047
Codeforces Round 923 (Div. 3)（A,B,C,D,E,F,G）
Codeforces Round #789 (Div. 2) B~E
qq_51672768的博客
05-09 251
Codeforces Round #789 (Div. 2) B~F B.Tokitsukaze and Good 01-String 链接 题意：给出01字符串，要求每次可以修改一个地方，最后要让连续的1和连续的0的长度都是偶数，输出最下操作次数和最后的段数 思路：首先考虑都变成奇数，从头开始每次跳2，假如不一样，说明出现了奇数的0或者1，就需要变成，然后统计段数，当和最后一次记录不同的时候，说明段数加一 #include<bits/stdc++.h> using namespace std;
Codeforces Round 923 (Div. 3) A—F
2203_75752922的博客
02-12 904
可以发现每相隔k个位置的元素之间相差不超过1，为了使数组包含1-n所有元素，我们让每隔k个位置的元素加1，但如果我们全部选择加1，构造出的数组为 1 4 7 9 2 5 8 10 3 6显然存在不符合条件的区间，所以我们不能全部选择加1，可以选择加一减一轮流出现的策略，此时构造出的数组为1 6 7 10 2 5 8 9 3 4。给定一个包含n个元素的数组a以及m个查询，每个查询包含l，r两个整数，你的任务是判断l到r之间是否存在不同元素，如果存在输出任意两个不同元素的下标，如果不存在输出-1 -1。
Codeforces Round #723 div.2 A-F题解
月阁
05-30 1155
A. Mean Inequality 题目大意 给定一个包含 2n(1≤n≤25)2n(1 \leq n \leq 25)2n(1≤n≤25) 个不同的数的数组 aaa ，求数组 bbb 使其满足以下条件： bbb 是 aaa 的一种排列 ∀i∈[1,2n]\forall i \in [1,2n]∀i∈[1,2n] ，bi≠bi−1+bi+12b_i \neq \frac{b_{i-1}+b_{i+1}}{2}bi​​=2bi−1​+bi+1​​ ，其中 b0=b2nb_0=b_{2n}b0​=b2n​
Codeforces Round #787 (Div. 3)个人题解
weixin_51767904的博客
05-06 1088
Codeforces Round #787 (Div. 3)个人题解 Codeforces Round #787 (Div. 3) A. Food for Animals B. Make It Increasing C. Detective Task D. Vertical Paths E. Replace With the Previous, Minimize F. Vlad and Unfinished Business G. Sorting Pancakes
Divide by Zero 2021 and Codeforces Round #714 (Div. 2)题解
qq_53629286的博客
07-19 309
Problem - A - Codeforces 题目大意:给定长度为n的排列,每组排列有山峰数k,请你进行构造使得n的排列恰好有k个山峰. 模拟题:首先山峰的最大数量为(n-1)/2,如果超过这个数那必然无法构造出来,然后再根据k的数量,从大到小放置n, n-1, n-2,…就可以了. #include<bits/stdc++.h> using namespace std; #define rep(x,y,z) for(int x = y; x<=z;++x) #define d
【浮*光】【Codeforces Round #500 (Div. 2)】A,B,C,D,E,F
flora715的博客
08-28 322
题目地址ヽ(✿ﾟ▽ﾟ)ノ      目录 【Problem A】Piles With Stones 【Problem B】And 【Problem C】Photo of The Sky 【Problem D】Chemical table 【Problem E】Hills 【Problem F】AB-Strings   【Problem A】Piles With Stones ...
Codeforces Round #661 (Div. 3)题解
繁凡さん的博客
09-06 337
Codeforces Round #661 (Div. 3)题解
Codeforces Round #723 (Div. 2) C2. Potions (Hard Version) （贪心、dp、数据结构）
madaidao的专栏
05-31 220
题目链接：https://codeforces.com/contest/1526/problem/C2 题目大意： 从左到右有杯酒，每杯酒有一个健康值，喝掉一杯酒后，人的健康值会加。初始的时候人的健康值为0，在最左边的酒，从左到右往后喝，对于一杯酒可以选择喝和不喝，人的健康值在整个过程不能小于0，求最多可以喝几杯酒？ 题解： 方法1:dp 表示前杯酒喝了杯最大的健康值 这种方法复杂度 个人的解法：贪心 若当前酒健康值为-4且能喝，后面有杯健康值为-1，那么显然后面这杯健康值为-1的酒是.
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1281
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
二叉树最小深度
2301_80161204的博客
09-27 468
25[0, 105]
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1009
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
最新发布
wnm23的专栏
10-02 515
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
Codeforces Round 798 (Div. 2)
09-08
Codeforces Round 798 (Div. 2)是一个Codeforces竞赛系列中的一场比赛。根据提供的引用内容，我们可以看到一些参赛选手的AC代码链接。这些链接中包含了一些参赛选手在比赛中解答的题目的代码。 其中，AC代码链接是一种解答题目的代码，题目为"E. ANDfinity"。AC代码链接是另一种解答题目的代码，题目同样为"E. ANDfinity"。AC代码链接是解答题目"C. Infected Tree"的代码。 因此，Codeforces Round 798 (Div. 2)是一场包含了题目"E. ANDfinity"和"C. Infected Tree"的Codeforces竞赛。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值