Educational Codeforces Round 92 (Rated for Div. 2) A-F

最新推荐文章于 2023-12-06 14:39:07 发布
最新推荐文章于 2023-12-06 14:39:07 发布
阅读量91 收藏
点赞数
分类专栏： 数学 扫描线 模拟
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44019404/article/details/107801020
版权
数学 同时被 3 个专栏收录
7 篇文章 0 订阅
订阅专栏
扫描线
2 篇文章 0 订阅
订阅专栏
模拟
2 篇文章 0 订阅
订阅专栏

数学和细节题十分不行的我，这场被打懵了。wa到自闭。

A
因为对两个数字求 l c m lcm lcm，至少需要小的数字乘以二。所以我们针对每个区间端点，乘以二，判断是否在内即可。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<climits>
#include<stack>
#include<vector>
#include<queue>
#include<set>
#include<bitset>
#include<map>
//#include<regex>
#include<cstdio>
#include <iomanip>
#pragma GCC optimize(2)
#define up(i,a,b)  for(int i=a;i<b;i++)
#define dw(i,a,b)  for(int i=a;i>b;i--)
#define upd(i,a,b) for(int i=a;i<=b;i++)
#define dwd(i,a,b) for(int i=a;i>=b;i--)
//#define local
typedef long long ll;
typedef unsigned long long ull;
const double esp = 1e-6;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int inf = 1e9;
using namespace std;
ll read()
{
	char ch = getchar(); ll x = 0, f = 1;
	while (ch<'0' || ch>'9') { if (ch == '-')f = -1; ch = getchar(); }
	while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
	return x * f;
}
typedef pair<int, int> pir;
#define lson l,mid,root<<1
#define rson mid+1,r,root<<1|1
#define lrt root<<1
#define rrt root<<1|1
int T;
int l, r;
int main()
{
	T = read();
	while (T--)
	{
		l = read(), r = read();
		if (r < 2 * l) { printf("%d %d\n", -1 ,-1); }
		else {
			printf("%d %d\n", l, 2 * l);
		}
	}
	return 0;
}

B
由题意，一共可以走k步，每次回头只能走一步，那么我们可以发现，每一次回头一共就有了2次步数的减少（去+回），再加上题目按时回头走的次数不多于五次，所以我们枚举回头次数。
针对一共 i i i次回头，我们最远能走到 k − 2 ∗ i 。 k-2*i。 k−2∗i。
我们只需要找到最大的 a [ i ] + a [ i + 1 ] a[i]+a[i+1] a[i]+a[i+1]，使得这个循环走 i i i次即可。
其次，针对端点，可以考虑成从端点到端点+1, a [ n ] + a [ n + 1 ] a[n]+a[n+1] a[n]+a[n+1]，这个循环走 i i i次。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<climits>
#include<stack>
#include<vector>
#include<queue>
#include<set>
#include<bitset>
#include<map>
//#include<regex>
#include<cstdio>
#include <iomanip>
#pragma GCC optimize(2)
#define up(i,a,b)  for(int i=a;i<b;i++)
#define dw(i,a,b)  for(int i=a;i>b;i--)
#define upd(i,a,b) for(int i=a;i<=b;i++)
#define dwd(i,a,b) for(int i=a;i>=b;i--)
//#define local
typedef long long ll;
typedef unsigned long long ull;
const double esp = 1e-6;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int inf = 1e9;
using namespace std;
ll read()
{
	char ch = getchar(); ll x = 0, f = 1;
	while (ch<'0' || ch>'9') { if (ch == '-')f = -1; ch = getchar(); }
	while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
	return x * f;
}
typedef pair<int, int> pir;
#define lson l,mid,root<<1
#define rson mid+1,r,root<<1|1
#define lrt root<<1
#define rrt root<<1|1
const int N = 1e5 + 10;
int T, n, k, z;
int a[N];
int main()
{
	T = read();
	while (T--)
	{
		n = read(), k = read(), z = read();
		upd(i, 1, n)a[i] = read();
		int ans = 0;
		upd(j, 0, z)
		{
			int len = k - 2 * j + 1;
			int mx = 0;
			int sum = 0;
			upd(i, 1, len)
			{
				mx = max(mx, a[i] + a[i + 1]);
				sum += a[i];
			}
			//sum += a[len];
			ans = max(ans, sum + j * mx);
		}
		printf("%d\n", ans);
	}
}

C
依题意，最后剩下的字符串一定形如 a b a b a b a b abababab abababab且长度是偶数。
所以暴力枚举我们剩余的两个数字即可。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<climits>
#include<stack>
#include<vector>
#include<queue>
#include<set>
#include<bitset>
#include<map>
//#include<regex>
#include<cstdio>
#include <iomanip>
#pragma GCC optimize(2)
#define up(i,a,b)  for(int i=a;i<b;i++)
#define dw(i,a,b)  for(int i=a;i>b;i--)
#define upd(i,a,b) for(int i=a;i<=b;i++)
#define dwd(i,a,b) for(int i=a;i>=b;i--)
//#define local
typedef long long ll;
typedef unsigned long long ull;
const double esp = 1e-6;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int inf = 1e9;
using namespace std;
ll read()
{
	char ch = getchar(); ll x = 0, f = 1;
	while (ch<'0' || ch>'9') { if (ch == '-')f = -1; ch = getchar(); }
	while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
	return x * f;
}
typedef pair<int, int> pir;
#define lson l,mid,root<<1
#define rson mid+1,r,root<<1|1
#define lrt root<<1
#define rrt root<<1|1
const int N = 2e5 + 10;
int T, n;
char s[N];
int num[2];
int main()
{
	T = read();
	while (T--)
	{
		scanf("%s", s + 1);
		n = strlen(s + 1);
		int ans = INF;
		upd(a, 0, 9)
		{
			upd(b, 0, 9)
			{
				num[0] = a, num[1] = b;
				int now = 0;
				int sum = 0;
				upd(i, 1, n)
				{
					if (num[now] != s[i]-'0')sum++;
					else {
						now ^= 1;
					}
				}
				if (now == 1) {
					if (a != b)sum++;
				}
				ans = min(ans, sum);
			}
		}
		printf("%d\n", ans);
	}
	return 0;
}

D
分为两个情况，第一个相交，第二个是不相交。
相交的话，先判断相交的长度是否大于 k k k,小于了直接输出0。大于的话，接着判断。我们可以发现，对于一组木板，我们将他扩展 L = m i n ( a l , b l ) L=min(a_l,b_l) L=min(al​,bl​), R = m a x ( a r , b r ) R=max(a_r,b_r) R=max(ar​,br​)，是最优秀的。因为这样可以节省费用，同样是长度 R − L R-L R−L，分别扩展两个木板利用了自己的长度部分，使得费用是最少的。所以我们计算长度 R − L R-L R−L和 n ∗ ( R − L ) n*(R-L) n∗(R−L)，判断与k的关系，不行的话利用两倍费用暴力扩展即可。
当不相交，首先扩展木板到相同的长度，然后判断他的 k k k的关系，如果 k k k更小的话，我们需要判断费用是否更加优秀。
有 a l , a r , b l , b r a_l,a_r,b_l,b_r al​,ar​,bl​,br​，我们假定a木板是更靠左的木板。有 a r < b l a_r<b_l ar​<bl​，将 a a a木板扩展到刚好和b相交，有 d i s t = ( b l − a r ) dist=(b_l-a_r) dist=(bl​−ar​)，将 a a a继续向右扩展，最多可以产生 l e n = b r − b l len=b_r-b_l len=br​−bl​的长度，费用是 d i s t + l e n dist+len dist+len。当 k < d i s t k<dist k<dist的时候，如果扩展 a a a木板，会产生 d i s t + k dist+k dist+k> 2 ∗ k 2*k 2∗k的费用，所以不如我们直接暴力扩展已经处理好的等长木板。否则的话，先扩展 a a a在扩展 b b b.

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<climits>
#include<stack>
#include<vector>
#include<queue>
#include<set>
#include<bitset>
#include<map>
//#include<regex>
#include<cstdio>
#include <iomanip>
#pragma GCC optimize(2)
#define up(i,a,b)  for(int i=a;i<b;i++)
#define dw(i,a,b)  for(int i=a;i>b;i--)
#define upd(i,a,b) for(int i=a;i<=b;i++)
#define dwd(i,a,b) for(int i=a;i>=b;i--)
//#define local
typedef long long ll;
typedef unsigned long long ull;
const double esp = 1e-6;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int inf = 1e9;
using namespace std;
ll read()
{
	char ch = getchar(); ll x = 0, f = 1;
	while (ch<'0' || ch>'9') { if (ch == '-')f = -1; ch = getchar(); }
	while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
	return x * f;
}
typedef pair<ll, ll> pir;
#define lson l,mid,root<<1
#define rson mid+1,r,root<<1|1
#define lrt root<<1
#define rrt root<<1|1
const int N = 2e5 + 10;
int T;
ll n, k;
pir a, b;
ll judge(pir x, pir y)
{
	return min(y.second, x.second) - max(x.first, y.first);
}
int main()
{
	T = read();
	while (T--)
	{
		n = read(), k = read();
		ll ans = 0;
		a.first = read(); a.second = read();
		b.first = read(), b.second = read();
		ll tp = judge(a, b);
		if(tp>=0)
		{ 
			if (tp*n >= k) {
				ans = 0;
			}
			else {
				k -= tp * n;
				int mod = (max(a.second, b.second) - min(a.first, b.first)) - tp;
				if (mod*n >= k)
				{
					ans += k;
				}
				else {
					ans += mod * n + (k - mod * n) * 2;
				}
			}
		}
		else {
			if (a.first > b.first)swap(a, b);
			int mx = max(a.second, b.second); int mn = min(a.first, b.first);
			int mod = (mx - a.second) + (a.first - mn) + (mx - b.second) + (b.first - mn);
			int len = mx - mn;
			int dist = max(b.first, a.second) - min(b.first, a.second);
			if (k <= len)ans += dist + k;
			else {
				int cnt = 0;
				upd(i, 1, n) {
					if (k >= len) {
						k -= len; ans += mod;
						cnt++;
					}
					else break;
				}
				{
					if (cnt == n) {
						ans += k * 2;
					}
					else {
						if (dist > k)ans += 2 * k;
						else ans += 2 * dist + (k - dist);
					}
				}
			}
		}
		printf("%lld\n", ans);
	}
	return 0;
}

E
由，第x个月第y天和第y个月第x天是相同的星期几，我们可以得到：
( x − 1 ) ∗ d + y m o d    w = = 0 (x-1)*d+y\mod w==0 (x−1)∗d+ymodw==0, ( y − 1 ) ∗ d + x m o d    w = = 0 (y-1)*d+x \mod w==0 (y−1)∗d+xmodw==0，两式相减，就有：
( x − y ) ∗ ( d − 1 ) m o d    w = = 0 (x-y)*(d-1)\mod w==0 (x−y)∗(d−1)modw==0因为 ( d − 1 ) (d-1) (d−1)是常数，将 d − 1 d-1 d−1除掉。就有：
( x − y ) m o d    ( w / g c d ( w , ( d − 1 ) ) = = 0 (x-y)\mod (w/gcd(w,(d-1))==0 (x−y)mod(w/gcd(w,(d−1))==0，因为 x < = d & x < = m x<=d\&x<=m x<=d&x<=m同理可得 y y y，
故题目化简成求，有多少对 ( x , y ) (x,y) (x,y)满足上式。枚举倍数 w ′ ′ w'' w′′，即 x − y = = w ′ x-y==w' x−y==w′，针对 d m = m i n ( d , m ) dm=min(d,m) dm=min(d,m)而言，一共有 ∑ i = 1 d m / w ′ d m − w ′ ∗ i \sum_{i=1}^{dm/w'}dm-w'*i ∑i=1dm/w′​dm−w′∗i，用通项公式化简即可。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<climits>
#include<stack>
#include<vector>
#include<queue>
#include<set>
#include<bitset>
#include<map>
//#include<regex>m
#include<cstdio>
#include <iomanip>
#pragma GCC optimize(2)
#define up(i,a,b)  for(int i=a;i<b;i++)
#define dw(i,a,b)  for(int i=a;i>b;i--)
#define upd(i,a,b) for(int i=a;i<=b;i++)
#define dwd(i,a,b) for(int i=a;i>=b;i--)
//#define local
typedef long long ll;
typedef unsigned long long ull;
const double esp = 1e-6;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int inf = 1e9;
using namespace std;
ll read()
{
	char ch = getchar(); ll x = 0, f = 1;
	while (ch<'0' || ch>'9') { if (ch == '-')f = -1; ch = getchar(); }
	while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
	return x * f;
}
typedef pair<int, int> pir;
#define lson l,mid,root<<1
#define rson mid+1,r,root<<1|1
#define lrt root<<1
#define rrt root<<1|1
int T;
ll m, d, w;
ll gcd(ll a, ll b)
{
	return a ? gcd(b%a, a) : b;
}
int main()
{
	T = read();
	while (T--)
	{
		m = read(), d = read(), w = read();
		ll md = min(m, d);
		ll w_ = w / gcd(w, d - 1);
		ll cnt = md / w_;
		ll ans = 0;      
		ans = md * cnt - w_ * (cnt*(cnt + 1) / 2);
		printf("%lld\n", ans);
	}
	return 0;
}

F
考虑一个二分图（依靠颜色分为两种），我们如果正向连边，即颜色=1的点，向所有满足题意的颜色=2的点连边，该题不容易找到解法。反过来，如果颜色=1的向所以形成bad的颜色=2的点连边，那么题目就变成找到最大独立集。由网络流可以知道，最大独立集=n-最大匹配。故现在我们需要找到一个匹配方式，是最大的。
常规匹配变数可能是 n 2 n^2 n2，我们需要找到一个更优秀的方法。容易想到，利用扫描线的思想，我们把每一个线段抽象成两个点，起点和终点。现在开两个集合，表示颜色1，颜色2。针对每一个起点，我们添加他的终点进入集合，针对每一个终点，我们匹配另外一个集合中，最小的终点。可以容易的发现这样贪心的正确性。（利用multiset，不然会wa4，终点多个重合的情况）

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<climits>
#include<stack>
#include<vector>
#include<queue>
#include<set>
#include<bitset>
#include<map>
//#include<regex>
#include<cstdio>
#include <iomanip>
#pragma GCC optimize(2)
#define up(i,a,b)  for(int i=a;i<b;i++)
#define dw(i,a,b)  for(int i=a;i>b;i--)
#define upd(i,a,b) for(int i=a;i<=b;i++)
#define dwd(i,a,b) for(int i=a;i>=b;i--)
//#define local
typedef long long ll;
typedef unsigned long long ull;
const double esp = 1e-6;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int inf = 1e9;
using namespace std;
ll read()
{
	char ch = getchar(); ll x = 0, f = 1;
	while (ch<'0' || ch>'9') { if (ch == '-')f = -1; ch = getchar(); }
	while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
	return x * f;
}
typedef pair<int, int> pir;
#define lson l,mid,root<<1
#define rson mid+1,r,root<<1|1
#define lrt root<<1
#define rrt root<<1|1
const int N = 2e5 + 10;
int L[N], R[N], t[N];
int n;
struct node {
	int a, b, c;
};
multiset<int>s[3];
vector<node>vec;
int main()
{
	n = read();
	upd(i, 1, n) {
		L[i] = read(), R[i] = read(), t[i] = read(); t[i]--;
	}
	upd(i, 1, n)
	{
		vec.push_back(node{ L[i],i,0 });
		vec.push_back(node{ R[i],i,1 });
	}
	sort(vec.begin(), vec.end(), [](node t1, node t2) {
		if (t1.a == t2.a)
		{
			return t1.c < t2.c;
		}
		else { return t1.a < t2.a; };
	});
	int pi = 0;
	for (auto k : vec)
	{
		int id = k.b;
		int col = t[id];
		if (k.c == 1)
		{
			if (s[col].find(R[id]) != s[col].end())
			{
				if (s[col^1].size()) {
					pi++; s[col ^ 1].erase(s[col ^ 1].begin());
				}
				s[col].erase(s[col].find(R[id]));
			}
		}
		else {
			s[col].insert(R[id]);
		}
	}
	cout << n - pi << endl;
	return 0;
}
weixin_44019404
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Educational Codeforces Round 83 (Rated for Div. 2) D
01-20
C(n-2,i-1)*C(j-1,n-2)*(i-1) __ j: n-1 -> m 我们发现内层循环，每次只是j加一，我们就可以只用一次组合数剩下的用差量表示 对于外层循环同理 只有(i-1) * C(n-2,i-1) i会每次加一。我们也只算一次剩下的用差量...
Educational Codeforces Round 83 (Rated for Div. 2) E. Array Shrinking
01-03
葫芦聚聚说可以n^2搞。。 还好没卡我n^3 的做法。。 核心思路就是f[i]表示 前i个数最小能分成几个数。 然后由于前i个数都分好了，我们只需要取min f[k]+1( 满足k<i>n; for(int i=1;i>a[i],d
Educational Codeforces Round 145 (Rated for Div. 2) A-D
Mango.
04-01 477
Educational Codeforces Round 145 (Rated for Div. 2) A-D
Educational Codeforces Round 138 (Rated for Div. 2)-C. Number Game
weixin_52490191的博客
10-21 227
Educational Codeforces Round 138 (Rated for Div. 2)-C. Number Game
Educational Codeforces Round 114 (Rated for Div. 2) A-D
行码棋
09-22 276
博客主页: https://blog.csdn.net/qq_50285142 欢迎点赞????收藏✨关注❤留言 ???? 如有错误，敬请指正 ????虽然生活很难，但我们也要一直走下去???? A.Regular Bracket Sequences 题意： 给一个n，让你构造n个互不相同的括号对，能够让数字和符号填进去让表达式成立 思路： 我们就这样构造，比如n=4 （）（）（）（） （（））（）（） （（（）））（） （（（（）））） 每次都有一个括号对在左边的括号对里面，每个都不一样 #i
Educational Codeforces Round 131 (Rated for Div. 2) A-D题解
每一发奋努力的背后,必有加倍的赏赐。
07-09 357
Educational Codeforces Round 131 (Rated for Div. 2)
Educational Codeforces Round 159（Rated for Div. 2）
wyzz_yz的博客
12-06 1086
Educational Codeforces Round 159（Rated for Div. 2）
Educational Codeforces Round 130 (Rated for Div. 2) A--C
m0_60610120的博客
07-31 185
用贪心的思维则我们尽可能选择大的，这样能使得其中y个较小的值最大化。对于所免费获得的价值，我们可以用前缀和来计算，从而达到降低时间复杂度的目的。如果顾客购买了至少x件商品，最便宜的y件商品都是免费的。问字符串a能否通过两种操作变成b操作1（将ab变成ba）操作2（将bc变成cb）此外根据观察可以发现，a的位置只能向后移动，c的位置只能向前。所以在字符串a中的字符。来改变字母的相对位置，我们首先可以去掉两个字符串当中的。位置一定小于等于在字符串b中的，字符。两个操作的共性都是通过。...
Educational Codeforces Round 155 (Rated for Div. 2)
maisui12138的博客
09-25 353
题意：给出a,b两个大小为n的数组，给出一个n*n的棋盘，向里面填筹码，每行或者每列起码得有一个筹码，填入筹码的成本为棋盘坐标(i, j)—>ai+bj，问最小成本。每一段需要删(t-1)个，那么该段可能的操作数即为t中留一个，即t种选择，每段子序列相乘，还需要乘上所有需要操作字符的全排列，即为最终答案；题意：举重比赛，给出n个人，每个人给出能举的最大重量和单个重量能举起的次数，要让第一个人赢，需要用多大的重量，成绩相同无胜者。​ 找出每列的最小值，填满最小列，保证每一行有筹码，得到成本y；
Educational Codeforces Round 131 (Rated for Div. 2) A-C
qq_52930538的博客
07-10 182
刷题记录
Educational Codeforces Round 122 (Rated for Div. 2) A-D题解
yueshehanjiang的博客
02-01 580
A. Div. 7 思路： 注意n>=10，说明一定是两位数注意n>=10，说明一定是两位数注意n>=10，说明一定是两位数 并且7个一循环，直接枚举这位数的最后一位并且7个一循环，直接枚举这位数的最后一位并且7个一循环，直接枚举这位数的最后一位 暴力判断是否可行即可暴力判断是否可行即可暴力判断是否可行即可 时间复杂度：OtOtOt #include <bits/stdc++.h> #define fer(i,a,b) for(re i = a ; i <= b ; ++
Educational Codeforces Round 150 (Rated for Div. 2)
qq_61657632的博客
06-13 1602
今晚看完电影再回来补。
Educational Codeforces Round 85 (Rated for Div. 2) B. Middle Class（贪心）
01-03
目录传送门题意：思路：代码： 传送门 题意： 思路： 排个序，然后从最大的开始判断是否合适即可 代码： #include #include #include #include #include #include #include ...#define SZ(x) (
Educational Codeforces Round 85 (Rated for Div. 2) A. Level Statistics
01-03
目录传送门题意：思路：代码： 传送门 题意： 思路： 就是让判断给出的数据是否合理 两个p,c p,c肯定是是增加的，要么不变 p不变的话，c肯定不能变 始终p应该是大于等于c的 如果两个同时增加，p增加的应该大于等于c...
Educational Codeforces Round 83 (Rated for Div. 2) C. Adding Powers
01-03
传送门 题意： 思路： 每步可加kik^iki，也可以跳过不加，看能否构成给定数组 数组中的0是不需要处理的 ... }// l=3 b[i]=1+9+9^2 if(p[l]!=1){ flag=0; break; } p[l]=
防雷及短路计算软件.zip
05-12
防雷及短路计算软件
电线穿管选用小软件.zip
05-12
电线穿管选用小软件
【小白python数据分析入门4Pandas可视化-板块8案例 2018幸福大数据】
最新发布
05-12
小白python数据分析入门4Pandas可视化——板块8案例 2018幸福大数据，辅助8.1读取数据
电气照明照度计算软件.zip
05-12
电气照明照度计算软件
educational codeforces round 103 (rated for div. 2)
09-06
"educational codeforces round 103 (rated for div. 2)"是一个Codeforces平台上的教育性比赛，专为2级选手设计评级。以下是有关该比赛的回答。 "educational codeforces round 103 (rated for div. 2)"是一场...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值