连通分量（Tarjan、Kosaraju-两遍bfs、Gabow）模版——图论

于 2020-07-24 11:37:42 发布
阅读量310 收藏 1
点赞数 2
分类专栏： # 连通分量 算法模版
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34261446/article/details/107557230
版权

定义：

如果两个顶点可以相互通达，则称两个顶点强连通 (strongly connected)。如果有向图 G 的每两个顶点都强连通，称 G 是一个强连通图。有向图的极大强连通子图，称为强连通分量 (strongly connected components)。

Tarjan算法

  • 复杂度

可以发现，运行 tarjan 算法的过程中，每个顶点都被访问了一次，且只进出了一次堆栈，每条边也只被访问了一次，所以该算法的时间复杂度为 O (n+e)。其中 n 为有向图 G 的顶点数量，e 为 G 的边数。

代码

#include<iostream>
#include<vector>
using namespace std;

const int mxn = 5010;
int Stack[mxn], top = 0;        //Tarjan 算法中的栈
bool InStack[mxn];              //某个节点是否在栈中
int DFN[mxn];                   //递归搜索到这个节点时候的 次序/编号
int Low[mxn];                   //能够追溯到的最早的 次序/编号
int ComponentNum = 0;           //强连通分量的个数
int Index = 0;                  //次序/编号/索引号
vector<int> edge[mxn];          //存图
vector<int> component[mxn];     //每个强连通分量的组成
int InComponent[mxn];           //记录每个节点所在的强连通分量
int ComponentDegree[mxn];       //记录每个强连通分量的度


void Tarjan(int u)
{
    DFN[u] = Low[u] = ++ Index;
    InStack[u] = true;
    Stack[++ top] = u;
    int v;

    for(int i = 0; i < edge[i].size(); i ++)
    {
        v = edge[u][i];
        if(! DFN[v])
        {
            Tarjan(v);
            Low[u] = min(Low[u], Low[v]);
        }
        else if(InStack[v]) Low[u] = min(Low[u], DFN[v]);       //也可以是 Low[u] = min(Low[u], Low[v]); 仅在求强连通分量的时候
    }

    if(DFN[u] == Low[u])
    {
        ComponentNum ++;
        do
        {
            v = Stack[top --];
            InStack[v] = false;
            component[ComponentNum].push_back(v);
            InComponent[v] = ComponentNum;
        }
        while(u != v);
    }
}
void init(int n)
{
    Index = 0;
   for(int i = 1; i <= n; i ++) component[i].clear(), Low[i] = DFN[i] = 0; 
}

int main()
{
    int n, m;
    while(scanf("%d %d", &n, &m) & n)
    {
        int u, v;
        for(int i = 1; i <= m; i ++)
            scanf("%d %d", &u, &v), edge[u].push_back(v);

        for(int i = 1; i <= n; i ++)
            if(! DFN[i]) Tarjan(i);

    }

    return 0;
}

Kosaraju算法——两遍dfs

  • 复杂度

    由于算法的时间取决于两次 DFS，因此时间复杂度，对于稀疏图是 O (V+E)，对于稠密图是 O (V²)，

代码（待添加）

#include<iostream>
#include<vector>
using namespace std;

const int mxn = 1e5;
vector<int> G[mxn];
vector<int> G_t[mxn];

int n, m, idx;
int vis[mxn], tim[mxn];

void dfs(int u)
{
    vis[u] = 1;
    for(int i = 0; i < G[u].size(); i ++)
    {
        int v = G[u][i];
        if(! vis[v])
            dfs(v);
    }
    tim[++ idx] = u;
}
void rdfs(int u)
{
    vis[u] = 1;
    for(int i = 0; i < G_t[u].size(); i ++)
    {
        int v = G_t[u][i];
        if(! vis[v])
            rdfs(v);
    }
}

void init(int n)
{
    idx = 0;
    memset(vis, 0, sizeof(vis));
    for(int i = 1; i <= n; i ++)
        G[i].clear(), \
            G_t[i].clear();
}

int main()
{
    while(scanf("%d %d", &n, &m) != EOF && n)
    {
        init(n);
        for(int i = 1, u, v; i <= m; i ++)
        {
            scanf("%d %d", &u, &v);
            G[u].push_back(v);
            G_t[v].push_back(u);
        }

        for(int i = 1; i <= n; i ++)
        {
            if(! vis[i])
                dfs(i);
        }
        memset(vis, 0, sizeof(vis));
        int sum = 0;                        //强连通分量 的数量
        for(int i = n; i >= 1; i --)
        {
            if(! vis[tim[i]])
                rdfs(tim[i]), sum ++;
        }
        printf("%d\n", sum);
    }

    return 0;
}
/*
12
16
12 11
11 8
11 10
8 10
10 9
9 8
9 7
7 6
5 7
6 5
6 4
6 3
4 3
2 3
3 2
4 1
*/

Gabow算法

  • 复杂度

O (v + e),Tarjan 算法和 Gabow 算法其实是同一个思想的不同实现，但是，Gabow 算法更精妙，时间更少 (不用频繁更新 Low [])。

代码

#include<iostream>
#include<vector>
#include<stack>
using namespace std;

const int mxn = 1e5;
vector<int> edge[mxn];      //邻接表存图
int order[mxn];             //存储节点被递归遍历的到的次序，注意这个次序号的 大小 是作为判断：强连通分量的 根的依据
int idx = 0;                //遍历的次序
int part[mxn];              //某个节点是否已经被确定的了 在某个强连通分量中
int partnum = 0;            //强连通分量的 编号
stack<int> path;            //记录路径
stack<int> root;            //存储并不断的找，强连通分量的根

void Gabow(int u)
{
    order[u] = ++ idx;
    path.push(u);
    root.push(u);
    for(int i = 0; i < edge[u].size(); i ++)
    {
        int v = edge[u][i];
        if(order[v] == -1)          //v 没有被拜访过/编过号
            Gabow(v);
        else if(part[v] == -1)      //v 被拜访过，但是它所位于的强连通分量 还没有被分配编号
        {
            while(order[root.top()] > order[v]) root.pop();
        }
    }

    if(u == root.top())             //从节点u-> 出发 经过一些节点又回到了 -> u 说明找到一个 强连通分量
    {
        root.pop();
        partnum ++;                 //为找到的 这个强连通分量 分配编号
        int Top;
        do
        {
            Top = path.top();
            path.pop();
            part[Top] = partnum;
        } while(Top != u);
    }
}

void init(int n)
{
    idx = partnum = 0;
    for(int i = 1; i <= n; i ++)  order[i] = -1, part[i] = -1, edge[i].clear();
}

int main()
{

    return 0;
}

例题 A - 迷宫城堡 HDU - 1269

Tarjan代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <map>
/* #include <unordered_map> */
#include <bitset>
#include <vector>
#include <stack>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define ll long long
#define ull unsigned long long
#define db double
#define Pir pair<int, int>
#define PIR pair<Pir, Pir>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
using namespace std;

const int mxn = 10005;
const int mxm = 100005;
struct Edge
{
    int v, next;
} edge[mxm];
int head[mxn], vis[mxn];
stack<int> st;
int num, idx, tot;
int Low[mxn], DFN[mxn];
vector<int> res[mxn];
void Add(int u, int v)
{
    edge[++ tot] = (Edge){ v, head[u] }; head[u] = tot;
}

bool Tarjan(int u)
{
    Low[u] = DFN[u] = ++ idx;
    vis[u] = 1;         //是否在 栈 里面
    st.push(u);
    for(int i = head[u]; i; i = edge[i].next)
    {
        int v = edge[i].v;
        if(! vis[v])
        {
            Tarjan(v);
            Low[u] = min(Low[u], Low[v]);       //注意这的一是 min(Low[u], Low[v]) 这与Low[v] 的值会变小有关
        }
        else if(vis[v])
        {
            Low[u] = min(Low[u], DFN[v]);
        }
    }

    if(Low[u] == DFN[u])
    {
        num ++;
        if(num >= 2) return false;
        int Top;
        do
        {
            Top = st.top();
            st.pop();
            vis[Top] = false;
            /* res[num].pb(Top); */
        } while(Top != u);
    }
    if(num >= 2) return false;
    return true;
}


void init(int n)
{
    num = idx = tot = 0;
    for_(i, 1, n) DFN[i] = Low[i] = vis[i] = head[i] = 0;     //不要忘了给 head 数组进行初始化
    while(! st.empty()) st.pop();
}

int main()
{
    //fre();
    int n, m;
    while(sc("%d %d", &n, &m) && n)
    {
        init(n);
        int u, v;
        for_(i, 1, m)
        {
            sc("%d %d", &u, &v);
            Add(u, v);
        }
        int fg = 1;
        for_(i, 1, n)
        {
            if(DFN[i] == 0)
            {
                if(Tarjan(i) == false || i > 1)
                {
                    fg = 0;
                    break;
                }
            }
        }

        if(fg)
            pr("Yes\n");
        else
            pr("No\n");
    }

    return 0;
}

Kosaraju-两遍dfs 代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <map>
/* #include <unordered_map> */
#include <bitset>
#include <vector>
#include <stack>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define ll long long
#define ull unsigned long long
#define db double
#define Pir pair<int, int>
#define PIR pair<Pir, Pir>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
using namespace std;

const int mxn = 10005;
const int mxm = 100005;
struct Edge
{
    int v, next;
} e1[mxm], e2[mxm];
int t1, t2;
int h1[mxn], h2[mxn];
void Add(int u, int v, int & tot, int h[], Edge e[])        //注意这里 tot 的声明必须是 引用！！！
{
    e[++ tot] = (Edge){ v, h[u] }; h[u] = tot;
}

int idx, vis[mxn], tim[mxn];
void dfs(int u)
{
    vis[u] = 1;
    for(int i = h1[u]; i; i = e1[i].next)
    {
        int v = e1[i].v;
        if(! vis[v])
            dfs(v);
    }
    tim[u] = ++ idx;
}
void rdfs(int u)
{
    vis[u] = 1;
    for(int i = h2[u]; i; i = e2[i].next)
    {
        int v = e2[i].v;
        if(! vis[v])
            rdfs(v);
    }
}

void init(int n)
{
    t1 = t2 = idx = 0;
    for_(i, 1, n) h1[i] = h2[i] = vis[i] = 0;    
}

int main()
{
    /* fre(); */
    int n, m;
    while(sc("%d %d", &n, &m) && n)
    {
        init(n);
        int u, v;
        for_(i, 1, m)
        {
            sc("%d %d", &u, &v);
            Add(u, v, t1, h1, e1);
            Add(v, u, t2, h2, e2);
        }
        for_(i, 1, n)
            if(! vis[i])
                dfs(i);

        for_(i, 1, n) vis[i] = 0;       //注意这里的初始化不要忘

        int fg = 0;
        for_(i, 1, n)
            if(! vis[i])
            {
                rdfs(i);
                fg ++;
                if(fg >= 2)
                    break;
            }

        if(fg == 2)
            pr("No\n");
        else
            pr("Yes\n");
    }

    return 0;
}

Gbow代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <map>
/* #include <unordered_map> */
#include <bitset>
#include <vector>
#include <stack>
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define ll long long
#define ull unsigned long long
#define db double
#define Pir pair<int, int>
#define PIR pair<Pir, Pir>
#define m_p make_pair
#define INF 0x3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
#define for_(i, s, e) for(int i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(int i = (ll)(e); i >= (ll)(s); i --)
#define sc scanf
#define pr printf
#define sd(a) scanf("%d", &a)
#define ss(a) scanf("%s", a)
using namespace std;

const int mxn = 10005;
const int mxm = 100005;
struct Edge
{
    int v, next;
} edge[mxm];
int tot, head[mxn];
void Add(int u, int v) { edge[++ tot] = (Edge){ v, head[u] }; head[u] = tot; }

int part[mxn], idx;
int order[mxn], partnum;
stack<int> path;
stack<int> root;

void Gabow(int u)
{
    path.push(u);
    root.push(u);
    order[u] = ++ idx;
    for(int i = head[u]; i; i = edge[i].next)
    {
        int v = edge[i].v;
        if(! order[v])
            Gabow(v);
        else if(! part[v])          //如果被访问过，且在 root栈中,那么v就可能是 v所属的强连通分量的根
        {
            while(order[root.top()] > order[v]) root.pop();
        }
    }
    if(u == root.top())
    {
        partnum ++;
        root.pop();
        int Top;

        do
        {
            Top = path.top();
            //vis[Top] = 0; 
            path.pop();
        } while(Top != u);
    }
}

void init(int n)
{
    tot = idx = partnum = 0;
    for_(i, 1, n) head[i] = order[i] = part[i] = 0;
}
int main()
{
    /* fre(); */
    int n, m;
    while(sc("%d %d", &n, &m) && n)
    {
        init(n);
        int u, v;
        for_(i, 1, m)
        {
            sc("%d %d", &u, &v);
            Add(u, v);
        }

        int fg = 0;
        for_(i, 1, n)
        {
            if(! order[i])
            {
                Gabow(i);
                fg += partnum;
                partnum = idx = 0;        //这里不要忘了初始化
                if(fg >= 2)
                    break;
            }
        }

        if(fg == 2)
            pr("No\n");
        else
            pr("Yes\n");
    }

    return 0;
}
做一只大熊猫
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
强连通分支算法--Tarjan算法和Gabow算法
happylife1527的专栏
09-03 924
Tarjan算法 Kosaraju算法的流程简单，但是需要对图(和逆图)进行两次DFS搜索，而且读逆图的DFS搜索中顶点的访问顺序有特定的限制。下面将介绍的两个算法的过程比Kosaraju算法更为简洁，只需要执行一次DFS，并且不需要计算逆图。 Tarjan基于递归实现的深度优先搜索，在搜索过程中将顶点不断压入堆栈中，并在回溯时判断堆栈中顶点是否在同一联通分支。函数借助两个辅助数组pre和lo
Codeforces 1133F2 Spanning Tree with One Fixed Degree【BFS+强连通分量】
qq_42211531的博客
03-10 340
传送门 题意：给你一个n个点，m条边的无向图（保证两个有一条路连通），现在要求你利用这些边生成一个棵树，保证结点1的度为k。 思路：我们要满足1的度为k，如果连接1边的数量小于 k ，那么答案肯定是 NO。如果连接 1 边的数量大于 k 我们肯定要删除多余的边，但是把边删除过后，我们还要保证剩余的边还能生成一棵树。我们要判断不是通过1结点来连接的点集有多少个，其实就是先把1连接的边去掉，判断剩...
poj 2375 BFS实现强连通分量缩点
caoyu01
08-08 463
题意：奶牛可以向相邻的并且haibo
求强连通分量的三种算法——Kosaraju, Tarjan, Gabow
chenhq1991的专栏
05-25 1340
就我所知，有三种时间复杂度为O(n)的方法可以求强连通分量，分别是Kosaraju、Tarjan和Gabow。 Kosaraju 算法的步骤为 对图G进行DFS，并按照遍历完成的先后顺序进行标号。将图G中所有的边反向得到G'。对G'进行DFS，每轮DFS都选择编号最大的点最为当前的遍历树的根。最后，遍历得到的森林就是SCC的集合。 该算法的优点在于，最后得到的节点是按照拓扑序组织
Kosaraju两次深搜实现强连通分量
08-30 224
Kosaraju两次深搜实现强连通分量 kosaraju算法进行两次dfs，第一次在原图上进行，并在结点递归调用返回时将结点压入一个栈中，第二次dfs在原图的逆图上进行，并且初始点选择栈中最上面的点，每次dfs所访问的点构成一个强连通分量。 第一次看kosaraju算法的时候，我很不解，为什么第二次dfs随便遍历一下就能找到一个强连通分量呢？后来才顿悟，这里关键是选取的遍历起始点...
HDU-1269（Tarjan模板-求强连通分量）
01-03
Tarjan求有向图的强连通分量， */ #include #include #include #include #include using namespace std; const int MAXN = 1e5 + 10; struct Edge{ int to, next, dis; }edge[MAXN << 1];
Tarjan及2-SAT讲课PPT
最新发布
10-20
Tarjan算法，源于著名计算机科学家Robert Tarjan，是一种在图论中广泛使用的高效算法，尤其在处理强连通分量的问题上展现出强大的能力。本文将深入探讨Tarjan算法的核心思想及其在2-SAT问题中的应用。 为何讲解...
图论- 图的连通性- Tarjan 求强连通分量.rar
09-16
图论是计算机科学和数学中的一个重要分支，它研究如何用图形..."图论- 图的连通性- Tarjan 求强连通分量.pdf"文档可能包含了对这个算法的详细解释、伪代码、实例分析以及相关习题，是学习和理解Tarjan算法的宝贵资源。
图论- 图的连通性- Tarjan 求双连通分量.rar
09-16
总结来说，“图论- 图的连通性- Tarjan 求双连通分量.rar”这个资源涵盖了图论中的核心概念——图的连通性和双连通分量，以及Tarjan算法这一求解双连通分量的经典方法。理解并掌握这些知识对于学习高级图算法和解决...
tarjan(e):Tarjan 的强连通分量算法-matlab开发
05-30
实现用于查找有向图的强连通分量的 Tarjan 算法。 在强连通分量 (SCC) 中，每个节点到每个其他节点都有一条路径。 SCC 是不相交的。 入度或出度为零或属于无环图的节点自己形成 SCC。 接受邻接矩阵作为输入。 为了...
gabow算法的实现
05-10
求有向图强联通分量，采用gabow算法实现
图：BFS、DFS、CycleDetection、UnionFind、Kruskal、Prim、TopoSort、Kosaraju、Tarjan、Dijkstra、BF、Floyd、Johnson
bitdai2018
03-10 715
图 阿西， 零、基本概念 图的概念： 顶点（Vertex），边（Edges），度（degree）: 入度和出度indegree，outdegree 有向无环图：DAG 握手定理（无向图）：一个聚会上，把每个人握手的次数相加必为偶数，也就是所有顶点的度加起来等于边数的两倍。 图的分类 有向图（Directed Graph）：单箭头，顶点A，B： (A,B) != (B,A) 无向图（Un-...
Gabow算法【转自nocow】
Sky_Gr_OI
04-30 835
Gabow算法 [编辑]求解有向图强连通分量的Gabow算法 Gabow算法与Tarjan算法的核心思想实质上是相通的,就是利用强连通分量必定是DFS的一棵子树 这个重要性质,通过找出这个子树的根来求解强分量.具体到实现是利用一个栈S来保存DFS遇到的 所有树边的另一端顶点,在找出强分量子树的根之后,弹出S中的顶点一一进行编号. 二者不同的是,Tarjan算法通过一个low
6.3.1 强连通分支算法--Kosaraju算法、Tarjan算法和Gabow算法
weixin_30715523的博客
11-08 251
强连通分支算法 本节内容将详细讨论有向图的强连通分支算法(stronglyconnectedcomponent)，该算法是图深度优先搜索算法的另一重要应用。强分支算法可以将一个大图分解成多个连通分支，某些有向图算法可以分别在各个联通分支上独立运行，最后再根据分支之间的关系将所有的解组合起来。 在无向图中，如果顶点s到t有一条路径，则可以知道从t到s也有一条路径；在有向无环图中个，如果顶...
Gabow算法
pi9nc的专栏
09-24 3959
有向图强连通分量的定义：在有向图G中，如果两个顶点vi,vj间（vi!= vj）有一条从vi到vj的有向路径，同时还有一条从vj到vi的有向路径，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。非强连通图有向图的极大强连通子图，称为强连通分量(stronglyconnected components)。   对于一幅无向图
Garbow算法
肘子的博客
08-13 918
Garbow算法是Tarjan算法的另一种实现，Tarjan算法里面的用dfn[maxn]和low[maxn]数组来求出强连通分量的根。Garbow在编程时是用一个堆栈来辅助求出强连通分量的根。 使用类比方法，在Tarjan算法中，每次low[v]的修改都是由于环的出现，不然，low[v]的值不可能变小。每次出现环，在这个环里面只剩下一个low[v]没有被改变(深度最低的那个)，或者全部改变，如...
强连通分量的Garbow算法
u012889441的博客
05-09 596
一、数据集形式 其中：1595446（节点个数） 0（起始边） 1（终边）二、数据集上传中等待审核成功再链接过来三、实现代码// Tarjan.cpp : Defines the entry point for the console application. //#include "stdafx.h" #include "time.h" #include <fstream> #include<
BFS和强连通分量寻找
RandomWW的博客
12-24 774
广度优先走索（BFS）与DFS的区别还是比较明显的：后者是首先朝着一个方向始终探索，直到“死路”才回溯去探索别的路口；后者则是稳步推进的方式，有点类似水纹扩散，一步一步向外扩散。在代码思想上，主要一个是运用FIFO队列一个是FILO队列。大致实现如下： from collections import deque def bfs(G, s, seq, ans): # G是图，s是起始点，seq是F...
Kosaraju算法的分析和证明
...
11-06 525
首先提出图的转置的概念。所谓转置就是将一个图上所有的有向边反向。简单来说就是本是x->y的一条边，现在变为y->x这样一条边。 另外强连通性质具有传递性，如果(i,j),(j,k)属于同一强连通分量，那么(i,k)属于同一强连通分量。因为如果满足题设，那么存在路径i->j->k和k->j->i。所以传递性得证。所以其实我们要求点i所属的极大强连通分量，只需要把所有和i可以互达的点求出来就可以了。
Tarjan与2-SAT图论算法详解PPT
Tarjan算法是图论中常见的一种方法，可以用于缩点和求强连通分量。 Tarjan算法的重要性在于它可以将有向图中的强连通分量缩成一个点，从而将原图转化为一个有向无环图。这个过程可以通过DFS来实现。首先对于一个图...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值