线段树

最新推荐文章于 2023-09-22 21:17:03 发布
最新推荐文章于 2023-09-22 21:17:03 发布
阅读量157 收藏
点赞数 1
分类专栏： 数据结构与算法

转载自：http://blog.csdn.net/metalseed/article/details/8039326

一：线段树基本概念

1：概述
线段树，类似区间树，是一个完全二叉树，它在各个节点保存一条线段（数组中的一段子数组），主要用于高效解决连续区间的动态查询问题，由于二叉结构的特性，它基本能保持每个操作的复杂度为O(lgN)!
性质：父亲的区间是[a,b],(c=(a+b)/2)左儿子的区间是[a,c]，右儿子的区间是[c+1,b]，线段树需要的空间为数组大小的四倍

2：基本操作（demo用的是查询区间最小值）
线段树的主要操作有：
(1)：线段树的构造 void build(int node, int begin, int end);
主要思想是递归构造，如果当前节点记录的区间只有一个值，则直接赋值，否则递归构造左右子树，最后回溯的时候给当前节点赋值

#include <iostream>  
using namespace std;  

const int maxind = 256;  
int segTree[maxind * 4 + 10];  
int array[maxind];   
/* 构造函数，得到线段树 */  
void build(int node, int begin, int end)    
{    
    if (begin == end)    
        segTree[node] = array[begin]; /* 只有一个元素,节点记录该单元素 */  
    else    
    {     
        /* 递归构造左右子树 */   
        build(2*node, begin, (begin+end)/2);    
        build(2*node+1, (begin+end)/2+1, end);   

        /* 回溯时得到当前node节点的线段信息 */    
        if (segTree[2 * node] <= segTree[2 * node + 1])    
            segTree[node] = segTree[2 * node];    
        else    
            segTree[node] = segTree[2 * node + 1];    
    }    
}  

int main()  
{  
    array[0] = 1, array[1] = 2,array[2] = 2, array[3] = 4, array[4] = 1, array[5] = 3;  
    build(1, 0, 5);  
    for(int i = 1; i<=20; ++i)  
     cout<< "seg"<< i << "=" <<segTree[i] <<endl;  
    return 0;  
}

此build构造成的树如图：

这里写图片描述

(2)：区间查询int query(int node, int begin, int end, int left, int right);
（其中node为当前查询节点，begin,end为当前节点存储的区间，left,right为此次query所要查询的区间）
主要思想是把所要查询的区间[a,b]划分为线段树上的节点，然后将这些节点代表的区间合并起来得到所需信息
比如前面一个图中所示的树，如果询问区间是[0,2]，或者询问的区间是[3,3]，不难直接找到对应的节点回答这一问题。但并不是所有的提问都这么容易

int query(int node, int begin, int end, int left, int right)    
{   
    int p1, p2;    

    /*  查询区间和要求的区间没有交集  */  
    if (left > end || right < begin)    
        return -1;    

    /*  if the current interval is included in  */    
    /*  the query interval return segTree[node]  */  
    if (begin >= left && end <= right)    
        return segTree[node];    

    /*  compute the minimum position in the  */  
    /*  left and right part of the interval  */   
    p1 = query(2 * node, begin, (begin + end) / 2, left, right);   
    p2 = query(2 * node + 1, (begin + end) / 2 + 1, end, left, right);    

    /*  return the expect value  */   
    if (p1 == -1)    
        return p2;    
    if (p2 == -1)    
        return p1;    
    if (p1 <= p2)    
        return  p1;    
    return  p2;      
}

可见，这样的过程一定选出了尽量少的区间，它们相连后正好涵盖了整个[left,right]，没有重复也没有遗漏。同时，考虑到线段树上每层的节点最多会被选取2个，一共选取的节点数也是O(log n)的，因此查询的时间复杂度也是O(log n)。
线段树并不适合所有区间查询情况，它的使用条件是“相邻的区间的信息可以被合并成两个区间的并区间的信息”。即问题是可以被分解解决的。

(3)：区间或节点的更新 及 线段树的动态维护update （这是线段树核心价值所在，节点中的标记域可以解决N多种问题）
动态维护需要用到标记域，延迟标记等。
a:单节点更新

void Updata(int node, int begin, int end, int ind, int add)/*单节点更新*/    
{    

    if( begin == end )    
    {    
        segTree[node] += add;    
        return ;    
    }    
    int m = ( left + right ) >> 1;    
    if(ind <= m)    
        Updata(node * 2,left, m, ind, add);    
    else    
        Updata(node * 2 + 1, m + 1, right, ind, add);    
    /*回溯更新父节点*/    
    segTree[node] = min(segTree[node * 2], segTree[node * 2 + 1]);     

}

b：区间更新（线段树中最有用的）
需要用到延迟标记，每个结点新增加一个标记，记录这个结点是否被进行了某种修改操作(这种修改操作会影响其子结点)。对于任意区间的修改，我们先按照查询的方式将其划分成线段树中的结点，然后修改这些结点的信息，并给这些结点标上代表这种修改操作的标记。在修改和查询的时候，如果我们到了一个结点p，并且决定考虑其子结点，那么我们就要看看结点p有没有标记，如果有，就要按照标记修改其子结点的信息，并且给子结点都标上相同的标记，同时消掉p的标记。（优点在于，不用将区间内的所有值都暴力更新，大大提高效率，因此区间更新是最优用的操作）

void Change(node *p, int a, int b) /* 当前考察结点为p，修改区间为(a,b]*/  

{  

  if (a <= p->Left && p->Right <= b)  

  /* 如果当前结点的区间包含在修改区间内*/  

  {  

     ...... /* 修改当前结点的信息，并标上标记*/  

     return;  

  }  

  Push_Down(p); /* 把当前结点的标记向下传递*/  

  int mid = (p->Left + p->Right) / 2; /* 计算左右子结点的分隔点 

  if (a < mid) Change(p->Lch, a, b); /* 和左孩子有交集，考察左子结点*/  

  if (b > mid) Change(p->Rch, a, b); /* 和右孩子有交集，考察右子结点*/  

  Update(p); /* 维护当前结点的信息（因为其子结点的信息可能有更改）*/  

}

3:主要应用
(1)：区间最值查询问题 （见模板1）
(2)：连续区间修改或者单节点更新的动态查询问题 （见模板2）
(3)：多维空间的动态查询 （见模板3）

二：典型模板

模板1：
RMQ，查询区间最值下标—min

#include<iostream>    

using namespace std;    

#define MAXN 100    
#define MAXIND 256 //线段树节点个数    

//构建线段树,目的:得到M数组.    
void build(int node, int b, int e, int M[], int A[])    
{    
    if (b == e)    
        M[node] = b; //只有一个元素,只有一个下标    
    else    
    {     
        build(2 * node, b, (b + e) / 2, M, A);    
        build(2 * node + 1, (b + e) / 2 + 1, e, M, A);    

        if (A[M[2 * node]] <= A[M[2 * node + 1]])    
            M[node] = M[2 * node];    
        else    
            M[node] = M[2 * node + 1];    
    }    
}    

//找出区间 [i, j] 上的最小值的索引    
int query(int node, int b, int e, int M[], int A[], int i, int j)    
{    
    int p1, p2;    

    //查询区间和要求的区间没有交集    
    if (i > e || j < b)    
        return -1;    

    if (b >= i && e <= j)    
        return M[node];    

    p1 = query(2 * node, b, (b + e) / 2, M, A, i, j);    
    p2 = query(2 * node + 1, (b + e) / 2 + 1, e, M, A, i, j);    

    //return the position where the overall    
    //minimum is    
    if (p1 == -1)    
        return M[node] = p2;    
    if (p2 == -1)    
        return M[node] = p1;    
    if (A[p1] <= A[p2])    
        return M[node] = p1;    
    return M[node] = p2;    

}    


int main()    
{    
    int M[MAXIND]; //下标1起才有意义,否则不是二叉树,保存下标编号节点对应区间最小值的下标.    
    memset(M,-1,sizeof(M));    
    int a[]={3,4,5,7,2,1,0,3,4,5};    
    build(1, 0, sizeof(a)/sizeof(a[0])-1, M, a);    
    cout<<query(1, 0, sizeof(a)/sizeof(a[0])-1, M, a, 0, 5)<<endl;    
    return 0;    
}

模板2：
连续区间修改或者单节点更新的动态查询问题 （此模板查询区间和）

#include <cstdio>    
#include <algorithm>    
using namespace std;    

#define lson l , m , rt << 1    
#define rson m + 1 , r , rt << 1 | 1   
#define root 1 , N , 1   
#define LL long long    
const int maxn = 111111;    
LL add[maxn<<2];    
LL sum[maxn<<2];    
void PushUp(int rt) {    
    sum[rt] = sum[rt<<1] + sum[rt<<1|1];    
}    
void PushDown(int rt,int m) {    
    if (add[rt]) {    
        add[rt<<1] += add[rt];    
        add[rt<<1|1] += add[rt];    
        sum[rt<<1] += add[rt] * (m - (m >> 1));    
        sum[rt<<1|1] += add[rt] * (m >> 1);    
        add[rt] = 0;    
    }    
}    
void build(int l,int r,int rt) {    
    add[rt] = 0;    
    if (l == r) {    
        scanf("%lld",&sum[rt]);    
        return ;    
    }    
    int m = (l + r) >> 1;    
    build(lson);    
    build(rson);    
    PushUp(rt);    
}    
void update(int L,int R,int c,int l,int r,int rt) {    
    if (L <= l && r <= R) {    
        add[rt] += c;    
        sum[rt] += (LL)c * (r - l + 1);    
        return ;    
    }    
    PushDown(rt , r - l + 1);    
    int m = (l + r) >> 1;    
    if (L <= m) update(L , R , c , lson);    
    if (m < R) update(L , R , c , rson);    
    PushUp(rt);    
}    
LL query(int L,int R,int l,int r,int rt) {    
    if (L <= l && r <= R) {    
        return sum[rt];    
    }    
    PushDown(rt , r - l + 1);    
    int m = (l + r) >> 1;    
    LL ret = 0;    
    if (L <= m) ret += query(L , R , lson);    
    if (m < R) ret += query(L , R , rson);    
    return ret;    
}    
int main() {    
    int N , Q;    
    scanf("%d%d",&N,&Q);    
    build(root);    
    while (Q --) {    
        char op[2];    
        int a , b , c;    
        scanf("%s",op);    
        if (op[0] == 'Q') {    
            scanf("%d%d",&a,&b);    
            printf("%lld\n",query(a , b ,root));    
        } else {    
            scanf("%d%d%d",&a,&b,&c);    
            update(a , b , c , root);    
        }    
    }    
    return 0;    
}

模板3：
多维空间的动态查询

三：练习题目

下面是hh线段树代码，典型练习哇~
在代码前先介绍一些我的线段树风格:

maxn是题目给的最大区间,而节点数要开4倍,确切的来说节点数要开大于maxn的最小2x的两倍
lson和rson分辨表示结点的左儿子和右儿子,由于每次传参数的时候都固定是这几个变量,所以可以用预定于比较方便的表示
以前的写法是另外开两个个数组记录每个结点所表示的区间,其实这个区间不必保存,一边算一边传下去就行,只需要写函数的时候多两个参数,结合lson和rson的预定义可以很方便
PushUP(int rt)是把当前结点的信息更新到父结点
PushDown(int rt)是把当前结点的信息更新给儿子结点
rt表示当前子树的根(root),也就是当前所在的结点
整理这些题目后我觉得线段树的题目整体上可以分成以下四个部分:

单点更新:最最基础的线段树,只更新叶子节点,然后把信息用PushUP(int r)这个函数更新上来

hdu1166 敌兵布阵
题意:O(-1)
思路:O(-1)
线段树功能:update:单点增减 query:区间求和

#include<cstring>  
#include<iostream>  

#define M 50005  
#define lson l,m,rt<<1  
#define rson m+1,r,rt<<1|1  
/*left,right,root,middle*/  

int sum[M<<2];  

inline void PushPlus(int rt)  
{  
    sum[rt] = sum[rt<<1] + sum[rt<<1|1];  
}  

void Build(int l, int r, int rt)  
{  
    if(l == r)  
    {  
        scanf("%d", &sum[rt]);  
        return ;  
    }  
    int m = ( l + r )>>1;  

    Build(lson);  
    Build(rson);  
    PushPlus(rt);  
}  

void Updata(int p, int add, int l, int r, int rt)  
{  

    if( l == r )  
    {  
        sum[rt] += add;  
        return ;  
    }  
    int m = ( l + r ) >> 1;  
    if(p <= m)  
        Updata(p, add, lson);  
    else  
        Updata(p, add, rson);  

    PushPlus(rt);  
}  

int Query(int L,int R,int l,int r,int rt)  
{  
    if( L <= l && r <= R )  
    {  
        return sum[rt];  
    }  
    int m = ( l + r ) >> 1;  
    int ans=0;  
    if(L<=m )  
        ans+=Query(L,R,lson);  
    if(R>m)  
        ans+=Query(L,R,rson);  

    return ans;  
}  
int main()  
{     
    int T, n, a, b;  
    scanf("%d",&T);  
    for( int i = 1; i <= T; ++i )  
    {  
        printf("Case %d:\n",i);  
        scanf("%d",&n);  
        Build(1,n,1);  

        char op[10];  

        while( scanf("%s",op) &&op[0]!='E' )  
        {  

            scanf("%d %d", &a, &b);  
            if(op[0] == 'Q')  
                printf("%d\n",Query(a,b,1,n,1));  
            else if(op[0] == 'S')  
                Updata(a,-b,1,n,1);  
            else  
                Updata(a,b,1,n,1);  

        }  
    }  
    return 0;  
}

hdu1754 I Hate It
题意:O(-1)
思路:O(-1)
线段树功能:update:单点替换 query:区间最值

#include <cstdio>  
#include <algorithm>  
using namespace std;  

#define lson l , m , rt << 1  
#define rson m + 1 , r , rt << 1 | 1  
const int maxn = 222222;  
int MAX[maxn<<2];  
void PushUP(int rt) {  
    MAX[rt] = max(MAX[rt<<1] , MAX[rt<<1|1]);  
}  
void build(int l,int r,int rt) {  
    if (l == r) {  
        scanf("%d",&MAX[rt]);  
        return ;  
    }  
    int m = (l + r) >> 1;  
    build(lson);  
    build(rson);  
    PushUP(rt);  
}  
void update(int p,int sc,int l,int r,int rt) {  
    if (l == r) {  
        MAX[rt] = sc;  
        return ;  
    }  
    int m = (l + r) >> 1;  
    if (p <= m) update(p , sc , lson);  
    else update(p , sc , rson);  
    PushUP(rt);  
}  
int query(int L,int R,int l,int r,int rt) {  
    if (L <= l && r <= R) {  
        return MAX[rt];  
    }  
    int m = (l + r) >> 1;  
    int ret = 0;  
    if (L <= m) ret = max(ret , query(L , R , lson));  
    if (R > m) ret = max(ret , query(L , R , rson));  
    return ret;  
}  
int main() {  
    int n , m;  
    while (~scanf("%d%d",&n,&m)) {  
        build(1 , n , 1);  
        while (m --) {  
            char op[2];  
            int a , b;  
            scanf("%s%d%d",op,&a,&b);  
            if (op[0] == 'Q') printf("%d\n",query(a , b , 1 , n , 1));  
            else update(a , b , 1 , n , 1);  
        }  
    }  
    return 0;  
}

[hdu1394 Minimum Inversion Number](http://acm.hdu.edu.cn/showproblem.php?pid=1394
题意:求Inversion后的最小逆序数
思路:用O(nlogn)复杂度求出最初逆序数后,就可以用O(1)的复杂度分别递推出其他解
线段树功能:update:单点增减 query:区间求和

#include <cstdio>  
#include <algorithm>  
using namespace std;  

#define lson l , m , rt << 1  
#define rson m + 1 , r , rt << 1 | 1  
const int maxn = 5555;  
int sum[maxn<<2];  
void PushUP(int rt) {  
    sum[rt] = sum[rt<<1] + sum[rt<<1|1];  
}  
void build(int l,int r,int rt) {  
    sum[rt] = 0;  
    if (l == r) return ;  
    int m = (l + r) >> 1;  
    build(lson);  
    build(rson);  
}  
void update(int p,int l,int r,int rt) {  
    if (l == r) {  
        sum[rt] ++;  
        return ;  
    }  
    int m = (l + r) >> 1;  
    if (p <= m) update(p , lson);  
    else update(p , rson);  
    PushUP(rt);  
}  
int query(int L,int R,int l,int r,int rt) {  
    if (L <= l && r <= R) {  
        return sum[rt];  
    }  
    int m = (l + r) >> 1;  
    int ret = 0;  
    if (L <= m) ret += query(L , R , lson);  
    if (R > m) ret += query(L , R , rson);  
    return ret;  
}  
int x[maxn];  
int main() {  
    int n;  
    while (~scanf("%d",&n)) {  
        build(0 , n - 1 , 1);  
        int sum = 0;  
        for (int i = 0 ; i < n ; i ++) {  
            scanf("%d",&x[i]);  
            sum += query(x[i] , n - 1 , 0 , n - 1 , 1);  
            update(x[i] , 0 , n - 1 , 1);  
        }  
        int ret = sum;  
        for (int i = 0 ; i < n ; i ++) {  
            sum += n - x[i] - x[i] - 1;  
            ret = min(ret , sum);  
        }  
        printf("%d\n",ret);  
    }  
    return 0;  
}

hdu2795 Billboard
题意:h*w的木板,放进一些1*L的物品,求每次放空间能容纳且最上边的位子
思路:每次找到最大值的位子,然后减去L
线段树功能:query:区间求最大值的位子(直接把update的操作在query里做了)

#include <cstdio>  
#include <algorithm>  
using namespace std;  

#define lson l , m , rt << 1  
#define rson m + 1 , r , rt << 1 | 1  
const int maxn = 222222;  
int h , w , n;  
int MAX[maxn<<2];  
void PushUP(int rt) {  
    MAX[rt] = max(MAX[rt<<1] , MAX[rt<<1|1]);  
}  
void build(int l,int r,int rt) {  
    MAX[rt] = w;  
    if (l == r) return ;  
    int m = (l + r) >> 1;  
    build(lson);  
    build(rson);  
}  
int query(int x,int l,int r,int rt) {  
    if (l == r) {  
        MAX[rt] -= x;  
        return l;  
    }  
    int m = (l + r) >> 1;  
    int ret = (MAX[rt<<1] >= x) ? query(x , lson) : query(x , rson);  
    PushUP(rt);  
    return ret;  
}  
int main() {  
    while (~scanf("%d%d%d",&h,&w,&n)) {  
        if (h > n) h = n;  
        build(1 , h , 1);  
        while (n --) {  
            int x;  
            scanf("%d",&x);  
            if (MAX[1] < x) puts("-1");  
            else printf("%d\n",query(x , 1 , h , 1));  
        }  
    }  
    return 0;  
}
_Roy_Cheng
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【算法】线段树详解
_Alexander_的博客
08-20 5万+
线段树，是一种二叉搜索树。它功能强大，支持区间求和，区间最大值，区间修改，单点修改等操作。 它的时间复杂度是O(nlogn)的。 十分良心，欢迎阅读！
线段树建树
12-14
线段树是一种二叉树，也就是说，每个线段都可以用一二叉树表示 比如一个长度为4的线段可以如此表示： ——————————————-4 1————-2————-3————4 1 2 3 4 如果你要表示线段上的和，最上面的根...
线段树详解
orz
05-20 9941
1. 什么是线段树 顾名思义 ， 线段树是一棵二叉树 ， 但不同的是这棵树的结点储存的值是一个数列中 [l,r][l,r][l,r] 的某个需要的值 （例如，求和，求最大值，求最小值） 这是一棵典型的线段树 ，其性质是 ： 若其中一子节点编号为 aaa ， 则该节点左儿子编号为 2a2a2a ， 其右儿子编号为 2a+12a+12a+1 2. 线段树的用处 线段树的用处就是，对编号连续的一些点进行修改或者统计操作，修改和统计的复杂度都是 O(log2n)O(log_2 n)O(log2​n). 3.
线段树 从入门到进阶（超清晰，简单易懂）
热门推荐
繁凡さん的博客
02-12 8万+
目录第一部 概念引入第二部 简单（无pushdown）的线段树1、单点修改，区间查询2、区间修改，单点查询第三部 进阶线段树第四部 乘法（根号）线段树1、乘法线段树2、根号线段树模板题与代码：单点修改，区间查询：洛谷树状数组模板1区间修改，单点查询：洛谷树状数组模板2区间加法，洛谷线段树模板1区间乘法：洛谷线段树模板2区间根号，bzoj3211 线段树是什么？？线段树怎么写？？ 如果你在考提高组前...
什么是线段树
ThinPikachu的博客
04-04 1718
线段树的概念 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。 线段树的应用 线段树 segmentTree 是一个二叉树，每个结点保存数组 nums 在区间 [left, right] 的最...
李超线段树
fzyyyyyyyy的博客
09-22 861
李超线段树是巨佬李超发明的一种，又名李超树。代码简短，思想简明，用途广泛。
线段树练习题集
UncleJokerly
04-28 2271
线段树题目整合 1.hdu1166 敌兵布阵 更新节点,区间求和。 2.hdu1754 I Hate It 更新节点,区间最值. .3.hdu1698 Just a Hook 成段更新,总区间求和. .4.hdu1394 Minimum Inversion Number 更新节点,区间求和 .5.hdu1779（这个爆炸了，别做了） 成段更新,区间最值 .6.pku...
线段树模板
听取WA声一片
10-28 2062
线段树 打标记
线段树解题报告
01-03
H Moving Points 题目链接：...思路：树状数组维护，类似于树状数组求逆序对+思维（思维量很小） #include using namespace std; const int N = 2e5+9; typedef long long ll; struct node{ ...ll c1[N
C语言线段树讲解
06-15
线段树是一种数据结构，主要用于高效地处理一系列区间或线段上的操作，如查询、更新等。在C语言中，线段树同样可以被用来实现这些功能。下面将详细解释线段树的基本概念、结构以及常见操作。 1. **线段树的定义**：...
线段树Java实现-SegmentTree
最新发布
05-01
### 线段树Java实现-SegmentTree #### 概述 线段树是一种非常高效的数据结构，主要用于处理区间查询和区间更新问题。在本文档中，我们将详细探讨线段树的基本概念、Java实现以及一个具体的例子：区间求和。 #### ...
线段树讲义PPT
12-05
线段树，类似区间树，它在各个节点保存一条线段（数组中的一段子数组），主要用于高效解决连续区间的动态查询问题，由于二叉结构的特性，它基本能保持每个操作的复杂度为O(logn)。
线段树入门
05-03
线段树是一种高效的数据结构，用于处理和维护在一维空间中的一系列区间或线段，同时支持动态查询和修改操作。它特别适用于那些需要快速查询区间信息，如求区间和、查找区间内满足条件的元素个数等问题。线段树的核心...
线段树_线段树_
10-01
线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的...
细讲线段树
12-04
这PPT讲了线段树的结构、性质、存储、修改、查询操作，适合新手看。
线段树代码
09-11
线段树代码 线段树是一种数据结构，它通常用于解决区间查询和修改的问题。在竞赛中，线段树经常作为一种高效的解决方案，用于解决一些复杂的问题。 线段树的基本结构是一个二叉树，每个节点都存储了一个区间的信息...
线段树详解与应用
"线段树基础" 线段树是一种数据结构，主要用于处理区间或段上的数据查询和更新操作，常用于解决动态区间统计问题。它是由二叉树结构实现的，每个节点代表一个特定的区间，而这个区间在树的不同层级被不断细分。线段...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值