算法课复习 -- dp

最新推荐文章于 2024-09-09 18:27:36 发布
最新推荐文章于 2024-09-09 18:27:36 发布
阅读量284 收藏 1
点赞数
分类专栏： 算法课复习 文章标签： dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40993793/article/details/86428157
版权

HDU #2602 : Bone Collector

传送门：http://acm.hdu.edu.cn/showproblem.php?pid=2602

题意：n个东西，每个东西都有它的大小和价值。给定最大容量v，问容量为v的情况下最大价值为多少。

思路：最基本的背包类，要化成一维数组做的话从dp[n]往dp[1]就可以。

dp[i][j]：前i个东西容量为j时的最大价值。

dp[i][j] = max( dp[i][j] , dp[i][j-v[i]] + cost[i] );

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e9;
const double _e = 10e-6;
const int maxn = 1e5 + 10;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y, z;
char c;

int t, n, v;
int dp[1010], v1[1010], v2[1010];

int main()
{
	scanf("%d", &t);
	while (t--) {
		cl0(dp);
		scanf("%d%d", &n, &v);
		for (int i = 1; i <= n; i++)
			scanf("%d", &v1[i]);
		for (int i = 1; i <= n; i++)
			scanf("%d", &v2[i]);
		for (int i = 1; i <= n; i++) {
			for (int j = v; j >= 0; j--) {
				if (j - v2[i] < 0)break;
				dp[j] = max(dp[j], dp[j - v2[i]] + v1[i]);
			}
		}
		printf("%d\n", dp[v]);
	}
	return 0;
}

 

OpenJ_Bailian #2533 : Longest Ordered Subsequence

传送门：http://bailian.openjudge.cn/practice/2533?lang=en_US

题意：给一个字符串，求它的最长上升子序列的长度。

思路：dp[i]：长度为i的上升序列中，第i位的最小值。

for循环，对于 dp[i-1] < s[j] 成立的最大的 i，dp[i] = min ( dp[i] , s[j] );

直接lower_bound二分来找更新位置也是可以的。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e9;
const double _e = 10e-6;
const int maxn = 1e5 + 10;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y, z;
char c;

int t, n, v;
int a[1010], dp[1010];

int main()
{
	while (~scanf("%d", &n)) {
		for (int i = 0; i <= 1005; i++)
			dp[i] = INF;
		for (int i = 1; i <= n; i++)
			scanf("%d", &a[i]);
		for (int i = 1; i <= n; i++) {
			int pos = lower_bound(dp + 1, dp + n + 1, a[i]) - dp;
			dp[pos] = a[i];
		}
		for (int i = 1; i <= n + 1; i++) {
			if (dp[i] == INF) {
				printf("%d\n", i - 1);
				break;
			}
		}		
	}
	return 0;
}

 

HDU #1159 : Common Subsequence

传送门：http://acm.hdu.edu.cn/showproblem.php?pid=1159

题意：给两个字符串，求最长公共子串。

思路：dp[i][j]：字符串s1从0-i位置，s2从0-j位置的公共子串的最大长度。

s[i]==s[j]：dp[i][j] = max ( dp[i][j] , dp[i-1][j-1] + 1 );

s[i]!=s[j]：dp[i][j] = max ( dp[i][j] , dp[i-1][j] , dp[i][j-1] );

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e9;
const double _e = 10e-6;
const int maxn = 1e5 + 10;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y, z;
char c;

string s1, s2;
int dp[1010][1010];

int main()
{
	while (cin >> s1 >> s2) {
		int len1 = s1.length(), len2 = s2.length();
		cl0(dp);
		for (int i = 0; i < len1; i++) {
			for (int j = 0; j < len2; j++) {
				if (s1[i] == s2[j]) {
					if (i == 0 || j == 0)
						dp[i][j] = 1;
					else 					
						dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
				}
				else {
					if (i != 0)
						dp[i][j] = max(dp[i][j], dp[i - 1][j]);
					if (j != 0)
						dp[i][j] = max(dp[i][j], dp[i][j - 1]);
				}
			}
		}
		printf("%d\n", dp[len1 - 1][len2 - 1]);
	}
	return 0;
}

 

HDU #5092 : Seam Carving

传送门：http://acm.hdu.edu.cn/showproblem.php?pid=5092

题意：给出一个n行m列的矩阵。从顶上往下走，如果开始在i列，则下次只能在i-1、i、i+1列中任意一列。每个位置有一个数字，问怎么走才能使得一路上的数字之和最小。如果有相同的话取最靠右的方案。

思路：dp + 用pre数组记路。

pre记路的话，每次 dp[i][j] 更新的时候 pre[i][j] 也跟着更新，在最后利用 ans=pre[i--][ans]; 来还原。

dp[i][j]：走到第 i 行，第 j 列时的最小值。

dp[1][j] = a[1][j];

dp[i][j] = min( dp[i][j] , dp[i-1][j+k] );  ( -1 <= k <= 1 )

注意因为相同取最右，所以如果是从左往右则小于等于的时候也要更新。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e9;
const double _e = 10e-6;
const int maxn = 1e5 + 10;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y, z;
char c;

int t, n, m;
ll a[110][110], dp[110][110];
int pre[110][110];

int main()
{
	scanf("%d", &t);
	for (int _ = 1; _ <= t; _++) {
		scanf("%d%d", &n, &m);
		cl0(pre);
		for (int i = 1; i <= n; i++)
			for (int j = 1; j <= m; j++)
				dp[i][j] = INF;
		for (int i = 1; i <= n; i++)
			for (int j = 1; j <= m; j++)
				scanf("%d", &a[i][j]);
		for (int i = 1; i <= m; i++)
			dp[1][i] = a[1][i];
		for (int i = 2; i <= n; i++)
			for (int j = 1; j <= m; j++) {
				for (int k = -1; k <= 1; k++) {
					if (j + k <= 0 || j + k > m)continue;
					if (dp[i - 1][j + k] + a[i][j] <= dp[i][j]) {
						dp[i][j] = dp[i - 1][j + k] + a[i][j];
						pre[i][j] = j + k;
					}
				}
			}
		int ans = 1;
		for (int i = 2; i <= m; i++) {
			if (dp[n][i] <= dp[n][ans])
				ans = i;
		}
		stack<int> s;
		while (ans != 0) {
			s.push(ans);
			ans = pre[n--][ans];
		}
		printf("Case %d\n", _);
		printf("%d", s.top()); s.pop();
		while (!s.empty()) {
			printf(" %d", s.top());
			s.pop();
		}
		printf("\n");
	}
	return 0;
}

 

UVA #10003 : Cutting Sticks

传送门：https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=944

题意：给出木头总长度和需要切的点，每次切一块长度为n的木头需要花费n，问最少花费多少。

思路：区间dp。

dp[i][j]：点 i 到点 j 范围内的最小花费。点0为0位置，点n+1为l位置。

dp[i][j] = min ( dp[i][j] , dp[i][k] + dp[k][j] + cost[i][j] ); ( i < k < j )

最终答案为dp[0][n+1]。

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#include<bitset>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs (id*2+1)
#define Mod(a,b) a<b?a:a%b+b
#define cl0(a) memset(a,0,sizeof(a))
#define cl1(a) memset(a,-1,sizeof(a))
using namespace std;

const ll M = 1e9 + 7;
const ll INF = 1e9 + 10;
const double _e = 10e-6;
const int maxn = 1e4 + 10;
const int matSize = 9;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
const int _dx[8] = { -1,-1,-1,0,0,1,1,1 }, _dy[8] = { -1,0,1,-1,1,-1,0,1 };

int x, y, z;
char c;

int l, n;
int a[110];
int dp[110][110];

int main()
{
	while (~scanf("%d", &l)) {
		if (l == 0)break;
		for (int i = 0; i <= 100; i++)
			for (int j = 0; j <= 100; j++) {
				dp[i][j] = INF;
				if (i == j)dp[i][j] = 0;
			}		
		scanf("%d", &n);
		for (int i = 1; i <= n; i++)
			scanf("%d", &a[i]);
		a[0] = 0; a[n + 1] = l;
		for (int i = 1; i <= n + 1; i++) {
			dp[i][i - 1] = 0;
			dp[i - 1][i] = 0;
		}
		for (int len = 2; len <= n + 1; len++) {
			for (int s = 0; s <= n + 1; s++) {
				int e = s + len;
				if (e > n + 1)break;
				for (int i = s + 1; i <= e - 1; i++)
					dp[s][e] = min(dp[s][e], dp[s][i] + dp[i][e] + a[e] - a[s]);
			}
		}
		printf("The minimum cutting is %d.\n", dp[0][n + 1]);
	}
	return 0;
}

 

__喵喵喵
关注
专栏目录
DP算法
u013246297的专栏
08-08 9316
----- 线型动态规划   f[i,j]:=min(f[i,j],f[i+1,j- 1] (s[i]s[j]=”()”or(”[]”)),f[i+1,j+1]+1 (s[j]=”(”or”[” )  , f[i,j- 1]+1(s[j]=”)”or”]”);     74  棋盘切割   ----- 线型动态规划   f[k,x1,y1,x2,y2]=min{min
动态规划算法（DP）
热门推荐
那什
06-05 5万+
    校招笔试面试前，大家一般都会先去牛客网上刷刷题，《剑指offer》，《leetcode》走起来，然后初次入手，发现很多不会，不会到什么程度呢，连个想法都没有，于是就去讨论区看答案，然后java大神，c++大神会给出花式解答，他们喜欢在答案前加一句，简单的dp算法，递归就可以解决，巴拉巴拉。说的还是很详细的，然而代码并不能看懂，毕竟    人生苦短，我用python下面就先给大家举一些详细的...
DP（算法设计与分析）
04-02
对于由从1到N (1 <= N <= 39)这N个连续的整数组成的集合来说，我们有时可以将集合分成两个部分和相同的子集合。 例如，N=3时，可以将集合{1, 2, 3} 分为{1,2}和{3}。此时称有一种方式（即与顺序无关）。 N=7时，共有四种方式可以将集合{1, 2, 3, ..., 7} 分为两个部分和相同的子集合： {1,6,7} 和 {2,3,4,5} {2,5,7} 和 {1,3,4,6} {3,4,7} 和 {1,2,5,6} {1,2,4,7} 和 {3,5,6} 输入：程序从标准输入读入数据，只有一组测试用例。如上所述的N。 输出：方式数。若不存在这样的拆分，则输出0。 测试输入关于“测试输入”的帮助 期待的输出关于“期待的输出”的帮助 时间限制关于“时间限制”的帮助 内存限制关于“内存限制”的帮助 额外进程关于“{$a} 个额外进程”的帮助 测试用例 1 以文本方式显示 7↵ 以文本方式显示 4↵ 1秒 64M 0
dp算法
qq_45712954的博客
10-15 1038
一、动态规划 动态规划算法是通过拆分问题，定义问题状态和状态之间的关系，使得问题能够以递推（或者说分治）的方式去解决 明确状态和转移两个问题 二、例题 例一：数字三角形 有一个由非负整数组成的三角形，第一行只有一个数，除了最下行之外每个数的左下方和右下方各有一个数. 1 3 2 4 10 1 4 3 2 20 从第一行的数开始，每次可以往左下或右下走一格，直到走到最下行，把沿途经过的数全部加起来，如何走才能使得这个和尽量大？ 输入：三角形的行数n，数字三角形的各个数（从上到下，从左到右） 输出：最大的和。
DP 详解
最新发布
George110915的博客
09-09 4314
DP 问题在 OIer 中很受欢迎，因为每个 DP 问题在某种意义上都是原创的，你必须努力思考其状态和状态转移方程才能为其发明解决方案。由于动态规划如此受欢迎，它可能是算法竞赛中最重要的掌握方法。DP（Dynamic programming，全称动态规划），是一种基于分治，将原问题分解为简单子问题求解复杂问题的方法。动态规划的耗时往往远少于朴素（爆搜）解法。很简单的名字，即为使用空间的代价来确保不会超时。分类讨论就是分类 --> 讨论！
算法——动态规划（DP）
戏拈秃笔的博客
12-18 2764
动态规划通常用于求解最优化问题，如最长路径、最大值、最小值等。递归则更常用于遍历、搜索和排列组合等问题
NOIP NOI 信息学竞赛 ACM-ICPC POJ（北京大学在线评测系统）刷题推荐 OI复习计划 算法大纲
10-04
本文主要介绍的是关于NOIP（全国青少年信息学奥林匹克竞赛）和NOI（全国青少年信息学奥林匹克联赛）的信息学竞赛以及ACM-ICPC（国际大学生程序...，特别是通过北京大学在线评测系统（POJ）进行的刷题推荐和算法大纲...
算法设计与分析期末复习（知识点+习题详解）
02-28
### 算法设计与分析期末复习知识点及习题详解 #### 第1章 算法引论 **1.1 算法与程序** - **算法的定义**: 算法是一种精确且完整的解题方案描述，它是解决问题的具体方法和步骤。 - **算法的特征**: - **输入**...
DP专题-算法盲点扫荡：状压 DP
Plozia 的小窝
06-04 308
DP专题-算法盲点扫荡：状压 DP1. 前言2. 题单[P2396 yyy loves Maths VII](https://www.luogu.com.cn/problem/P2396)[P2150 [NOI2015] 寿司晚宴](https://www.luogu.com.cn/problem/P2150)3. 总结 1. 前言 本文是作者写的第 3 篇状压 DP 的博文，专门用来总结、复习状压 DP 这一动态规划的相关内容。 DP专题-学习笔记：状压 DP（2021/3/2） DP专题-专项训练：状
算法分析与设计（一）——0-1背包问题
LongXinKou的博客
05-25 2079
文章目录1. 背包问题1.1 0-1背包问题 在简单复习完数据结构以后，便开始了算法复习。本博客将结合复习视频与LeetCode题目，面向机考算法复习。 1. 背包问题 1.1 0-1背包问题 （1）问题描述 在背包容量有限的情况下，带走总价值最多的物品。 输入： 背包容量C n个商品组成集合，每个商品有两个属性viv_ivi​和pip_ipi​，分别表示体积和价格。 约束条件 最大化价值：max⁡∑i∈Spi\max \sum_{i \in S}p_imax∑i∈S​pi​ 背包容量限制：∑i∈Sv
常见算法小结（DP、动态规划、最长子序列、DFS、BFS等常见基础算法小集）
03-12
本资源主要是汇集了自己刷题时总结下来的一些经典题目：包括二分、字符串替换、DP问题、动态规划、最长子序列、DFS、BFS、回溯算法等，旨在记录和查看复习，为了不断提升，不断更新补充。也包括链表的一些基础，有...
算法DP总结
xiaxiaotian121的博客
11-01 378
此文章为算法设计与分析动态规划章节学习总结..... 1.基本思想 将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同，适合于用动态规划求解的问题经分解得到子问题往往不是互相独立的。 2.基本要素 （1）最优子结构性质： 原问题的最优解包含其子问题的最优解。问题的最优子结构性质，提供了该问题可用动态规划算法求解的重要线索。 （2）重叠子问题性质： 在用递归算法自顶向下解问题时，每次产生的子问题并不总是新问题，有些子问题被...
基础算法——DP
qq_43578047的博客
07-18 1048
Leetcode 120 [mid] 给定一个三角形 triangle ，找出自顶向下的最小路径和。 每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。 输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]] 输出：11 解释：如下面简图所示： 2 3 4 6 5 7 4 1 8 3 .
【算法】动态规划(dp)
bubblecheese的博客
04-08 1188
动态规划(dp)的基本方法，包含0-1背包问题。
机器学习：维特比算法（Viterbi Algorithm）
u013250861的博客
01-03 7260
一、维特比算法（Viterbi Algorithm）讲解方式01：篱笆网络（Lattice）的最短路径问题 已知下图的篱笆网络，每个节点之间的数字表示相邻节点之间的距离，举个例子来说，如果我走，这个距离是。那么如果让你从A走到E，最短路径是哪一条呢？ 显然大家都知道，通过穷举的方法是很容易得到最短路径，可是问题就在于如果穷举的话，需要的加法次数不用算你也知道实在是太多啦（每条路径需要计算次加法，一共条路径共次计算）！像这种没几层的篱笆网络也就罢了，如果每层13个节点，一共12层（然而这个规模对于标注问题来
dp算法入门（闫氏dp分析法）
m0_72400354的博客
05-06 4029
dp即是动态规划，是一种把问题分成若干个有关联的子问题来求解复杂问题的方法。dp常常适用于有重叠的子问题和最有子结构性质的问题(★ dynamic programming is a method for solving a complex problem by breaking it down into a collection of simpler subproblems.)简单来说，dp就是将复杂问题分成小问题然后表示每种问题的‘状态’并加以计算。
算法总结-DP入门
LZUwujiajun
08-02 455
一个问题必须有重叠子问题和最优子结构才可以用动态规划解决。 解决方式： 1. 递推：自底向上 2. 递归自顶向下 贪心与动态规划的区别 贪心是局部最优解，在每一次选择中，选了就不后悔。动态规划则考虑所有的子问题，选择能笑到最后的。 //数塔问题，将一些数字排成塔状，第n层有n个数字，现在从第一层走到第n层 //最后路径上最大的数字之和为多少 //用DFS做复杂度O(2^n)，存在大...
算法之动态规划总结（11种DP类型，70道全部搞懂）
pl0321的博客
04-08 4万+
简介 参考文章，将所有的DP问题分成11大类，本文将这些题目的解法进行探讨。所有题目均来自leetcode。 题目 1、线性 DP 最经典单串： 最长上升子序列 最经典双串： 最长公共子序列 经典问题： 三角形最小路径和 最大子序和 乘积最大子数组 鸡蛋掉落（DP+二分） 俄罗斯套娃信封问题 打家劫舍系列: (打家劫舍3 是树形DP) 打家劫舍 打家劫舍 II 股票系列: 买卖股票的最佳时机 买卖股票的最佳时机 II 买卖股票的最佳时机 III 买卖股票的最佳时机 IV
算法精品讲解(2)——DP问题入门（适合零基础者，一看就会）
jxwd的博客
12-07 1万+
目录前言DP问题它是什么（了解）从中学的例题谈起再来说一下，DP问题的核心思想（理解）DP问题的解决方法先说方法论：再说具体的例子例一：例二：例三：DP和搜索的关系结语DP入门介绍：先画个饼吧哈哈。看完之后，你也可以。如下，是我们本节将要讲述的内容。我们将结合着LeetCode、洛谷和CodeForce上面的一些习题来作为我们的参考。难度循序渐进，直到大于等于LeetCode Hard。文章首发于wx公众h【自学编程村】 我们下面就进入正文。大名鼎鼎的DP问题，实际上就是Dynamic programmin
算法期末复习：关键问题与求解方法
本资源是一份关于算法设计与分析的复习资料，主要涵盖了多种经典的计算机科学问题，包括但不限于装载问题、会场安排问题、虚拟汽车加油问题、区域覆盖问题以及著名的0-1背包问题。这些问题不仅考察了算法的基本原理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值