4.1 八皇后问题 - 传统dfs，爬山法，首选爬山法，模拟退火 --- 实现代码附详细注释

最新推荐文章于 2023-10-17 18:49:41 发布
最新推荐文章于 2023-10-17 18:49:41 发布
阅读量783 收藏 14
点赞数 1
分类专栏： 人工智能：一种现代的方法 （学习笔记） ACM # 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45919985/article/details/115681751
版权
本文对比了传统的深度优先搜索（DFS）算法与随机重启爬山法（randomRestart）、模拟退火搜索（simulated Annealing）在解决八皇后问题中的效率和全局最优解的寻优过程。通过实例代码展示了这些算法的不同策略，以及它们在复杂性与搜索效率上的差异。
摘要由CSDN通过智能技术生成

传统解法 - 深度优先搜索（DFS):

#include <iostream>
#include <cstdio>
using namespace std;
#define ll long long
const int maxn = 200005;
const int INF = 0x3f3f3f;

int n,a[50],ans = 0;
bool vis[3][50];
int cnt = 0;

void dfs(int i) {
    ++cnt;
    if(i == n+1) {
        ++ans;
        for(int _i = 1; _i <= n; ++_i){
            cout << "(" << _i << "," << a[_i] << ") ";
        }
        cout << endl;
        return;
    }
    for(int j = 1; j <= n; ++j)
        if(!vis[0][j] && !vis[1][j+i] && !vis[2][j-i+n]) {
        a[i] = j;
        vis[0][j] = 1; //列
        vis[1][j+i] = 1;
        vis[2][j-i+n] = 1;
        dfs(i+1);
        vis[0][j] = 0; //列
        vis[1][j+i] = 0;
        vis[2][j-i+n] = 0;
    }
    return;
}

int main() {
    cout << "输入n: "; //输入n皇后
    cin >> n;
    dfs(1);
    cout << "共有" << ans << "种解法" << endl;
    cout << "基本操作执行次数：" << cnt << endl;
    return 0;
}

输出：
在这里插入图片描述

下山法（HILL-CLIMBING):
在这里插入图片描述

#include <iostream>
#include <time.h>
#include <stdlib.h>
#include <algorithm>
#include <cmath>
using namespace std;

int queens[8][8];  // 8*8棋盘
int temp[8][8];
int totalTrial;   // 统计移动步数

// 随机生成初始状态
void initial() { //皇后不允许跨行移动
    for (int i = 0; i < 8; ++i) {
        for (int j = 0; j < 8; j++) {
            queens[i][j] = 0;
        }
    }
    for (int i = 0; i < 8; i++) {
        int num = rand() % 8;
        queens[i][num] = 1;
    }
}

void _print() {
    for (int i = 0; i < 8; ++i) {
        for (int j = 0; j < 8; j++)
            cout << queens[i][j] << " ";
        cout << endl;
    }
}

// 统计在该位置下所有皇后的冲突个数
int findCollision(int row, int col) {
    int count = 0;
    // 该位置为1
    temp[row][col] = 1;
    for (int k = 0; k < 64; k++) {
        if (temp[k/8][k%8] == 1) {
            for (int i = 0; i < 8; i++)                             // 同一列
                if (i != k/8 && temp[i][k%8] == 1)
                    count++;
            for (int i = k/8, j = k%8; i < 8 && j < 8; i++, j++)    // 右下方
                if (i != k/8 && temp[i][j] == 1) 
                    count++;
            for (int i = k/8, j = k%8; i >= 0 && j >= 0; i--, j--)  // 左上方
                if (i != k/8 && temp[i][j] == 1) 
                    count++;
            for (int i = k/8, j = k%8; i < 8 && j >= 0; i++, j--)   // 左下方
                if (i != k/8 && temp[i][j] == 1) 
                    count++;
            for (int i = k/8, j = k%8; i >= 0 && j < 8; i--, j++)   // 右上方
                if (i != k/8 && temp[i][j] == 1)
                    count++;
        }
    }
    temp[row][col] = 0;  // 复原位置
    return count/2;
}

bool check(int h[8][8]) {
    for (int i = 0; i < 8; i++) {
        bool flag = false;
        for (int j = 0; j < 8; j++) {
            if (queens[i][j] == 1 && h[i][j] == 0) { //皇后所在位置没有冲突
                flag = true;
                break;
            }
        }
        if (!flag) { // 皇后所在位置仍有冲突，还需要继续查找
            return false;
        }
    }
    return true;
}

// 爬山法
bool hillClimbing(bool b) {
    // 尝试次数大于100则判定为无解
    for (int trial = 0; trial <= 100; trial++) {
        if(b) {cout << "trial:" << trial << endl; _print(); cout << endl;}
        // 拷贝原始棋盘数据到temp
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                temp[i][j] = queens[i][j];
            }
        }
        int h[8][8];
        int minH = 9999; //代价函数h(x)的最小取值
		int minX = 0, minY = 0;
		int curState = 0; //当前状态的代价
		bool f_curState = false;
        for (int i = 0; i < 8; i++) { // 8 * 7 共56种选择
            for (int j = 0; j < 8; j++) {
				if(queens[i][j] == 1 && f_curState) {
					h[i][j] = f_curState;
					continue;
				}
                // 在计算h(i, j)之前，对i行所有位置赋值为0，因为皇后不能换行移动， 所以皇后只有可能出现在其所在行某一位置
                for (int k = 0; k < 8; k++)
                    temp[i][k] = 0;
                // 查找h(i, j)
                h[i][j] = findCollision(i, j);
                // 当前状态的h值
                if (queens[i][j] == 1) {
                    curState = h[i][j];
					f_curState = true;
                }
                // 先找出冲突个数最小的位置
                if (h[i][j] < minH) {
                    minH = h[i][j];
                    minX = i;
                    minY = j;
                }
                // 计算h(i,j)之后要复原数据，避免计算错误
                for (int k = 0; k < 8; k++)
                    temp[i][k] = queens[i][k];
            }
        }
        // 将皇后放在该行冲突最少的位置处
        if (curState > minH) {
            for (int i = 0; i < 8; i++)
                queens[minX][i] = 0;
            queens[minX][minY] = 1;   
        }
        // 判断是否找到解, 有解则返回值为真
        if (check(h)) {
            totalTrial += trial;
            return true;
        }
    }
    return false;
}

int HILL_CLIMBING() {
    int count = 0;
    for (int i = 0; i < 1000; i++) {
        initial();
        if (hillClimbing(0))
            count++;
    }
    return count;
}

int main() {
    srand((int)time(0));
    initial();
    cout << "HILL-CLIMBING searching..." << endl;
    // totalTrial = 0;
    // int count = HILL_CLIMBING();
    // cout << "HILL-CLIMBING[success/total]: " << count << "/1000" << endl;
    // cout << "average steps: " << totalTrial/count << endl;
    if(hillClimbing(1)) {
        cout << "Find answer!" << endl;
    }
    else cout << "Unsuccessful!" << endl;
}

首选爬山法：
在这里插入图片描述

#include <iostream>
#include <time.h>
#include <stdlib.h>
#include <algorithm>
#include <cmath>
using namespace std;

int queens[8][8];  // 8*8棋盘
int temp[8][8];
int totalTrial;   // 统计移动步数

// 随机生成初始状态
void initial() { //皇后不允许跨行移动
    for (int i = 0; i < 8; ++i) {
        for (int j = 0; j < 8; j++) {
            queens[i][j] = 0;
        }
    }
    for (int i = 0; i < 8; i++) {
        int num = rand() % 8;
        queens[i][num] = 1;
    }
}

void _print() {
    for (int i = 0; i < 8; ++i) {
        for (int j = 0; j < 8; j++)
            cout << queens[i][j] << " ";
        cout << endl;
    }
}

// 统计在该位置下所有皇后的冲突个数
int findCollision(int row, int col) {
    int count = 0;
    // 该位置为1
    temp[row][col] = 1;
    for (int k = 0; k < 64; k++) {
        if (temp[k/8][k%8] == 1) {
            for (int i = 0; i < 8; i++)                             // 同一列
                if (i != k/8 && temp[i][k%8] == 1)
                    count++;
            for (int i = k/8, j = k%8; i < 8 && j < 8; i++, j++)    // 右下方
                if (i != k/8 && temp[i][j] == 1) 
                    count++;
            for (int i = k/8, j = k%8; i >= 0 && j >= 0; i--, j--)  // 左上方
                if (i != k/8 && temp[i][j] == 1) 
                    count++;
            for (int i = k/8, j = k%8; i < 8 && j >= 0; i++, j--)   // 左下方
                if (i != k/8 && temp[i][j] == 1) 
                    count++;
            for (int i = k/8, j = k%8; i >= 0 && j < 8; i--, j++)   // 右上方
                if (i != k/8 && temp[i][j] == 1)
                    count++;
        }
    }
    temp[row][col] = 0;  // 复原位置
    return count/2;
}

bool check(int h[8][8]) {
    for (int i = 0; i < 8; i++) {
        bool flag = false;
        for (int j = 0; j < 8; j++) {
            if (queens[i][j] == 1 && h[i][j] == 0) { //皇后所在位置没有冲突
                flag = true;
                break;
            }
        }
        if (!flag) { // 皇后所在位置仍有冲突，还需要继续查找
            return false;
        }
    }
    return true;
}

// 首选爬山法
bool firstchose(bool b) {
    // 尝试次数大于100则判定为无解
    for (int trial = 0; trial <= 100; trial++) {
        if(b) {cout << "trial:" << trial << endl; _print(); cout << endl;}
        // 拷贝原始棋盘数据到temp
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                temp[i][j] = queens[i][j];
            }
        }
        int h[8][8], curState;
		bool f_curState = false;
        for (int i = 0; i < 8; i++) { // 8 * 7 共56种选择
            for (int j = 0; j < 8; j++) {
				if(queens[i][j] == 1 && f_curState) {
					h[i][j] = f_curState;
					continue;
				}
                // 在计算h(i, j)之前，对i行所有位置赋值为0
                for (int k = 0; k < 8; k++)
                    temp[i][k] = 0;
                // 查找h(i, j)
                h[i][j] = findCollision(i, j);
                // 当前状态的h值
                if (queens[i][j] == 1) {
                    curState = h[i][j];
					f_curState = false;
                }
                // 计算h(i,j)之后要复原数据，避免计算错误
                for (int k = 0; k < 8; k++)
                    temp[i][k] = queens[i][k];
            }
        }
        // 随机选取第一个优于当前状态的下一状态
        bool better = false;
        int next, nextState, times = 0;
        while (!better) {
            next = rand() % 64;
            nextState = h[next/8][next%8];
            if (nextState < curState) {
                better = true;
            }
            if (++times > 100) break;
        }
        if (better) {
            for (int i = 0; i < 8; i++)
                queens[next/8][i] = 0;
            queens[next/8][next%8] = 1;  // 放置皇后
        }
        // 判断是否找到解, 有解则返回值为真
        if (check(h)) {
            totalTrial += trial;
            return true;
        }
    }
    return false;
}

// 首选爬山法
int firstChose() {
    int count = 0;
    for (int i = 0; i < 1000; i++) {
        initial();
        if (firstchose(0))
            count++;
    }
    return count;
}

int main() {
    srand((int)time(0));
    initial();
    cout << "FIRT-CHOSE searching..." << endl;
    // totalTrial = 0;
    // int count = firstChose();
    // cout << "FIRT-CHOSE[success/total]: " << count << "/1000" << endl;
    // cout << "average steps: " << totalTrial/count << endl;
    if(firstchose(1)) {
        cout << "Find answer!" << endl;
    }
    else cout << "Unsuccessful!" << endl;
}

随机重启爬山法（random restart hill climbing):
在这里插入图片描述
字面意思：就是不停调用爬山法，直到找到为止，因此就不贴完整代码了。

// 随机重新开始爬山法
int randomRestart() {![在这里插入图片描述](https://img-blog.csdnimg.cn/20210413232437811.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkxOTk4NQ==,size_16,color_FFFFFF,t_70#pic_center)

    bool find = false;
    while (!find) {
        initial();
        find = hillClimbing();
    }
    return find;
}

模拟退火搜索（SIMULATED-ANNEALING）：

在这里插入图片描述
久闻模拟退火搜索大名，终于碰到了

#include <iostream>
#include <time.h>
#include <stdlib.h>
#include <algorithm>
#include <cmath>
using namespace std;

int queens[8][8];  // 8*8棋盘
int temp[8][8];
int totalTrial;   // 统计移动步数

// 随机生成初始状态
void initial() { //皇后不允许跨行移动
    for (int i = 0; i < 8; ++i) {
        for (int j = 0; j < 8; j++) {
            queens[i][j] = 0;
        }
    }
    for (int i = 0; i < 8; i++) {
        int num = rand() % 8;
        queens[i][num] = 1;
    }
}

void print() {
    for (int i = 0; i < 8; ++i) {
        for (int j = 0; j < 8; j++)
            cout << queens[i][j] << " ";
        cout << endl;
    }
}

// 统计在该位置下所有皇后的冲突个数
int findCollision(int row, int col) {
    int count = 0;
    // 该位置为1
    temp[row][col] = 1;
    for (int k = 0; k < 64; k++) {
        if (temp[k/8][k%8] == 1) {
            for (int i = 0; i < 8; i++)                             // 同一列
                if (i != k/8 && temp[i][k%8] == 1)
                    count++;
            for (int i = k/8, j = k%8; i < 8 && j < 8; i++, j++)    // 右下方
                if (i != k/8 && temp[i][j] == 1) 
                    count++;
            for (int i = k/8, j = k%8; i >= 0 && j >= 0; i--, j--)  // 左上方
                if (i != k/8 && temp[i][j] == 1) 
                    count++;
            for (int i = k/8, j = k%8; i < 8 && j >= 0; i++, j--)   // 左下方
                if (i != k/8 && temp[i][j] == 1) 
                    count++;
            for (int i = k/8, j = k%8; i >= 0 && j < 8; i--, j++)   // 右上方
                if (i != k/8 && temp[i][j] == 1)
                    count++;
        }
    }
    temp[row][col] = 0;  // 复原位置
    return count/2;
}

bool check(int h[8][8]) {
    for (int i = 0; i < 8; i++) {
        bool flag = false;
        for (int j = 0; j < 8; j++) {
            if (queens[i][j] == 1 && h[i][j] == 0) { //皇后所在位置没有冲突
                flag = true;
                break;
            }
        }
        if (!flag) { // 皇后所在位置仍有冲突，还需要继续查找
            return false;
        }
    }
    return true;
}

// 模拟退火搜索 
bool simulated() {
    double temperature = 5; //初始温度
    int trial = 0;
    while (temperature > 0.00001) {
        // 拷贝原始棋盘数据到temp
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                temp[i][j] = queens[i][j];
            }
        }
        int h[8][8], curState;
		bool f_curState = false;
        for (int i = 0; i < 8; i++) { // 8 * 7 共56种选择
            for (int j = 0; j < 8; j++) {
				if(queens[i][j] == 1 && f_curState) {
					h[i][j] = f_curState;
					continue;
				}
                // 在计算h(i, j)之前，对i行所有位置赋值为0
                for (int k = 0; k < 8; k++)
                    temp[i][k] = 0;
                // 查找h(i, j)
                h[i][j] = findCollision(i, j);
                // 当前状态的h值
                if (queens[i][j] == 1) {
                    curState = h[i][j];
					f_curState = false;
                }
                // 计算h(i,j)之后要复原数据，避免计算错误
                for (int k = 0; k < 8; k++)
                    temp[i][k] = queens[i][k];
            }
        }
        // 随机选取一个下一状态
        bool better = false;
        int next, nextState, times = 0;
        next = rand() % 64;
        nextState = h[next/8][next%8];
        int E = nextState - curState;
        if (E < 0) { //下一状态代价更小， 爬山
            better = true;
        } 
        else if (exp((-1)*E/temperature) > ((double)(rand() % 1000) / 1000)) { //e^E/T 随温度降低越来越小->慢慢降低摇晃的强度
                                                                               //((double)(rand() % 1000) / 1000) 生成<1的随机小数
            better = true;
        }
        if (better) {
            for (int i = 0; i < 8; i++)
                queens[next/8][i] = 0;
            queens[next/8][next%8] = 1;  // 放置皇后
            trial++;
        }
        // 判断是否找到解, 有解则返回值为真
        if (check(h)) {
            totalTrial += trial;
            return true;
        }
        temperature *= 0.99; //降温
    }
    return false;
}

// 模拟退火搜索
int simulatedAnnealing() {
    int count = 0;
    for (int i = 0; i < 1000; i++) {
        initial();
        if (simulated())
            count++;
    }
    return count;
}

int main(int argc, char const *argv[]) {
    srand((int)time(0));
    totalTrial = 0;
    cout << "simulated-Annealing searching..." << endl;
    int count = simulatedAnnealing();
    cout << "simulated-Annealing[success/total]: " << count << "/1000" << endl;
    cout << "average steps: " << totalTrial/count << endl;
    return 0;
}

可以看到找到退火控制在每次下降1%还是会有部分解跳了出去， 退火的原因时间明显增长， 但是在更精确的退货时间控制的情况下，算法找多全局最优解的概率接近于1
退火速度 * 99%
在这里插入图片描述
退火速度 * 99.5%
在这里插入图片描述
可以看到随着退火速度变慢，算法寻找最优解的概率显著增大

Spikeeee-
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
人工智能:用爬山法、模拟退火算法实现八皇后和八数码问题
云卷更云舒
11-04 1万+
这里简单介绍下局部搜索算法。局部搜索算法是对一个或多个状态进行评价和修改，而不是系统地从初始状态开始的路径。这些算法适用于关注那些关注解状态而不是路径代价的问题。局部搜索算法从单个当前节点出发，通常只移动到它的临近状态，一般保存搜索路径。局部搜素不是系统化的，但有两个关键的优点。 1. 只用很少的内存——通常是常熟 2. 经常能在系统化算法不适用的很大或无限的状态空间中找到合理的解。爬山法（最陡
八皇后问题和八数码问题的最陡上升爬山法、首选爬山法、随机重启爬山法、模拟退火算法的分析和实现
LoHiauFung的博客
11-01 5734
源起人工智能的第二次作业课后的某题要求对八皇后问题和八数码问题分别用最陡上升爬山法、首选爬山法、随机重启爬山法、模拟退火算法来实现，并且分析他们的性能。分析我们发现要求实现的各个算法是有共同点的，比如，八皇后问题相关算法拥有相同的状态空间，每个算法都有从当前状态获取下一状态的需求，各个算法细节不同，共同点是，它们都是算法。 基于这样的想法，我们可以将代码划分为3层： 运行示例代码比较长，附在最后
洛谷P1433 吃奶酪 DFS、模拟退火
qq_43663263的博客
07-14 156
1
模拟退火解决八皇后问题
12-29
这次程序使用C#语言，使用了人工智能中的模拟退火算法解决了八皇后的问题，界面也很完整，可以给出很完整的数据。
八皇后问题-爬山法
10-16
可自定义皇后数量，采用爬山法求解，已经vs编译通过，可运行
爬山法、模拟退火法、遗传算法实现八皇后问题
12-09
编程实现爬⼭山法，模拟退⽕火法，遗传算法，解决⼋八皇后问题。 本实验选择采⽤C++编程实现。
vray4.1-for-SketchUp2016-2019高质量渲染软件.rar
07-10
VRay是一款高质量渲染软件，基于V-Ray 内核开发的有VRay for 3ds max、Maya、Sketchup、Rhino等诸多版本，为不同领域的优秀3D建模软件提供了高质量的图片和动画渲染，方便使用者渲染各种图片。VRay将向智能化，多元...
SEAL-4.1-x64-windows.zip
最新发布
07-05
SEAL-4.1-x64-windows
【官方绿色版】gradle-4.1-rc-1-all.zip
11-08
Gradle各个版本即将上线，官网下载不成功的，嫌官网下载速度慢的，可以直接在这里下载。本人会做一个gradle全版本的搜集。 gradle-4.1 gradle android studio 离线包
Doris 1.2.4.1 Dockerfile制作 init-fe.sh
08-03
Doris 1.2.4.1 Dockerfile制作 init-fe.sh
八皇后（爬山法）
03-09
爬山法 (Hill- climbing)搜索的算法，它是一个向值增加的方向持续移动的简单循环过程——也就是，登高。是一种最简单的启发式搜索算法, 它将最陡上升方向作为搜索方向, 因此能够以最快的速度爬到山顶。它将会到达一个“峰顶”时终止，相邻状态中没有比它更高的值。这种算法不维护搜索树，因此当前节点的数据结构只需记录当前的状态和它的目标函数值。爬山法不会前瞻与当前状态不直接相邻的那些状态的值，就像健忘的人攀登珠穆朗玛峰一样。
N皇后问题求解（爬山法）
03-20
用爬山法解决N皇后问题，3000个皇后可以在1s内求得一个解
模拟退火 基因算法 八皇后问题
10-01
模拟退火 基因算法 实现八皇后问题 JAVA
Doris 1.2.4.1 Dockerfile制作 init-fe.sh 和 init-be.sh
08-03
Doris 1.2.4.1 Dockerfile制作 init-fe.sh 和 init-be.sh
爬山法实现 八皇后问题 （Python 实现）
weixin_40975029的博客
03-22 2132
本文主要简单阐述爬山法的基本算法思想，并给出用此算法实现八皇后问题详细过程 最基本的爬上搜索算法表示：(节选自《人工智能》第二版)： function HILL-CLIMBING(problem) return a state thate is a locak maximum   &...
模拟退火 八皇后_模拟退火和八皇后问题
weixin_26735933的博客
09-13 1268
模拟退火 八皇后The Simulated Annealing (SA) algorithm is one of many random optimization algorithms. Unlike algorithms like the Hill Climbing algorithm where the intent is to only improve the optimization, S...
使用爬山法、模拟退火和遗传算法求解八皇后问题
Sakura_Vv的博客
10-10 8358
使用爬山法、模拟退火和遗传算法求解八皇后问题 实验使用 C++ 语言，并在 Windows 的 Visual Studio 2017 下能够正常运行。 参考书籍：《人工智能：一种现代的方法（第三版）》 文章目录使用爬山法、模拟退火和遗传算法求解八皇后问题1. 准备阶段1.1 `Board` 类1.2 其他全局变量2. 爬山法2.1 最陡上升爬山法2.1.1 代码实现2.1.2 测试2.2 首选...
爬山法求解八皇后问题
qq_40369277的博客
10-17 1008
print("第"+str(num)+"种:",(1,queen_col_loc[0]),(2,queen_col_loc[1]),(3,queen_col_loc[2]),(4,queen_col_loc[3])queen_list.pop()#回溯，尝试当前行的其他皇后摆放方法。有一个 8 × 8 的棋盘，现在要将8个皇后放到棋盘上，满足：对于每一个皇后，在。检查当前位置是否与之前的皇后所在的主对角线和副对角线有冲突。检查当前位置是否与之前的皇后所在的列有冲突。回溯，尝试当前行的其他皇后摆放方法，从。
C语言局部搜索算法（爬山法，模拟退火法，遗传算法）求解八皇后问题
qq_44310495的博客
10-17 3653
C语言局部算法求解八皇后问题写在前面八皇后问题及局部搜索算法爬山法（hill-climbing searching)算法介绍代码实现退火法（simulated annealing)算法介绍代码实现遗传算法算法介绍代码实现 写在前面 该篇博客盖改自https://blog.csdn.net/chenxz_/article/details/83014641，习惯用python可以去参考他的代码。 八皇后问题及局部搜索算法 八皇后问题（英文：Eight queens），是由国际西洋棋棋手马克斯·贝瑟尔于1848年
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值