线段树 （成段更新）

最新推荐文章于 2020-02-22 10:08:12 发布
最新推荐文章于 2020-02-22 10:08:12 发布
阅读量622 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013466936/article/details/23858397
版权

 hdu1698

 lazy-tag(lazy标记)进行区间修改:

  为了减小修改次数，先将要进行的修改存起来，当访问到子节点的时候，如果发现父节点带有标记，就顺便将子节点更新，就像搭顺风车一样。在这道题中，每次可能要将一个区间更改为一个值，比如全集为[1,7],现在要对区间[1,4]进行操作，例如要将[1,4]更改为1，如果采用单点更新，那么就要访问到叶节点一个一个第更新。实际上，当我们从[1,7]访问到它的左儿子[1,4]的时候，由于此时[1,4]恰好已经覆盖了要更新的区间，于是就将[1,4].sum = 1 * （4 - 1 + 1）,当下次需要访问[1,4]的子节点时，发现[1,4]带有标记，就在访问[1,4]的子节点的时候顺便将以前记下的1操作，对[1,4]的子节点进行实施，同时将[1,4]的子节点带上标记。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>

using namespace std;

#define lson l,mid,x<<1
#define rson mid+1,r,x<<1|1
const int MAX = 444444;

struct node
{
    int vis;//标记当前节点是否被更新
    int sum;//当前区间的总价值
}a[MAX];

void Pushup(int x)
{
    a[x].sum = a[x<<1].sum + a[x<<1|1].sum;
}

void build(int l,int r,int x)
{
    a[x].vis = 0;//初始化时所有的节点都未被更新
    a[x].sum = 1;
    if(l==r)return ;
    int mid = (l+r)>>1;
    build(lson);
    build(rson);
    Pushup(x);
}

void Pushdown(int x,int m)//对当前节点的子节点进行更新
{
    if(a[x].vis!=0)
    {
        a[x<<1].vis = a[x<<1|1].vis = a[x].vis;
        a[x<<1].sum = (m - (m>>1)) * a[x].vis;
        a[x<<1|1].sum = (m>>1) * a[x].vis;
        a[x].vis = 0;
    }
}

void update(int A,int B,int C,int l,int r,int x)//对线段树进行更新
{
    if(A<=l && B>=r)//如果覆盖整个区间则将整段区间的值修改为C，区间价值即为C*（r - l + 1）
    {
        a[x].vis = C;
        a[x].sum = C * (r - l + 1);
        return ;
    }
    Pushdown(x,r - l + 1);//更新儿子节点
    int mid = (l + r)>>1;
    if(A<=mid) update(A,B,C,lson);//有覆盖到左儿子
    if(B > mid) update(A,B,C,rson);//有覆盖到右儿子
    Pushup(x);
}

int main()
{
    int t,n,m,x,y,z,temp = 1;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        build(1,n,1);
        scanf("%d",&m);
        while(m--)
        {
            scanf("%d%d%d",&x,&y,&z);
            update(x,y,z,1,n,1);
        }
        cout<<"Case "<<temp++<<": The total value of the hook is "<<a[1].sum<<"."<<endl;
    }
    return 0;
}

poj 3468

  题意：给一些数，有两种操作。一种是某个区间都增加一个数，另一种是查询某段区间的和。

  思路：在这道题中，每次可能要将一个区间更改为一个值，

       比如全集为[1,7],现在要对区间[1,4]进行操作，

       例如要将[1,4]之间的值都加上1，如果采用单点更新，

       那么就要访问到叶节点一个一个第更新。

       实际上，当我们从[1,7]访问到它的左儿子[1,4]的时候，

       由于此时[1,4]恰好已经覆盖了要更新的区间，

       于是就将[1,4].sum = 1 * （4 - 1 + 1），并将[1,4].vis += 1，

       当下次需要访问[1,4]的子节点时，发现[1,4]带有标记，

       就在访问[1,4]的子节点的时候顺便将以前记下的vis操作，

       对[1,4]的子节点进行实施，同时将[1,4]的子节点带上标记。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>

using namespace std;

#define lson l,mid,x<<1
#define rson mid+1,r,x<<1|1
#define LL long long
const LL MAX = 444444;

struct node
{
    LL vis;//标记是否进行过修改
    LL sum;//当前区间的和
}a[MAX];

void Pushup(LL x)
{
    a[x].sum = a[x<<1].sum + a[x<<1|1].sum;
}

void Pushdown(LL x,LL m)//更新当前节点并修改左右子节点
{
    if(a[x].vis)
    {
        a[x<<1].vis += a[x].vis;
        a[x<<1|1].vis += a[x].vis;//这里注意要用“+=”，因为有可能进行过多次修改，如果没累加的话，记录的只是访问之前的最后一次修改
        a[x<<1].sum += (m - (m>>1)) * a[x].vis;
        a[x<<1|1].sum += (m>>1) * a[x].vis;
        a[x].vis = 0;
    }
}

void build(LL l,LL r,LL x)
{
    a[x].vis = 0;
    a[x].sum = 0;
    if(l==r) return ;
    LL mid = (l+r)>>1;
    build(lson);
    build(rson);
}

void update(LL A,LL B,LL C,LL l,LL r,LL x)//对区间【A，B】进行更新
{
    if(A<=l && B>=r)//完全覆盖区间【r，l】，返回区间的和即可
    {
        a[x].sum += (r - l + 1) * C;
        a[x].vis += C;
        return ;
    }
    Pushdown(x,r - l +1);//需要对节点x进行操作，所以要先修改x节点
    LL mid = (l + r)>>1;
    if(A<=mid) update(A,B,C,lson);//有覆盖到左区间
    if(B > mid) update(A,B,C,rson);//有覆盖到右区间
    Pushup(x);
}

LL query(LL A,LL B,LL l,LL r,LL x)//查找区间【A，B】的和
{
    if(A<=l && B>=r) return a[x].sum;
    Pushdown(x,r - l + 1);
    LL mid = (l + r)>>1;
    LL ret = 0;
    if(A<=mid) ret += query(A,B,lson);
    if(B > mid) ret += query(A,B,rson);
    return ret;
}

int main()
{
    LL n,q,i,k;
    while(~scanf("%lld%lld",&n,&q))
    {
        build(1,n,1);
        for(i = 1; i <= n; i++)
        {
            scanf("%lld",&k);
            update(i,i,k,1,n,1);
        }
        char ch;
        LL A,B,C;
        while(q--)
        {
            getchar();
            scanf("%c",&ch);
            if(ch=='Q')
            {
                scanf("%lld%lld",&A,&B);
                printf("%lld\n",query(A,B,1,n,1));
            }
            else if(ch=='C')
            {
                scanf("%lld%lld%lld",&A,&B,&C);
                update(A,B,C,1,n,1);
            }
        }
    }
    return 0;
}

poj 2528

  题意:在墙上贴海报,海报可以互相覆盖,问最后可以看见几张海报

      （这题数据范围很大,直接搞超时+超内存,需要离散化:

      离散化简单的来说就是只取我们需要的值来用,

      比如说区间[1000,2000],[1990,2012]

      我们用不到[-∞,999][1001,1989][1991,1999][2001,2011][2013,+∞]这些值,

      所以我只需要1000,1990,2000,2012就够了,

      将其分别映射到0,1,2,3,这样复杂度就大大的降下来了

      所以离散化要保存所有需要用到的值,

      排序后,分别映射到1~n,这样复杂度就会小很多很多）

  思路:用到线段树，因为最多有10^6，

      建那么大的树肯定会爆空间和时间，

      所以想到要离散化，将每条线段的两端，

      就是海报的两头分开考虑，所有的端点放在一起非递减排序，

      去掉相同的，计算出有n个不同的点，编号从1到n，——这是离散化过程。

      然后建二叉树。更新的时候先二分查找那条线段两端的点的编号，

      然后在那棵建好的树上更新，遇到一样的节点就覆盖，

      如果线段在那个节点的子节点上，而且这个节点又被其他线段覆盖过，

      那么就要更新它的子节点，他自己改成不被覆盖的。

      最后计算结果那里要用个辅助数组，从根节点开始找被覆盖的节点，

       分别将不同的值放在数组里，最后看有几个结果就是几个。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>

using namespace std;

#define lson l,mid,x<<1
#define rson mid+1,r,x<<1|1

const int MAX = 11111;
int a[MAX<<4];
int ans;
bool hash[MAX<<4];

struct node1
{
    int l,r;
}m[MAX];

void Pushdown(int x)
{
    if(a[x]!=-1)//如果当前节点已被覆盖，则更新他的左右儿子节点，并将该节点改为没被覆盖
    {
        a[x<<1] = a[x];
        a[x<<1|1] = a[x];
        a[x] = -1;
    }
}

void Update(int A,int B,int C,int l,int r,int x)
{
    if(A<=l && B>=r)
    {
        a[x] = C;
        return ;
    }
    Pushdown(x);
    int mid = (l + r)>>1;
    if(A<=mid) Update(A,B,C,lson);
    if(B > mid) Update(A,B,C,rson);
}

void query(int l,int r,int x)
{
    if(a[x]!=-1)
    {
        if(!hash[a[x]]) ans++;
        hash[a[x]] = true;
        return ;
    }
    if(l==r)return ;
    int mid = (l + r)>>1;
    query(lson);
    query(rson);
}

int bin(int key,int n,int ma[])//离散化，用二分查找
{
    int l = 0;
    int r = n-1;
    while(l<=r)
    {
        int mid = (l + r)>>1;
        if(ma[mid]==key) return mid;
        if(ma[mid] < key) l = mid + 1;
        else r = mid - 1;
    }
    return -1;
}

int main()
{
    int t,n,i;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        int ma[MAX<<1];
        int nu = 0;
        for(i = 0; i < n; i++)
        {
            scanf("%d%d",&m[i].l,&m[i].r);
            ma[nu++] = m[i].l;
            ma[nu++] = m[i].r;
        }
        sort(ma,ma+nu);
        int nu1 = 1;
        for(i = 1; i < nu; i++)//去除重复的数
        if(ma[i]!=ma[i-1]) ma[nu1++] = ma[i];
        memset(a,-1,sizeof(a));
        for(i = 0; i < n; i++)
        {
            int l = bin(m[i].l,nu1,ma);
            int r = bin(m[i].r,nu1,ma);//l和r是离散化后所对应的值
            Update(l,r,i,0,nu1-1,1);//更新区间【l,r】
        }
        ans = 0;
        memset(hash,false,sizeof(hash));
        query(0,nu1-1,1);
        printf("%d\n",ans);
    }
    return 0;
}

poj 3225

  题意：定义对集合的交、并、差、异或，求空集经过一系列操作后的结果。

  题解：将原点集每一个点乘以2，形成一个新的点集，

       其中偶数点都对应着原来的点，

       奇数点对应着不包括它左右两个点的开区间，

       即2k+1==>（k,k+1），

       于是区间上所有点都能用整点表示，

       线段树可求解，对于每一个操作区间，

       无论开闭，都对应这线段树上的一段线段。

  1、并运算[a,b]，就是将[a,b]赋值为1.（a,b均为对应之后的点）

  2、交运算[a,b]，将除了[a,b]区间以外的线段清0.

  3、S-[a,b]，将[a,b]区间清0.

  4、[a,b]-S,将[a,b]区间以外线段清0，并且将[a,b]线段所代表区域取反.

  5、异或运算，上面两者去并，就是将[a,b]区域取反.

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>

using namespace std;

#define lson l,mid,x<<1
#define rson mid+1,r,x<<1|1

const int MAX = 222222;
bool hash[MAX];

struct node
{
    int Xor,cover;//用0和1表示是否包含区间,-1表示该区间内既有包含又有不包含
}a[MAX<<2];

void FXor(int x)
{
    if(a[x].cover!=-1)
    a[x].cover ^= 1;
    else a[x].Xor ^= 1;
}
/*成段覆盖的操作很简单,比较特殊的就是区间0/1互换这个操作,
  我们可以称之为异或操作。
  很明显我们可以知道这个性质:
      当一个区间被覆盖后,不管之前有没有异或标记都没有意义了。
  所以当一个节点得到覆盖标记时把异或标记清空，
  而当一个节点得到异或标记的时候,
  先判断覆盖标记,如果是0或1,
  直接改变一下覆盖标记,不然的话改变异或标记
*/
void Pushdown(int x)
{
    if(a[x].cover!=-1)//有覆盖标记
    {
        a[x<<1].cover = a[x<<1|1].cover = a[x].cover;
        a[x<<1].Xor = a[x<<1|1].Xor = 0;//清空标记
        a[x].cover = -1;
    }
    if(a[x].Xor)//有异或标记
    {
        FXor(x<<1);
        FXor(x<<1|1);
        a[x].Xor = 0;
    }
}

void Update(char ch,int A,int B,int l,int r,int x)
{
    if(A<=l && B>=r)
    {
        if(ch=='U')
        {
            a[x].cover = 1;
            a[x].Xor = 0;
        }
        else if(ch=='D')
        {
            a[x].cover = 0;
            a[x].Xor = 0;
        }
        else if(ch=='C' || ch=='S')
        {
            FXor(x);
        }
        return ;
    }
    Pushdown(x);
    int mid = (l + r)>>1;
    if(A<=mid) Update(ch,A,B,lson);
    else
    {
        if(ch=='I' || ch=='C')
        {
            a[x<<1].cover = a[x<<1].Xor = 0;
        }
    }
    if(B > mid) Update(ch,A,B,rson);
    else
    {
        if(ch=='I' || ch=='C')
        {
            a[x<<1|1].cover = a[x<<1|1].Xor = 0;
        }
    }
}

void query(int l,int r,int x)
{
    if(a[x].cover==1)
    {
        for(int i = l; i <= r; i++)
        hash[i] = true;
        return ;
    }
    else if(a[x].cover==0)return ;
    Pushdown(x);
    int mid = (l + r)>>1;
    query(lson);
    query(rson);
}

int main()
{
    a[1].cover = a[1].Xor = 0;
    char ch,l,r;
    int A,B;
    while(~scanf("%c %c%d,%d%c\n",&ch,&l,&A,&B,&r))
    {
        /*离散化处理 
          线段树经常碰见的离散化问题。
          对于这种经典的，要把常规思维中的点变成线的问题，
          办法，就是将每个点倍增，这意味着，例如我们存储了{ 1, 2, 3, 4, 5}
          代表了我们拥有的是(0,3)，分开来讲，就是
          (0, 1)、1、(1, 2)、2、(2, 3)。
        */
        A<<=1;
        B<<=1;
        if(l=='(')A++;
        if(r==')')B--;
        /*还有一点需要注意，输入中的区间(a, b)，由于a <= b，
          可能出现类似(2, 2)这样的区间，应看成空。
        */
        if(A > B)
        {
            if(ch=='I' || ch=='C')
            a[1].cover = a[1].Xor = 0;
        }
        else Update(ch,A,B,0,MAX,1);
    }
    query(0,MAX,1);
    bool flag = false;
    int e,s = -1;
    for(int i = 0; i <= MAX; i++)
    {
        if(hash[i]==1)
        {
            if(s==-1)
            s = i;
            e = i;
        }
        else
        {
            if(s!=-1)
            {
                if(flag) printf(" ");
                flag = true;
                if(s&1)
                printf("(");
                else printf("[");
                printf("%d,%d",s>>1,(e+1)>>1);
                if(e&1)
                printf(")");
                else printf("]");
                s = -1;
            }
        }
    }
    if(!flag) printf("empty set");
    puts("");
    return 0;
}


_hua_z
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树详解（单点更新与成段更新\区间更新操作）
超级菜鸟ZiP的小窝
07-06 9942
本文纯属原创，转载请注明出处，谢谢。 距离第一次接触线段树已经一年多了，再次参加ACM暑假集训，这一次轮到我们这些老家伙们给学弟学妹们讲解线段树了，所以就自己重新把自己做过的题目看了一遍，然后写篇博客纪念一下。 作为近年来算法竞赛里面最火爆的数据结构考点，它的用法和问法层出不穷。而作为解决反复对区间的更新和查询问题最好的数据结构，它拥有其他数据结构无法取代的地位。树状数组虽然也能解决很多问题，
线段树.pdf
12-05
线段树完全版，涉及到线段树的所有用法。 包括单点更新（增减，替换），区间求和，区间最值。 区间求最大值的位置。 成段更新（延迟标记，增减）。 离散化 扫描线
线段树（成段更新）
Peteriazhen的博客
09-11 232
1、提出背景：给你N个点，执行M次操作，每次操作让你把[X,Y]区间里的元素都加Z。 2、为什么要进行成段更新？ 答：如果不进行成段更新，那么在单点更新的基础上，我们是不是要把[X,Y]中的元素都进行单点更新，时间复杂度会相当的高！！！ 3、成段更新在单点更新的基础上会有什么不同呢？ 答：最大的不同在原来基础上增加了 lazy[ ]（延迟数组）进行标记。我的理解是，当我们要对某个区间进行更...
线段树成段更新操作及Lazy思想（POJ3468解题报告）
热门推荐
fmt.Println(
11-03 1万+
就直接那POJ上面的例题来说吧，http://poj.org/problem?id=3468。 此题题意很好懂：  给你N个数，Q个操作，操作有两种，‘Q a b ’是询问a~b这段数的和，‘C a b c’是把a~b这段数都加上c。 需要用到线段树的，update:成段增减，query:区间求和 介绍Lazy思想：lazy－tag思想，记录每一个线段树节点的变化值，当这部分线段的一致
线段树成段更新
liu20111590的专栏
10-03 464
hdu 1698 http://acm.hdu.edu.cn/showproblem.php?pid=1698 成段更新求和 #include #include #include using namespace std; #define MAX 100100 #define mid (l+r)>>1 #define lson l,m,rt<<1 #define rs
线段树 成段更新
Time is up , let's go .
10-22 457
线段树就是许多线段组成的，并对每条线段进行操作，线段树的节点满足二叉树，所以某个节点的左右儿子是 2*rt，和2*rt+1； 举例说明：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次 在[0,7]区间上建立一棵满二叉树：（为了和已知线段区别，用【】表示线段树中的线段）
统计的力量-线段树全接触-张昆玮
最新发布
05-10
线段树是一种高效的数据结构，特别适用于处理动态的区间查询和更新问题。它在计算机科学，尤其是算法竞赛和计算几何领域中有着广泛的应用。线段树通过将一维空间（通常是一组数值或数组）划分为多个重叠的区间来工作...
线段树函数
07-27
4. 重复此过程直至到达根节点，确保线段树完全反映了成段更新。 **查询操作** 线段树不仅支持更新操作，还支持查询操作。查询一个区间的信息时，从根节点开始，按照与更新类似的方式向下遍历，但这次是根据节点覆盖...
线段树应用示例程序
05-18
5. **应用实例**：线段树常用于解决竞赛编程中的问题，如统计一段区间内的特定信息、动态维护数组的前缀和、区间最值问题等。文章可能会给出一些实际题目，通过这些例子来解释线段树的运用。 6. **代码实现**：线段...
poj2823.cpp.tar.gz_线段树
09-20
线段树是一种数据结构，主要用于高效地处理区间（或段）上的查询与更新操作。在题目"poj2823"中，我们看到它被应用于寻找区域间的最大值和最小值。线段树通常用于解决动态规划问题，特别是在数组或序列上执行范围...
HDU 1698 线段树成段更新
Dan__ge的博客
03-16 1717
点击打开链接 题意：给你T组数据，每组N个数，初始为1，M个操作，每个操作将区间a到b的值更新为才，问n个数的和。 思路：简单的线段树成段更新，需要用到懒惰标记，说白了懒惰标记就是用到的时候再去更新它，不然就放在那里 #include #include #include #include #include using namespace std; const int inf=0x3
hdu 4325 线段树 成段更新
天逸南爵的专栏
08-02 819
题意：    给出花的开花时间st[i]与凋谢时间ed[i],要求在一个时间点上开了多少花！！（花 解法：   线段树区间更新+离散化+区间求值！！！以前都有结构体来解决这些问题，但感觉牛人的代码的确够简洁，所以就忍不住拿来学学，过不其然，怎一个爽字了得！/* 转自 傻崽大牛博客的一段话 离散化简单的来说就是只取我们需要的值来用,比如说区间[1000,2000],[1990,2012] 我们
HDU 1698 线段树的成段更新，懒人思想
Me1ody__的专栏
12-02 649
这里解释下懒人算法的功能，懒人算法用于线段树的成端更新，意思就是说，当我更新的时候，不需要全部更新到底，用一个延迟标记来让更新延迟到下一次我需要更新这里或者询问这个区间的的时候。 懒人的思想通俗的说就是，我要更新一个区间，那我不用像用单点更新来更新父亲节点这种方法一样，我可以先将这里更新，然后在这里留下一个lazy的标记，当下次再次经过这个区间的时候，我在把上次遗留的问题一起解决，这里要注意无论
Wikioi 1082线段树成段更新成段查询
liwei的专栏
05-08 999
这题从昨晚搞到现在敲了又改好久，刚开始是update中错了，然后找到了。但是还错，然后因为题目没有数据的范围提示，所以弄了好久都不知道哪错了，最后看评论才知道是超int了，改了之后还有错，然后才发现虽然改成long long了，但是输出的时候没改，哈哈…… #include #include #include #include #include #include #include
线段树（区间更新）
日月
06-06 650
#include &lt;iostream&gt; #include &lt;cstdio&gt; using namespace std; typedef long long ll; ll a[100005]; struct node { int l, r; ll sum, lazy; }tree[500005]; int n; void Updown(int rt) ...
线段树成段更新模板-杭电1556
dtwd886的博客
08-15 273
#include #include #include #define left L,m,rt<<1 #define right m+1,R,rt<<1|1 #define maxn 100050 int flag; int sum[maxn<<2]; void down(int rt) { if(sum[rt]) { sum[rt<<1]+=sum[rt]; sum[rt<<1|1]
线段树 点更新和段更新
人面桃花
03-01 947
线段树 标签： acm数据结构 2016-08-18 17:26 82人阅读 评论(0) 收藏 举报 分类： 数据结构（9）内容来自石万东学长课件~1.问题 给你一个数的序列A1A2……An。 并且可能多次进行下列两个操作 1、对序列里面的某个数进行加减 2、询问这个序列里面任意一个连续的子序列AiAi+1……Aj的和是多少。 希望第2个操作每次能在log(n)时间内完成2.
单点更新线段树
跳动的量子
02-02 533
线段树是一种强（傻）大（逼）的数据结构，但博主实在是无聊，只好默默的玩一下这种强（傻）大（逼）的数据结构（博主N年前就已经掌握了这种数据结构）。但博主为了共产（工厂）主义事业，终于写下了这个代码（为NOIPPJ的水题奋斗）。/************************************************************************* > File Nam
再识线段树之更新与查询
马克菠萝包ଲ的博客
02-22 97
1.更新操作： 原题目如图所示：给出一组数1,3,5,7,9,11，输出下标对应数字。 若将原数组中第五格的数字9更新替换为数字6，则需进行线段树之更新操作，更新后应如下图所示： 代码如下： void update_tree(int arr[],int tree[],int node,int start,int end,int idx,int val){ if(start==end){//设...
线段树数据结构详解
例如，在处理影子宽度的问题中，可以将线段看作盒子的边界，线段树的每个节点记录的是对应区间内线段的贡献，通过更新和查询线段树，可以快速计算出线段覆盖的总长度。 在最直接的解决影子宽度问题的方法中，使用一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值