线段树例题集合

最新推荐文章于 2022-10-31 20:43:32 发布
最新推荐文章于 2022-10-31 20:43:32 发布
阅读量272 收藏
点赞数
分类专栏： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/silver_bone/article/details/77938322
版权

1.hdu 1556
代码：

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define inf 0x3f3f3f3f 
#define met(a,b) memset(a,b,sizeof(a))
const int maxn = 1e5+10;
#define lchild rt << 1, l, m
#define rchild rt << 1 | 1, m + 1, r
int tree[maxn<<2],lazy[maxn<<2];
int N;

void push_down(int rt, int len) {
    tree[rt << 1] += lazy[rt] * (len - (len >> 1));
    lazy[rt << 1] += lazy[rt];
    tree[rt << 1 | 1] += lazy[rt] * (len >> 1);
    lazy[rt << 1 | 1] += lazy[rt];
    lazy[rt] = 0;
}

void update(int L, int R, int delta, int rt = 1, int l = 1, int r = N) {
    if (L <= l && r <= R) {
        tree[rt] += delta * (r - l + 1);
        lazy[rt] += delta;
        return;
    }
    if (lazy[rt]) push_down(rt, r - l + 1);
    int m = (l + r) >> 1;
    if (L <= m) update(L, R, delta, lchild);
    if (R > m)  update(L, R, delta, rchild);
}

int query(int L, int R, int rt = 1, int l = 1, int r = N) {
    if (L <= l && r <= R) return tree[rt];
    if (lazy[rt]) push_down(rt, r - l + 1);
    int m = (l + r) >> 1, ret = 0;
    if (L <= m) ret += query(L, R, lchild);
    if (R > m)  ret += query(L, R, rchild);
    return ret;
}

int main(){
    while(scanf("%d",&N)&&N!=0){
        met(tree,0), met(lazy,0);
        for(int i=1;i<=N;i++){
            int a,b; scanf("%d%d",&a,&b);
            update(a,b,1);
        }
        for(int i=1;i<=N;i++){
            printf("%d",query(i,i));
            if(i!=N) printf(" ");
        }
        printf("\n");
    }
}

2.hdu 1166
代码：

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define inf 0x3f3f3f3f 
#define met(a,b) memset(a,b,sizeof(a))
const int maxn = 5e5+10;
#define lchild rt << 1, l, m
#define rchild rt << 1 | 1, m + 1, r
int tree[maxn<<2],num[maxn];
int N;

void push_up(int rt) {
    tree[rt] = tree[rt << 1] + tree[rt << 1 | 1];
}

void build(int rt = 1, int l = 1, int r = N) {
    if (l == r) { tree[rt]=num[l]; return; }
    int m = (l + r) >> 1;
    build(lchild); build(rchild);
    push_up(rt);
}

void update1(int p, int delta, int rt = 1, int l = 1, int r = N) {
    if (l == r) {
        tree[rt] += delta;
        return;
    }
    int m = (l + r) >> 1;
    if (p <= m) update1(p, delta, lchild);
    else update1(p, delta, rchild);
    push_up(rt);
}

void update2(int p, int delta, int rt = 1, int l = 1, int r = N) {
    if (l == r) {
        tree[rt]-= delta;
        return;
    }
    int m = (l + r) >> 1;
    if (p <= m) update2(p, delta, lchild);
    else update2(p, delta, rchild);
    push_up(rt);
}

int query(int L, int R, int rt = 1, int l = 1, int r = N) {
    if (L <= l && r <= R) return tree[rt];
    int m = (l + r) >> 1, ret = 0;
    if (L <= m) ret += query(L, R, lchild);
    if (R > m)  ret += query(L, R, rchild);
    return ret;
}

int main(){
    int t;
    int id=1;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&N);
        for(int i=1;i<=N;i++) scanf("%d",&num[i]);
        build();
        printf("Case %d:\n",id++);
        char s[10];
        while(1){
            scanf("%s",s);
            if(strcmp(s,"End")==0) break;
            else if(strcmp(s,"Query")==0) {int x,y; cin>>x>>y; printf("%d\n",query(x,y));}
            else if(strcmp(s,"Add")==0) {int x,y; cin>>x>>y; update1(x,y);}
            else {int x,y; cin>>x>>y; update2(x,y);}
            }
        }
}

3.hdu 1754（单点更新＋区间最值）
代码：

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define met(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
#define lchild rt<<1,l,m
#define rchild rt<<1|1,m+1,r
const int maxn = 2e5+10;
int tree[maxn<<2];
int n,m;
void push_up(int rt)
{
    tree[rt]=max(tree[rt<<1],tree[rt<<1|1]);
}

void build(int rt=1,int l=1,int r=n)
{
    if(l==r)
    {
        scanf("%d",&tree[rt]);
        return;
    }
    int m=(l+r)>>1;
    build(lchild); build(rchild);
    push_up(rt);
}

void updata(int pos,int delta,int rt=1,int l=1,int r=n)
{
    if(l==r)
    {
        tree[rt]=delta;
        return;
    }
    int m=(l+r)>>1;
    if(pos<=m) updata(pos,delta,lchild);
    else updata(pos,delta,rchild);
    push_up(rt);
}

int query(int L,int R,int rt=1,int l=1,int r=n)
{
    if(L<=l&&R>=r) return tree[rt];
    int m=(l+r)>>1,ret=0;
    if(L<=m) ret=max(ret,query(L,R,lchild));
    if(R>m) ret=max(ret,query(L,R,rchild));
    return ret;
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        met(tree,0);
        build();
        while(m--)
        {
            string s;
            cin>>s;
            if(s=="Q")
            {
                int x,y;
                scanf("%d%d",&x,&y);
                printf("%d\n",query(x,y));
            }
            else
            {
                int pos,delta;
                scanf("%d%d",&pos,&delta);
                updata(pos,delta);
            }
        }
    }
}

4.hdu 1698 (区间更新＋区间求和)
代码：

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define met(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
#define lchild rt<<1,l,m
#define rchild rt<<1|1,m+1,r
const int maxn = 1e5+10;
int tree[maxn<<2],lazy[maxn<<2];
int N;
void push_up(int rt) {
    tree[rt] = tree[rt << 1] + tree[rt << 1 | 1];
}

void push_down(int rt, int len) {
    tree[rt << 1] = lazy[rt] * (len - (len >> 1));
    lazy[rt << 1] = lazy[rt];
    tree[rt << 1 | 1] = lazy[rt] * (len >> 1);
    lazy[rt << 1 | 1] = lazy[rt];
    lazy[rt] = 0;
}

void build(int rt = 1, int l = 1, int r = N) {
    if (l == r) { tree[rt]=1; return; }
    int m = (l + r) >> 1;
    build(lchild); build(rchild);
    push_up(rt);
}

void update(int L, int R, int delta, int rt = 1, int l = 1, int r = N) {
    if (L <= l && r <= R) {
        tree[rt] = delta * (r - l + 1);
        lazy[rt] = delta;
        return;
    }
    if (lazy[rt]) push_down(rt, r - l + 1);
    int m = (l + r) >> 1;
    if (L <= m) update(L, R, delta, lchild);
    if (R > m)  update(L, R, delta, rchild);
    push_up(rt);
}

int query(int L, int R, int rt = 1, int l = 1, int r = N) {
    if (L <= l && r <= R) return tree[rt];
    if (lazy[rt]) push_down(rt, r - l + 1);
    int m = (l + r) >> 1, ret = 0;
    if (L <= m) ret += query(L, R, lchild);
    if (R > m)  ret += query(L, R, rchild);
    return ret;
}

int main()
{
    int t;
    scanf("%d",&t);
    int id=1;
    while(t--)
    {
        met(tree,0);
        met(lazy,0);
        scanf("%d",&N);
        build();
        int m;
        scanf("%d",&m);
        while(m--)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            update(x,y,z);
        }
        printf("Case %d: The total value of the hook is %d.\n",id++,query(1,N));
    }
}

5.poj 2777

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define met(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
typedef long long ll;
const int maxn = 100000+10;
struct node
{
    int left,right;
    int color;
    int lazy;
}tree[maxn<<2];

void push_up(int root)
{
    if(tree[root].left==tree[root].right)
        return;
    tree[root].color=tree[root<<1].color|tree[root<<1|1].color;
    return;
}

void push_down(int root)
{
    if(tree[root].left==tree[root].right)
        return;
    if(tree[root].lazy==0)
        return;
    tree[root<<1].lazy=tree[root<<1|1].lazy=tree[root].lazy;
    tree[root<<1].color=tree[root].color;
    tree[root<<1|1].color=tree[root].color;
    tree[root].lazy=0;
    return;
}

void build(int left,int right,int root)
{
    tree[root].left=left,tree[root].right=right;
    tree[root].color=1,tree[root].lazy=0;
    if(left==right)
        return;
    int mid=(left+right)>>1;
    build(left,mid,root<<1),build(mid+1,right,root<<1|1);
}

void updata(int l,int r,int delta,int root)
{
    if(tree[root].left==l&&tree[root].right==r)
    {
        tree[root].color=1<<(delta-1);
        tree[root].lazy=delta;
        return;
    }
    push_down(root);
    int mid=(tree[root].left+tree[root].right)>>1;
    if(r<=mid) updata(l,r,delta,root<<1);
    else if(l>mid) updata(l,r,delta,root<<1|1);
    else {
        updata(l,mid,delta,root<<1);
        updata(mid+1,r,delta,root<<1|1);
    }
    push_up(root);
}

int query(int l,int r,int root)
{
    if(tree[root].left==l&&tree[root].right==r)
        return tree[root].color;
    push_down(root);
    int mid=(tree[root].left+tree[root].right)>>1;
    if(r<=mid) return query(l,r,root<<1);
    else if(l>mid) return query(l,r,root<<1|1);
    else return query(l,mid,root<<1)|query(mid+1,r,root<<1|1);
}

int change(int num)
{
    int ans=0;
    while(num)
    {
        ans+=num%2;
        num/=2;
    }
    return ans;
}

int main()
{
    int N,T,O;
    while(scanf("%d%d%d",&N,&T,&O)!=EOF)
    {
        build(1,N,1);
        while(O--)
        {
            char s[100];
            int x,y;
            scanf("%s%d%d",s,&x,&y);
            if(x>y)
                swap(x,y);
            if(s[0]=='C')
            {
                int delta;
                scanf("%d",&delta);
                updata(x,y,delta,1);
            }
            else
            {
                printf("%d\n",change(query(x,y,1)));
            }
        }
    }
}

6.poj 3468

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define met(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
typedef long long ll;
const int maxn = 1e5+10;
struct node
{
    ll left,right;
    ll sum,lazy;
}tree[maxn<<2];
ll ans;

void push_up(ll root)
{
    tree[root].sum=tree[root<<1].sum+tree[root<<1|1].sum;
}

void push_down(ll root)
{
    tree[root<<1].lazy+=tree[root].lazy;;
    tree[root<<1|1].lazy+=tree[root].lazy;
    tree[root<<1].sum+=tree[root].lazy*(tree[root<<1].right-tree[root<<1].left+1);
    tree[root<<1|1].sum+=tree[root].lazy*(tree[root<<1|1].right-tree[root<<1|1].left+1);
    tree[root].lazy=0;
}

void build(ll left,ll right,ll root)
{
    tree[root].left=left,tree[root].right=right;
    tree[root].lazy=0;
    if(left==right)
    {
        scanf("%lld",&tree[root].sum);
        return;
    }
    ll mid=(left+right)>>1;
    build(left,mid,root<<1);
    build(mid+1,right,root<<1|1);
    push_up(root);
}

void updata(ll left,ll right,ll delta,ll root)
{
    if(right<tree[root].left||left>tree[root].right) return;
    if(left<=tree[root].left&&right>=tree[root].right)
    {
        tree[root].sum+=delta*(tree[root].right-tree[root].left+1);
        tree[root].lazy+=delta;
        return;
    }
    if(tree[root].lazy) push_down(root);
    updata(left,right,delta,root<<1);
    updata(left,right,delta,root<<1|1);
    push_up(root);
}

void query(ll left,ll right,ll root)
{
    if(left>tree[root].right||right<tree[root].left) return;
    if(left<=tree[root].left&&right>=tree[root].right)
    {
        ans+=tree[root].sum;
        return;
    }
    if(tree[root].lazy) push_down(root);
    ll mid=(tree[root].left+tree[root].right)>>1;
    if(mid>=right) query(left,right,root<<1);
    else if(mid<left) query(left,right,root<<1|1);
    else
    {
        query(left,mid,root<<1);
        query(mid+1,right,root<<1|1);
    }
}

int main()
{
    int N,Q;
    scanf("%d%d",&N,&Q);
    met(tree,0);
    build(1,N,1);
    char s[10];
    ll x,y;
    while(Q--)
    {
        scanf("%s%lld%lld",s,&x,&y);
        if(s[0]=='Q')
        {
            ans=0;
            query(x,y,1);
            printf("%lld\n",ans);
        }
        else
        {
            ll delta;
            scanf("%lld",&delta);
            updata(x,y,delta,1);
        }
    }
}

7.hdu 2795

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define met(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
typedef long long ll;
const int maxn = 2e5+10;
struct node
{
    int left,right;
    int data;
}tree[maxn<<2];
int h,w,n;

void push_up(int root)
{
    tree[root].data=max(tree[root<<1].data,tree[root<<1|1].data);
}

void build(int root,int left,int right)
{
    tree[root].left=left;
    tree[root].right=right;
    if(tree[root].left==tree[root].right)
    {
        tree[root].data=w;
        return;
    }
    int mid=(left+right)>>1;
    build(root<<1,left,mid);
    build(root<<1|1,mid+1,right);
    push_up(root);
}

void updata(int root,int pos)
{
    if(tree[root].left==tree[root].right)
    {
        printf("%d\n",tree[root].left);
        tree[root].data-=pos;
        return;
    }
    if(tree[root*2].data>=pos)
        updata(root<<1,pos);
    else
        updata(root<<1|1,pos);
    push_up(root);
}

int main()
{
    while (scanf("%d%d%d",&h,&w,&n)!=EOF)
    {
        if(h>n)
            h=n;
        build(1,1,h);
        while(n--)
        {
            int num;
            scanf("%d",&num);
            if(tree[1].data>=num)
                updata(1,num);
            else
                printf("-1\n");
        }
    }
}
kicksilver7
关注
专栏目录
什么是线段树？
wolfGuiDao的博客
10-04 899
什么是线段树？ 文章目录什么是线段树？一、简介二、线段树的结构与建树如何存储这个线段树呢?三、区间查询那么如何判断两个区间是否有交集？四、单点修改五、区间修改、懒标记懒标记六、完整代码线段树节点的构造下传标记的函数区间修改的函数加入懒标记后的建树函数加入懒标记后的查询函数主函数中的调用七、区间合并操作与懒标记的运用八、权值线段树动态开点九、查找排名第k的数十、查询数 k 的排名 一、简介 线段树是在算法竞赛中常用来维护区间信息的数据结构，同时，线段树的理解难度较树状数组低（当然是在理解递归的前提下）。
线段树题目整合
hao_zong_yin的博客
07-25 3899
1.hdu1166 敌兵布阵 更新节点,区间求和。 2.hdu1754 I Hate It 更新节点,区间最值. . 3.hdu1698 Just a Hook 成段更新,总区间求和. . 4.hdu1394 Minimum Inversion Number 更新节点,区间求和 . 5.hdu1779 9-Problem C暂不公开 成段更新,区间最值
线段树习题集
天亮说晚安
02-17 3878
线段树习题集 大部分来源于@NotOnlySuccess  一、点修改 最最基础的线段树,只更新叶子节点,然后把信息用PushUp(int rt)这个函数更新上来 hdu1166 敌兵布阵 线段树功能:update:单点增减 query:区间求和 解题报告 hdu1754 I Hate It 线段树功能:update:单点替换 query:区间最值 解
线段树（例题）
najiuzheyangbaacm的博客
08-03 609
C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地,Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚,每个工兵营地的人数都有可能发生变动，可能增加或减少若干人手,但这些都逃不过C国的监视。 中央情报局要研究敌人究竟演习什么战术,所以...
线段树_例题（HDU1166—敌兵布阵+HDU1754—I Hate It ）+板子
From now on...的Blogs
08-04 174
又是一个学习周期，今天学了线段树基础版的，早上困得一批，什么也没听进去，只能下午自己来脑补了 首先说什么是线段树，这有一篇大佬的bloghttps://blog.csdn.net/zearot/article/details/4829945线段树详解， 自我理解就是一个进阶版的分治过程，先把整个大区间拆分开来，弄成好过好多个小区间（当然拆到最后还剩一个节点）通过对小区间操作然后修改与他...
线段树例题
Tom~~~
08-16 713
线段树是一种二叉搜索树，将原始数据都存在叶节点，依次表示出每个叶节点的根节点。 一般数组开到叶节点数量的4倍。 关于线段树的例题 。HDU1166 敌兵布阵 按照指示来就可以 代码 #include &lt;stdio.h&gt; #include &lt;algorithm&gt; #include &lt;iostream&gt; #include &lt;string&gt; u...
洛谷上除了可持久化线段树的模板题，还有哪些经典的可持久化线段树例题？
最新发布
08-22
洛谷网站上除了持久化线段树的经典模板题之外，还有一些其他常见的经典题目涉及到这种数据结构的应用，包括但不限于： 1. **区间更新并查询**：如维护区间内的最大值、最小值、求和等问题，可以利用持久化线段树...
Arithmetic（线段树维护历史版本和）
Freopen的博客
04-29 1521
题意：一个多重集合的价值为将其变为公差为ddd(将在第一行输入)的等差数列需要插入几个数字（无法实现价值为0）。多次询问l,rl,rl,r，求[l,r][l,r][l,r]的子区间的价值和。 序列长度3e53e53e5，数字大小和d≤1e7d\leq 1e7d≤1e7 首先对于r′>rr'>rr′>r，lll使得[l,r][l,r][l,r]是最长的可以实现的区间，l′l'l′是...
线段树详解与应用实例
"线段树例题分析，包括线段树的基本概念、构造思想、运用以及实例解析，探讨了计算线段覆盖总长度的问题及其优化方法。" 线段树是一种数据结构，它允许我们高效地处理一系列线段或区间上的查询和更新操作。在计算机...
李超线段树学习笔记
shroud777的博客
03-15 482
文章目录李超线段树介绍主要思想实现大量例题P4254 - [JSOI2008]Blue Mary开公司P4097 - [HEOI2013]SegmentP4069 - [SDOI2016]游戏 李超线段树 介绍   李超线段树作为一种高级数据结构，其最经典的应用就是维护二维平面直角坐标系中，支持动态插入线段，（不支持删除线段），询问已插入直线中与直线 x=x0x=x_0x=x0​ 相交 yyy 值最大/最小值。其中插入直线复杂度 O(nlogn)O(nlogn)O(nlogn)，在指定区间插入线段复杂度 O
线段树习题
lllllan
07-20 108
简单题： hdu1166 hdu1394 hdu1698 hdu1754 hdu2795 poj1195 poj2182 poj2299 poj2828 poj2352 poj2750 poj2886 poj2777 poj3264 poj3468 中等题 hdu1540 hdu1823 hdu4027 hdu5869 poj2155 poj2528 poj2823 poj3225 综合题 hdu1255 hdu1542 hdu3642 hdu3974 hdu4578 hdu4614 hdu4718 h
线段树例题 题解
日居月诸的博客
09-11 489
文章目录T1题目链接解题思路详细代码T2题目链接解题思路详细代码T3题目链接解题思路详细代码 T1 题目链接 LOJ#10128. 「一本通 4.3 练习 2」花神游历各国 解题思路 首先，由于是区间问题，我们很容易想到使用线段树来维护区间和，完成区间修改操作。 但是区间修改操作并不好处理。如果对于区间里每个数都暴力地开平方，这一次操作的时间复杂度可是会退化成为O(n)O(n)O(n)的！ 怎么办...
最全线段树例题
yihanyifan的博客
09-23 1000
例题1： 给一个长度n的序列,对于每个询问 询问区间内最大连续和 一、一个区间的最大子段和有三种情况 1、左子区间的最大子段和 2、右子区间的最大子段和 3、横跨左右子区间 二、每个结点需要维护的信息 1、区间和sum 2、从区间左端点开始的最大子段和lgss 3、从区间右端点开始的最大子段和rgss 4、区间最大子段和gss 三、建树 1、遇到叶子节点就...
线段树入门三道题
Free Loop~~~跳动的音符
06-07 1244
线段树入门三水题
线段树详解（附图解，模板及经典例题分析）
qq_63786973的博客
10-31 3043
线段树是一种常用来维护区间信息的数据结构 ​ 可以在 O(logn) 的时间复杂度内实现单点修改、区间修改、区间查询（区间求和，求区间的最大值，求区间的最小值）等操作 ​ 如下图所示，线段树是建立在区间基础上的树，树的每个节点都代表着一段区间【L，R】
线段树
不可不戒
07-16 1284
从简单说起，线段树其实可以理解成一种特殊的二叉树。但是这种二叉树较为平衡，和静态二叉树一样，都是提前已经建立好的树形结构。针对性强，所以效率要高。这里又想到了一句题外话：动态和静态的差别。动态结构较为灵活，但是速度较慢；静态结构节省内存，速度较快。 接着回到线段树上来，线段树是建立在线段的基础上，每个结点都代表了一条线段[a , b]。长度为1的线段成为元线段。非元线段都有两个子结点，左结点
线段树经典题目（一定要做完）
bggl的博客
05-12 6568
最近学习了好久的线段树，对线段树有了初步的基础的认知，为了巩固知识点找几道基础题练练手 1.hdu1166 敌兵布阵 http://acm.hdu.edu.cn/showproblem.php?pid=1166 思路：线段树基础模版题（点修改+区间查询） #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;algorith...
线段树专辑(转)
黄廉政的专栏
08-04 1377
线段树专辑<br />这几天陆陆续续更新了下边几道我所能找到得具有一些代表性的线段树题目<br />从最最简单的区间求和到对区间的各种操作都包涵在这些题目里了<br />相信对一些准备学习线段树的人有一定得帮助<br />突然发现自己对数据结构的题目非常有感觉,所以在刷下边的题的同时也生出灵感出了好几道线段树题目<br />等比赛结束后也会陆续加进里边<br /><br />快半年过去代码风格也有很大的改变，感觉以前写的代码很不规范，用自己在预定义中定义的一些函数，但后来感觉作用不是很大，所以又删去了，所以
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值