3.28补题记录

已于 2022-03-29 17:31:41 修改
阅读量512 收藏
点赞数
分类专栏： 补题日记 文章标签： c++ 算法
于 2022-03-28 22:00:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50007959/article/details/123792857
版权

文章目录

前言

周赛0题，1/3都看过还做过，还有一道题反复做过，太难受了

一、我在哪？

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <cmath>
#define IOS ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL);
using namespace std;

const int maxx = 1e4 + 5;
const int maxn = 1e6 + 5;

#define N 10000100
#define ll long long
#define endl '\n'
const ll limit = 2000000;
const ll  mod = 998244353;
#define test printf("--------------------------\n");
//#define p printf
//#define s scanf
#define re(a) memset((a), 0, sizeof((a)))
#define remax(a) memset((a), 0x3f3f3f3f, sizeof((a)))

int main() {
	IOS;
	int n;
	cin >> n;
	string s;
	cin >> s;
	for (int i = 1; i <= n; ++i) {
		set<string> se;
		se.clear();
		bool flag = true;
		int j;
		for (j = 0; j + i <= n; ++j) {
			string t = s.substr(j, i);
			se.insert(t);
		}
		if (se.size() == j) {
			cout << i << endl;
			break;
		}
		/*1.	string temp = s.substr(j, i);
				if (se.count(temp) > 0) {//优化,寻找容器里有没有temp
					flag = false;
					break;
				}
				se.insert(temp);
			}
			if (flag) {
				cout << i;
				return 0;
			}*/
		/*2.if(se.size() == n - i + 1){//看图，因为刚好不重复的那个长度就有
				cout << i << endl;
				return 0;
		}
	}*/
	return 0;
}

这里需要注意的是可以用set容器的自动去重去查找有没有一样的字符串，没有就可以直接输出了

比较相似的题：Prefix Removals
这是通过证明在什么时刻，才会有不再重复的情况

二、股票买卖

读了几遍都读错了，我读题老是会错题，一定要改改
读错的点：当天卖了，下一天才能买
就是纯纯的贪心嘛

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <cmath>
#include <stack>
#define IOS ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL);
using namespace std;

const int maxx = 1e4 + 5;
const int maxn = 1e6 + 5;

#define N 10000100
#define ll long long
#define endl '\n'
const ll  mod = 998244353;
#define test printf("--------------------------\n");
#define re(a) memset((a), 0, sizeof((a)))
#define remax(a) memset((a), 0x3f3f3f3f, sizeof((a)))

inline int read () {
	int s = 0, w = 1;
	char ch = getchar ();
	while (ch < '0' || ch > '9') {
		if (ch == '-')
			w = -1;
		ch = getchar ();
	}
	while (ch >= '0' && ch <= '9')
		s = s * 10 + ch - '0', ch = getchar ();
	return s * w;
}

int a[maxn];
int dp[maxn];

int main() {
	IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据

	int n;
	cin >> n;
	ll sum = 0, ans = 0;
	for (int i = 1; i <= n; ++i) {
		cin >> a[i];
	}
	for (int i = 2; i <= n; ++i) {
		if (a[i] - a[i - 1] > 0)
			ans += (a[i] - a[i - 1]);//画个线图
	}
	cout << ans;
	return 0;
}

类似题：能量石

三、序列处理

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include<cmath>
#include<stack>
#define IOS ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL);
using namespace std;

const int maxx = 1e4 + 5;
const int maxn = 1e6 + 5;

#define N 10000100
#define ll long long
#define endl '\n'
const ll  mod = 998244353;
#define test printf("--------------------------\n");
#define re(a) memset((a), 0, sizeof((a)))
#define remax(a) memset((a), 0x3f3f3f3f, sizeof((a)))

inline int read () {
	int s = 0, w = 1; char ch = getchar ();
	while (ch < '0' || ch > '9') {if (ch == '-') w = -1; ch = getchar ();}
	while (ch >='0' && ch <= '9') s = s*10 + ch-'0', ch = getchar ();
	return s * w;
}

int a[3010];

//我的想法是还没到你但你也得腾位置出来给那同一个数，标答想法是一个一个腾位置，没到你就不挪

int main() {
	IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据
	int n;
    cin >> n;
    for (int i = 1; i <= n; ++i){
        cin >> a[i];
    }
    sort(a + 1, a + 1 + n);
    int ans = 0;
    a[0] = 0;
    for (int i = 1, last = 0; i <= n; ++i){
        int temp = max(a[i - 1] + 1, a[i]);
        ans += temp - a[i];
        a[i] = temp;
        last = temp;
    }
    cout << ans;
    return 0;
}

相似题：修改数组

int a[maxn];
int p[maxn];

int find(int x){
    if(p[x] == x) return x;
    return p[x] = find(p[x]);
}

int main() {
	IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据
	int n;
    cin >> n;
    for (int i = 1; i <= n; ++i){
        cin >> a[i];
    }
    for(int i = 1; i <= maxn; ++i) p[i] = i;
    for (int i = 1; i <= n; ++i){
        int temp = find(a[i]);
        if(a[i] != temp) a[i] = find(a[i]);
        cout << a[i] << ' ';
        p[a[i]] = a[i] + 1;
    }
    return 0;
}

这道题

四、鸣人的影分身

是整数划分的变形题
在洛谷找到:（不是板子题哈）
集合划分计数
整数划分
数的划分 类似于板子，0不能填进去时的情况

整数划分结论：（3，3，1 和 1，3，3这类是一样的不计入其中）
q (n, m) = 1 (n == 1 || m == 1)
q (n, m) = q (n, n) (n < m) （只含n和不含n的所有n-1划分）
q (n, m) = 1 + q (n, m - 1) (n == m)
q (n, m) = q (n - m, m) + q (n, m - 1) (n > m) (含m和不含m时n的m-1划分)

对比了下这道题的状态转移方程是差不多的哈，这题就是个板子题
这题爆搜也能做，dfs题解
道理是一样的，上面那个结论

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include<cmath>
#include<stack>
#define IOS ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL);
using namespace std;

const int maxx = 1e4 + 5;
const int maxn = 1e6 + 5;

#define N 10000100
#define ll long long
#define endl '\n'
const ll  mod = 998244353;
#define test printf("--------------------------\n");
#define re(a) memset((a), 0, sizeof((a)))
#define remax(a) memset((a), 0x3f3f3f3f, sizeof((a)))

inline int read () {
	int s = 0, w = 1; char ch = getchar ();
	while (ch < '0' || ch > '9') {if (ch == '-') w = -1; ch = getchar ();}
	while (ch >='0' && ch <= '9') s = s*10 + ch-'0', ch = getchar ();
	return s * w;
}

int dp[20][20], a[20];

int main() {
	IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据
    int t;
    cin >> t;
    while(t--){
        int n, m;
        cin >> m >> n;
        re(dp);
        dp[0][0] = 1;//00是一种方案
        for(int i = 0; i <= m; ++i){
            for(int j = 1; j <= n; ++j){
                dp[i][j] = dp[i][j - 1];//上一个的数字方案个数（比如这次是4位，上次就是3位）
                if(i >= j) dp[i][j] += dp[i - j][j];
            }
        }
        cout << dp[m][n] << endl;
    }
    return 0;
}
//-----------------------------------------------------dfs
int dfs(int sum, int start){
    if(sum == 0)
        return 1;
    if(start == 0)
        return 0;
    if(sum == start)
        return 1 + dfs(sum, start - 1);
    if(sum > start)
        return dfs(sum - start, start) + dfs(sum, start - 1);
    if(start > sum)
        return dfs(sum, sum);
}

int main() {
	IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据
    int t;
    cin >> t;
    while(t--){
        int n, m;
        cin >> m >> n;
        cout << dfs(m, n) << endl;
    }
    return 0;
}

五、家谱树

这居然是裸的拓扑排序，人傻了，果然对图掌握的可以说是基本没有
（acwing有，没报班看不了）
我不知道对没有，样例过了，有机会的话，或者你愿意的话交了给我说说吧
在这里插入图片描述

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include<cmath>
#include<queue>
#include<stack>
#define IOS ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL);
using namespace std;

const int maxx = 1e4 + 5;
const int maxn = 1e6 + 5;

#define N 10000100
#define ll long long
#define endl '\n'
const ll  mod = 998244353;
#define test printf("--------------------------\n");
#define re(a) memset((a), 0, sizeof((a)))
#define remax(a) memset((a), 0x3f3f3f3f, sizeof((a)))

inline int read () {
	int s = 0, w = 1; char ch = getchar ();
	while (ch < '0' || ch > '9') {if (ch == '-') w = -1; ch = getchar ();}
	while (ch >='0' && ch <= '9') s = s*10 + ch-'0', ch = getchar ();
	return s * w;
}

int in[105];
vector<int> v[105];
vector<int> ans;

int main() {
	IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据
	int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        int temp;
        while(cin >> temp && temp){
            ++in[temp];
            v[i].push_back(temp);
        }
    }
    queue<int> q;
    for (int i = 1; i <= n; ++i){
        if(in[i] == 0) {
            q.push(i);
        }
    }
    while(!q.empty()) {
        int t = q.front();
        q.pop();
        ans.push_back(t);

        for(auto w : v[t]){
            --in[w];
            if(in[w] == 0)
                q.push(w);
        }
    }
    for(auto w : ans){
        cout << w << " ";
    }
        return 0;
}

几个要素：
入度，入读为0的点反复加入知道没有能加的
queue vector关系 vector答案

最大食物链计数增加了对入度出度的考察

int in[maxn], out[maxn];
vector<int> v[maxn];
vector<int> ans;
int lu[maxn];//路径

int main() {
	IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据
	int n, m;
	cin >> n >> m;
	for (int i = 1; i <= m; ++i) {
		int temp, ou;
		cin >> temp >> ou;
		++in[ou], ++out[temp];
		v[temp].push_back(ou);
	}
	queue<int> q;
	for (int i = 1; i <= n; ++i) {
		if (in[i] == 0) {
			q.push(i);
			lu[i] = 1;
		}
	}
	while (!q.empty()) {
		int t = q.front();
		q.pop();
		ans.push_back(t);

		for (auto w : v[t]) {
			--in[w];
			lu[w] = (lu[w] + lu[t]) % 80112002;//加上上一个点被经过的路径
			if (in[w] == 0)
				q.push(w);
		}
	}
	int res = 0;
	for (int i = 1; i <= n; ++i) {
		if (out[i] == 0) {//去看题解为什么
			res = (res + lu[i]) % 80112002;
		}
	}
	cout << res;
	return 0;
}

先存着到时候看

六、Connect

嘿嘿知道了cf怎么搜题，就是直接改网址链接

一眼觉得是双端队列bfs
但是不是这个思路哈

这题居然是求出能到的没有代价的地方，暴力枚举所有点求一个最小值。
因为最多只能建一个通道，而且保证一定有解。

这里枚举所有点，还涉及到了曼哈顿距离那个定理，说白了就是折现和直线的距离是一样的

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include<cmath>
#include<stack>
#include<queue>
#define IOS ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL);
using namespace std;

const int maxx = 1e4 + 5;
const int maxn = 1e6 + 5;

#define N 10000100
#define ll long long
#define endl '\n'
const ll  mod = 998244353;
#define test printf("--------------------------\n");
#define re(a) memset((a), 0, sizeof((a)))
#define remax(a) memset((a), 0x3f3f3f3f, sizeof((a)))

inline int read () {
	int s = 0, w = 1; char ch = getchar ();
	while (ch < '0' || ch > '9') {if (ch == '-') w = -1; ch = getchar ();}
	while (ch >='0' && ch <= '9') s = s*10 + ch-'0', ch = getchar ();
	return s * w;
}

int n, m;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
char g[55][55];
bool vis[55][55];

 
 vector<pair<int, int>> v, vv;

 void bfs(int x1, int y1)
 {
     queue<pair<int, int>> q;
     q.push({x1, y1});
     v.push_back({x1, y1});
     vis[x1][y1] = true;
     while (!q.empty())
     {
         pair<int, int> se = q.front();
         q.pop();

         for (int i = 0; i < 4; ++i)
         {
             int xx = se.first + dx[i];
             int yy = se.second + dy[i];

             if (xx >= 1 && xx <= n && yy >= 1 && yy <= n && !vis[xx][yy] && g[xx][yy] == '0')
             {
                 vis[xx][yy] = true;
                 q.push({xx, yy});
                 v.push_back({xx, yy});
             }
         }
     }
    
}

void bbfs(int x1, int y1)
 {
     re(vis);
     queue<pair<int, int>> q;
     q.push({x1, y1});
     vv.push_back({x1, y1});
     vis[x1][y1] = true;
     while (!q.empty())
     {
         pair<int, int> se = q.front();
         q.pop();

         for (int i = 0; i < 4; ++i)
         {
             int xx = se.first + dx[i];
             int yy = se.second + dy[i];

             if (xx >= 1 && xx <= n && yy >= 1 && yy <= n && !vis[xx][yy] && g[xx][yy] == '0')
             {
                 vis[xx][yy] = true;
                 q.push({xx, yy});
                 vv.push_back({xx, yy});
             }
         }
     }
    
}

int main(){
    IOS;
	// freopen("P1908_6.in","r",stdin);//读入数据
	// freopen("P1908.out","w",stdout); //输出数据
    cin >> n;
    int x1, y1, x2, y2;
    cin >> x1 >> y1 >> x2 >> y2;
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= n; ++j)
            cin >> g[i][j];//这里不要cin>>g[i]， 错傻了怎么找都觉得没问题，最后居然是这里
    bfs(x1, y1);
    bbfs(x2, y2);
    int ans = 0x3f3f3f3f;
    for (int i = 0; i < v.size(); ++i){
        for (int j = 0; j < vv.size(); ++j){
            int temp = (v[i].first - vv[j].first) * (v[i].first - vv[j].first) + (v[i].second - vv[j].second) * (v[i].second - vv[j].second);
            ans = min(ans, temp);
        }
    }
    cout << ans << endl;
    return 0;
}

总结

我怎么这么菜啊（哀嚎）

蛀牙牙乐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
3.28学习心得
lxddddas的博客
03-28 269
本周主要练习了一些分治算法和动态规划的题目. 第一题。光荣的梦想 题目 Prince 对他在这片大陆上维护的秩序感到满意，于是决定启程离开艾泽拉斯。在他动身之前，Prince 决定赋予 King_Bette 最强大的能量以守护世界、保卫这里的平衡与和谐。在那个时代，平衡是个梦想。因为有很多奇异的物种拥有各种不稳定的能量，平衡瞬间即被打破。KB 决定求助于你，帮助他完成这个梦想。 一串数列即表示一个...
Java面试题
qq_32362489的博客
03-10 686
目录 1... JAVA系列... 10 1.1 常用容器... 10 1.2 ArrayList 和 linkedlist 区别。ArrayList 是否会越界... 12 1.3 ArrayList 和 hashset 的区别。hashset 存的数是否有序。... 12 1.4 HashMap与HashTable的区别... 13 1.5...
Python 练习 3.22~3.28
laLuna_的博客
03-28 336
Python 练习 3.22~3.28 目录Python 练习 3.22~3.28第3章-16 删除重复字符第3章-17 删除字符第3章-18 输出10个不重复的英文字母第3章-22 输出大写英文字母输入格式：输出格式：输入样例1：输出样例1：输入样例2：输出样例2：参考代码：第3章-21 判断回文字符串第4章-4 验证“哥德巴赫猜想” 第3章-16 删除重复字符 难点： 字符串去重与排序。 解决方法： 遍历字符串列表，注意循环语句： while i < len(letter): whil
ETL工程师面试题
weixin_47139678的博客
11-02 2255
ls、cd、pwd、mkdir、rmdir、cp、rm、mv、cat、tac、nl、more、less、head、tail、df、du、seq、chmod、echo、wc、sort、su、find、zip、unzip、gzip、ps、grep、sed、awk等。5.高性能：数据仓库的构建将大大缩短获取信息的时间，数据仓库作为数据的集合，所有的信息都可以从数据仓库直接获取，尤其对于海量数据的关联查询和复杂查询，所以数据仓库分层有利于实现复杂的统计需求，提高数据统计的效率。DELETE FROM 删除；
【刷（shui）题记录】201803
MEET YOU FIRST TIME
03-01 400
三月了，又是一个新的起点，继续前行。 3.1 说实话今天口胡了一道题，一直在思考，做的题比较少（也比较水） 然后第一次自己打SAM什么的，太弱了qwq。 BZOJ1303——Others——Miscellaneous 将大于中位数的值设为1，小于的设为-1，等于的设为0，则可以制造一个前缀和数组——在数组中只要某两个位置中值相等，则说明存在一段和为0的段，只需要排个序统计下即可。 ...
蓝桥杯试题及答案分享(Python版)
热门推荐
计算机视觉方面的点点滴滴，欢迎一起讨论
06-10 1万+
蓝桥杯比赛介绍，Python组竞赛，试题分析与代码解读
妇产科学习题---有答案
daanziliao的博客
07-13 3772
第一章 女性生殖系统解剖一、选择题 1．女性外阴血肿最易发生在 A．小阴唇 B．大阴唇 C．会阴部 D．阴阜部 E．阴蒂部 2．子宫最狭窄的部分是 A．组织学内口 B．解剖学内口 C．子宫颈管D．子宫峡部 E．子宫外口 3．卵巢动脉、静脉经什么韧带进入卵巢门? A．圆韧带 B．骨盆漏斗韧带 C．主韧带 D．子宫阔韧带 E. 卵巢固有韧带 4．切除子宫附件时，切断哪根韧带易损伤输尿管? A．骨盆漏斗韧带 B．骶韧带 C．主韧带 D．阔韧带 E．圆韧带 5．月经后子宫内膜的再生起于 A．子宫肌层 B
26 Linux高级篇-Linux面试题
虎慕的博客
08-31 910
20道常见Linux面试题。
华为 笔试 4.24 第二题：这一题只通过了36%why
每天多一点干货
04-24 1096
小米# #小米求职进展汇总#rt，投的日常实习，自动驾驶方向，因为暑期实习没有想去的岗位。只有一面，本人是自动化专业，简历上主要是嵌入式方向的，面试的岗位是。担惊受怕日子我真的过够了，每天对电话和信息都应激了，虽然感觉二面我回答的很勾史，但是还是希望美团救救。这次只问了第一个java项目，先介绍有无难点，然后问了某块设计的流程，问库存秒杀流程，然后就问到了r。目前面过的厂如下：美团，整个暑期实习的第一面，表现太差，一面挂。
高二英语下学期第三次双周考试题(3.28) 试题.doc
11-02
高二英语下学期第三次双周考试题(3.28) 试题.doc
wiztree v3.28
02-12
WizTree 3.28 是一个可以用来查找占用大量分区的无用文件和文件夹的查找大文件工具,界面中还会将搜索出来的文件夹从大到小排列,并且还会显示占用百分比、占用空间、文件数量、子文件夹数量等信息,可以直接进行删除等...
arcgis 3.28版本
06-13
ArcGIS API 3.28 是一款用于地理信息系统（GIS）开发的重要工具，由Esri公司提供，主要用于构建Web和移动应用程序。这个版本是针对ArcGIS平台的一个前端开发接口，它允许开发者通过JavaScript、Flex、Silverlight等...
3.28
03-29
3.28 #define _CRT_SECURE_NO_WARNINGS 1 //关键字typedef //3.28 // int main（）// {// // typedef-类型定义-类型重定义// typedef unsigned int u_int; // unsigned int num = 20; // u_int num2 = 20; //返回0...
Mesh Baker 3.28.1
10-21
Unity开发优化必备，DrawCall性能优化的必备工具，Mesh合并、Material合并、Texture合并等等
函数模板与类模板
程序员_小兵
07-12 1292
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
Linux C | 管道open打开方式
最新发布
I_feige的博客
07-12 238
1.
初始C++
2302_81016149的博客
07-08 799
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
C++ 多态
wxk2227814847的博客
07-10 758
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
ubuntu安装cmake3.28
04-16
要在Ubuntu上安装CMake 3.28，可以按照以下步骤进行操作： 1. 打开终端，可以使用快捷键Ctrl+Alt+T。 2. 更新软件包列表，输入以下命令并按下回车键： ``` sudo apt update ``` 3. 安装CMake，输入以下命令并按...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值