线段树--区间乘法和区间加法

已于 2024-06-11 12:43:18 修改
阅读量1.5k 收藏 3
点赞数 2
分类专栏： 数据结构 文章标签： 算法 图论 数据结构
于 2021-05-11 19:37:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45748404/article/details/116666926
版权

假设有编号从1到n的n个点，每个点都存了一些信息，用[L,R]表示下标从L到R的这些点。
线段树的用处就是，对编号连续的一些点进行修改或者统计操作，修改和统计的复杂度都是O(log2(n)).
线段树的原理，就是，将[1,n]分解成若干特定的子区间(数量不超过4*n),然后，将每个区间[L,R]都分解为少量特定的子区间，通过对这些少量子区间的修改或者统计，来实现快速对[L,R]的修改或者统计。

由此看出，用线段树统计的东西，必须符合区间加法，否则，不可能通过分成的子区间来得到[L,R]的统计结果。

符合区间加法的例子：
数字之和 总数字之和 = 左区间数字之和 + 右区间数字之和
最大公因数(GCD) 总GCD = gcd( 左区间GCD , 右区间GCD )
最大值 总最大值=max(左区间最大值，右区间最大值)

不符合区间加法的例子：
众数 只知道左右区间的众数，没法求总区间的众数
01序列的最长连续零 只知道左右区间的最长连续零，没法知道总的最长连续零

结构体线段树实现：

int w[N];//存放节点的权值
struct node {
    int l, r;//左右的范围
    ll sum;//总和
    ll add;//懒标记
} tree[N << 2];//四倍

1.push_up()函数

void push_up(int root) { //利用左右子树信息更新当前节点信息
    tree[root].sum = tree[root << 1].sum + tree[root << 1 | 1].sum;
}

2.build()函数建树

void build(int root, int l, int r) {
    if (l == r)tree[root] = { l,r,w[r],0 }; //填入四个信息，其中w[r]为值
    else {
        tree[root] = { l,r }; //初始化信息
        int mid = l + r >> 1;
        build(root << 1, l, mid);//构建左子树
        build(root << 1 | 1, mid + 1, r);//构建右子树
        push_up(root);//构建完成左右子树后更新当前节点信息
    }
}

3.push_down()函数下放懒标记

void push_down(int root) { //下放当前节点的懒标记
    auto& Root = tree[root], & left = tree[root << 1], & right = tree[root << 1 | 1];
    if (Root.add) {//下放只是下放到当前节点的左右子节点
        left.add += Root.add, left.sum += (ll)(left.r - left.l + 1) * Root.add;//首先是懒标记下放，然后左右节点的和要更新
        right.add += Root.add, right.sum += (ll)(right.r - right.l + 1) * Root.add;//都是+=因为可能子节点本身有懒标记
        Root.add = 0;//记得将懒标记清0
    }
}

4.modify()修改函数

void modify(int root, int l, int r, int num) {
    if (l <= tree[root].l && tree[root].r <= r) {//如果当前节点包含的区间在修改区间内，直接修改节点的信息即可
        tree[root].sum += (ll)(tree[root].r - tree[root].l + 1) * num;//修改该节点的和为区间长度乘以加数
        tree[root].add += num;//修改该节点的懒标记
    }
    else { //如果不完全包含
        push_down(root);//下放懒标记
        int mid = tree[root].l + tree[root].r >> 1;//计算当前节点所包含区间的中值
        if (l <= mid)modify(root << 1, l, r, num);//节点的左边区间和当前修改区间有交集
        if (r > mid)modify(root << 1 | 1, l, r, num);//节点的右边区间和当前修改区间有交集
        push_up(root);//记得push_up操作更新当前节点
    }
}

5.query()查询函数

ll query(int root, int l, int r) {
    //递归尾(查询区间大于节点区间,节点是其中一部分直接返回)
    if (l <= tree[root].l && tree[root].r <= r)return tree[root].sum;
    //(查询区间小于节点区间,在节点区间内进行细化)
    push_down(root);//没有的话就下放懒标记
    int mid = tree[root].l + tree[root].r >> 1;//计算当前节点所包含区间的中值
    if (r <= mid)return query(root << 1, l, r);//如果查询区间完全在节点的左区间
    else if (l > mid)return query(root << 1 | 1, l, r);//如果查询区间完全在节点的右区间
    else {//如果左右区间都包含有
        ll left = query(root << 1, l, r);
        ll right = query(root << 1 | 1, l, r);
        ll ans;
        //push_up
        ans = left + right;
        return ans;
    }
 }

洛谷 P3372 【模板】线段树 1
区间查询，区间修改（加）
结构体版

#include<bits/stdc++.h>
using namespace std;
template<class...Args>
void debug(Args... args) {//Parameter pack
    auto tmp = { (cout << args << ' ', 0)... };
    cout << "\n";
}
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll>pll;
typedef pair<int, int>pii;
const int INF = 0x7fffffff;
const int N = 1e5 + 5;
int w[N];//存放权值
struct node {
    int l, r;//左右的范围
    ll sum;//总和
    ll add;//懒标记
} tree[N << 2];
void push_up(int root) { //利用左右子树信息更新当前节点信息
    tree[root].sum = tree[root << 1].sum + tree[root << 1 | 1].sum;
}
void push_down(int root) { //下放当前节点的懒标记
    auto& Root = tree[root], & left = tree[root << 1], & right = tree[root << 1 | 1];
    if (Root.add) {//下放只是下放当前节点的左右子节点
        left.add += Root.add, left.sum += (ll)(left.r - left.l + 1) * Root.add;//首先是懒标记下放，然后左右节点的和要更新
        right.add += Root.add, right.sum += (ll)(right.r - right.l + 1) * Root.add;//都是+=因为可能子节点本身有懒标记
        Root.add = 0;//记得将懒标记清0
    }
}
void build(int root, int l, int r) {
    if (l == r)tree[root] = { l,r,w[r],0 }; //填入四个信息，其中w[r]为值
    else {
        tree[root] = { l,r }; //初始化信息
        int mid = l + r >> 1;
        build(root << 1, l, mid);//构建左子树
        build(root << 1 | 1, mid + 1, r);//构建右子树
        push_up(root);//构建完成左右子树后更新当前节点信息
    }
}
void modify(int root, int l, int r, int num) {
    if (l <= tree[root].l && tree[root].r <= r) {//如果当前节点包含的区间在修改区间内，直接修改节点的信息即可
        tree[root].sum += (ll)(tree[root].r - tree[root].l + 1) * num;//修改该节点的和为区间长度乘以加数
        tree[root].add += num;//修改该节点的懒标记
    }
    else { //如果不完全包含
        push_down(root);//下放懒标记
        int mid = tree[root].l + tree[root].r >> 1;//计算当前节点所包含区间的中值
        if (l <= mid)modify(root << 1, l, r, num);//节点的左边区间和当前修改区间有交集
        if (r > mid)modify(root << 1 | 1, l, r, num);//节点的右边区间和当前修改区间有交集
        push_up(root);//记得push_up操作更新当前节点
    }
}
ll query(int root, int l, int r) {
    //递归尾(查询区间大于节点区间,节点是其中一部分直接返回)
    if (l <= tree[root].l && tree[root].r <= r)return tree[root].sum;
    //(查询区间小于节点区间,在节点区间内进行细化)
    push_down(root);//没有的话就下放懒标记
    int mid = tree[root].l + tree[root].r >> 1;//计算当前节点所包含区间的中值
    if (r <= mid)return query(root << 1, l, r);//如果查询区间完全在节点的左区间
    else if (l > mid)return query(root << 1 | 1, l, r);//如果查询区间完全在节点的右区间
    else {//如果左右区间都包含有
        ll left = query(root << 1, l, r);
        ll right = query(root << 1 | 1, l, r);
        ll ans;
        //push_up
        ans = left + right;
        return ans;
    }
 }
int main() {
    ios_base::sync_with_stdio(false), cin.tie(0);

    ll n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++)cin >> w[i];
    build(1, 1, n);
    while (m--) {
        string str;
        ll a, b, c;
        cin >> str;
        if (str[0] == '1') {
            cin >> a >> b >> c;
            modify(1, a, b, c);
        }
        else {
            cin >> a >> b;
            cout << query(1, a, b) << "\n";
        }
    }

    return 0;
}

poj 3468 A Simple Problem with Integers
区间查询，区间修改（加）
非结构体版

//#include<bits/stdc++.h>
#include<iostream>
using namespace std;
template <typename T> void debug(string s, T x) { cout << s << "=" << x << "\n"; }
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll>pll;
const ll N = 1e5 + 5;
const ll MOD = 1e9 + 7;
const ll INF = 0x7fffffff;
long long sum[N << 2], add[N << 2];
void push_up(ll rt) {//向上更新,通过当前结点rt把值递归但父结点
    sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
}
void push_down(ll rt, ll m) {//更新rt的子结点
    if (add[rt]) {
        add[rt << 1] += add[rt];
        add[rt << 1 | 1] += add[rt];
        sum[rt << 1] += (m - (m >> 1)) * add[rt];
        sum[rt << 1 | 1] += (m >> 1) * add[rt];
        add[rt] = 0;//取消本层标记
    }
}

void build(ll l, ll r, ll rt) {            //用满二叉树建树
    add[rt] = 0;
    if (l == r) {                                   //叶子结点，赋值
        cin >> sum[rt];
        return;
    }
    ll mid = (l + r) >> 1;
    build(l, mid, rt << 1);
    build(mid + 1, r, rt << 1 | 1);
    push_up(rt);                                  //向上更新区间和
}
void update(ll a, ll b, ll c, ll l, ll r, ll rt) {//区间更新
    if (a <= l && b >= r) {
        sum[rt] += (r - l + 1) * c;
        add[rt] += c;
        return;
    }
    push_down(rt, r - l + 1);//向下更新
    ll mid = (l + r) >> 1;
    if (a <= mid) update(a, b, c, l, mid, rt << 1);        //分成两半，继续深入
    if (b > mid) update(a, b, c, mid + 1, r, rt << 1 | 1);
    push_up(rt);//向上更新
}
ll query(ll a, ll b, ll l, ll r, ll rt) {       //区间求和
    if (a <= l && b >= r) return sum[rt];          //满足lazy，直接返回值
    push_down(rt, r - l + 1);                       //向下更新
    ll mid = (l + r) >> 1;
    ll ans = 0;
    if (a <= mid) ans += query(a, b, l, mid, rt << 1);
    if (b > mid) ans += query(a, b, mid + 1, r, rt << 1 | 1);
    return ans;
}
int main() {
    ios_base::sync_with_stdio(false), cin.tie(0);

    ll n, m;
    cin >> n >> m;
    build(1, n, 1);
    while (m--) {
        string str;
        ll a, b, c;
        cin >> str;
        if (str[0] == 'C') {
            cin >> a >> b >> c;
            update(a, b, c, 1, n, 1);
        }
        else {
            cin >> a >> b;
            cout << query(a, b, 1, n, 1)<<"\n";
        }
    }

    return 0;
}

区间加法
P3373 【模板】线段树 2
在这里插入图片描述

#include<bits/stdc++.h>
#include <unordered_map>
using namespace std;
template<class...Args>
void debug(Args... args) {//Parameter pack
    auto tmp = { (cout << args << ' ', 0)... };
    cout << "\n";
}
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll>pll;
typedef pair<int, int>pii;
const ll N = 1e5 + 5;
//const ll MOD = 998244353;
const ll INF = 0x7fffffff;
int MOD;
int w[N];//存放权值
struct node {
    int l, r;//左右的范围
    ll sum;//总和
    ll mul;//乘法懒标记
    ll add;//加法懒标记
} tree[N << 2];
void push_up(int root) { //利用左右子树信息更新当前节点信息
    tree[root].sum = (tree[root << 1].sum + tree[root << 1 | 1].sum) % MOD;
}
void push_down(int root) { //下放当前节点的懒标记
    auto& Root = tree[root], & left = tree[root << 1], & right = tree[root << 1 | 1];
    //例子：(x*a+b)*c+d=x*ac+bc+d
    left.sum = (left.sum * Root.mul + (left.r - left.l + 1) * Root.add) % MOD;
    left.add = (left.add * Root.mul + Root.add) % MOD;
    left.mul = left.mul * Root.mul % MOD;

    right.sum = (right.sum * Root.mul + (right.r - right.l + 1) * Root.add) % MOD;
    right.add = (right.add * Root.mul + Root.add) % MOD;
    right.mul = right.mul * Root.mul % MOD;
    //重置懒标记
    Root.add = 0;
    Root.mul = 1;
}
void build(int root, int l, int r) {
    if (l == r)tree[root] = { l,r,w[r],1,0 };
    else {
        tree[root] = { l,r ,0,1,0}; //初始化信息
        int mid = l + r >> 1;
        build(root << 1, l, mid);//构建左子树
        build(root << 1 | 1, mid + 1, r);//构建右子树
        push_up(root);//构建完成左右子树后更新当前节点信息
    }
}
void modify(int root, int l, int r, int mul,int add) {
    if (l <= tree[root].l && tree[root].r <= r) {//如果当前节点包含的区间在修改区间内，直接修改节点的信息即可
        //修改该节点的和
        tree[root].sum = (tree[root].sum * mul + (tree[root].r - tree[root].l + 1) * add) % MOD;
        //修改该节点的懒标记
        tree[root].add = (tree[root].add * mul + add) % MOD;
        tree[root].mul = tree[root].mul * mul % MOD;
    }
    else { //如果不完全包含
        push_down(root);//下放懒标记
        int mid = tree[root].l + tree[root].r >> 1;//计算当前节点所包含区间的中值
        if (l <= mid)modify(root << 1, l, r, mul,add);//节点的左边区间和当前修改区间有交集
        if (r > mid)modify(root << 1 | 1, l, r, mul,add);//节点的右边区间和当前修改区间有交集
        push_up(root);//记得push_up操作更新当前节点
    }
}
ll query(int root, int l, int r) {
    //递归尾(查询区间大于节点区间,节点是其中一部分直接返回)
    if (l <= tree[root].l && tree[root].r <= r)return tree[root].sum;
    //(查询区间小于节点区间,在节点区间内进行细化)
    push_down(root);//没有的话就下放懒标记
    int mid = tree[root].l + tree[root].r >> 1;//计算当前节点所包含区间的中值
    if (r <= mid)return query(root << 1, l, r);//如果查询区间完全在节点的左区间
    else if (l > mid)return query(root << 1 | 1, l, r);//如果查询区间完全在节点的右区间
    else {//如果左右区间都包含有
        ll left = query(root << 1, l, r);
        ll right = query(root << 1 | 1, l, r);
        ll ans;
        //push_up
        ans = (left + right) % MOD;
        return ans;
    }
}
int main() {
    ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);

    int n, m;
    cin >> n >> m >> MOD;
    for (int i = 1; i <= n; i++)cin >> w[i];
    build(1, 1, n);
    while (m--) {
        int op;
        cin >> op;
        if (op == 1) {
            int l, r, mul;
            cin >> l >> r >> mul;
            modify(1, l, r, mul, 0);
        }
        else if (op == 2) {
            int l, r, add;
            cin >> l >> r >> add;
            modify(1, l, r, 1, add);
        }
        else {
            int l, r;
            cin >> l >> r;
            cout << query(1, l, r) << "\n";
        }
    }

    return 0;
}
Weach
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
P3373 【模板】线段树 2(区间乘法+区间加法+区间求和)
starlet_kiss的博客
02-19 496
题目描述 如题，已知一个数列，你需要进行下面三种操作： 将某区间每一个数乘上 xx 将某区间每一个数加上 xx 求出某区间每一个数的和 输入格式 第一行包含三个整数 n,m,pn,m,p，分别表示该数列数字的个数、操作的总个数和模数。 第二行包含 nn 个用空格分隔的整数，其中第 ii 个数字表示数列第 ii 项的初始值。 接下来 mm 行每行包含若干个整数，表示一个操作，具体如下： 操作 11： 格式：1 x y k 含义：将区间 [x,y][x,y] 内每个数乘上 kk 操作 22： 格式：2 x y
线段树2：区间乘法实现
weixin_30568591的博客
08-20 362
之前的线段树1相信大家都做过了。线段树1要求能够实现区间加法和区间查询，那如果再添加一项区间乘呢？ 显然，之前我们引入的懒标记是为了更快速的实现区间修改。 但这也仅仅是对于同等级的运算。 因为不同运算等级的运算是无法累积在同一懒标记的。 应该很好理解。就好比你要把你的孩子结点进行区间乘操作，但是你只是把你存储的懒标记乘了一下，是无法达到效果的。 考虑引入两个懒标记。 一个负责存储区间...
线段树杂谈·普通线段数|乘法线段数|主席树
这里是大千小熊的博客，一个温暖故事的开篇
07-18 271
。・ω・。)一点点前置知识x
C++数列区间最大值（线段树）
星辰大海的博客
10-04 2175
输入一串数字，给你 M 个询问，每次询问就给你两个数字 X,Y，要求你说出 X 到 Y这段区间内的最大数。 输入格式 第一行两个整数 N,M表示数字的个数和要询问的次数； 接下来一行为 N个数；接下来 M行，每行都有两个整数 X,Y。 输出格式 输出共 M行，每行输出一个数。 数据范围 1≤N≤105,1≤M≤106,1≤X≤Y≤N, 数列中的数字均不超过231−1 输入样例： 10 2 3 2 4 5 6 8 1 2 9 7 1 4 3 8 输出样例： 5 8 线段树叶子节点是元素值，一个父节点不超过两个
线段树的区间加法与区间乘法
zqc的博客
04-18 805
P3372 【模板】线段树 1 题目描述 如题，已知一个数列，你需要进行下面两种操作： 将某区间每一个数加上 kk。 求出某区间每一个数的和。 输入格式 第一行包含两个整数 n, mn,m，分别表示该数列数字的个数和操作的总个数。 第二行包含 nn 个用空格分隔的整数，其中第 ii 个数字表示数列第 ii 项的初始值。 接下来 mm 行每行包含 33 或 44 个整数，表示一个操作，具体如下： 1...
线段树（从入门到进阶）
hahahahahaha5的博客
10-31 1705
首先，讲解线段树之前，应该了解到线段树应该是一种工具，可以将一些对于区间（或者线段）的修改、维护，从O(N)的时间复杂度变成O（logN）。 一.线段树概念引入 线段树是一种二叉树，也就是对于一个线段，我们会用一个二叉树来表示。比如说一个长度为5的线段，我们可以表示成这样： 这代表着如果你要表示线段的和，那么最上面的根节点权值就等于两个儿子节点的权值之和。 那么就可以得到：节点i的权值 = i节点的左儿子权值 + i节点的右儿子权值 二.简单线段树 三.区间+/-修改与区间查询 四.区间乘除修改与查询
线段树区间乘法，区间加，区间查询和
bangdexuanyuan的博客
11-08 37
浅入深地讲解线段树 首先是最简单的模版——区间加，区间查 我们需要这样5个函数 pushup——由下往上地传递信息 pushdown——传递懒标记 build——建立出树形结构 modify——区间加操作 query——区间查询 1.建树 struct node{ int l,r; long long sum,add; }tr[maxn*4]; void build(int p,int l,...
统计的力量-线段树全接触-张昆玮
05-10
2. **适应能力强**：线段树可以处理各种区间操作，例如区间加法、区间乘法、区间最大值或最小值查询等。 3. **编写方便**：相比于其他高级数据结构，线段树的实现相对简单，易于理解。 4. **结构简单**：线段树的...
线段树Java实现-SegmentTree
最新发布
05-01
线段树Java实现——SegmentTree.txt 与文章中的讲解一致，几乎每句代码均有注释 阅读更方便，详细解析线段树 以区间求和为例进行代码的书写和解析。
SegmentTree:线段树-C ++模板
03-06
段树线段树-C ++模板线段树译文+ ACcode +分析（这是一个小菜鸡的做题记录以及一些小心得）有错误请指出，十分感谢。〜过渡来源会标在.cpp文件。多层次洛谷（QAQ萌新其他网站不会做） PXXX.cpp表示的是洛谷译文前面...
线段树区间更新code
12-22
线段树区间更新代码线段树区间更新代码线段树区间更新代码线段树区间更新代码
ACM 程序设计：线段树-p6.pdf
06-18
ACM 程序设计：线段树-p6.pdf
线段树——区间加、区间乘
aaa7888210的博客
11-05 134
线段树
线段树板子（区间加法+区间乘法）
到处遛鸟刑警
04-13 253
我呃呃 这个题主要的思想就是懒标记。。。（然而我之前并没有写过，结果就因为理解出现偏差，就写了2个小时） 懒标记与你当前线段树节点没关系，是维护子树的 ，，，我就认为懒标记也维护了自己。。 结果就翻车了（创造了一个线段树套队列的神奇结构。。。。。。。我太弱了（不过不算空间的话，跑的还是挺快的（最大的点1s多一点（USED O2）））） 这线段树上有两个懒标记，分别是加法的和乘法的。。。。 嘛，你们...
【线段树】单点修改&区间求和&区间求最大值&区间求最小值
小明的博客
03-16 1958
*对于线段树，怎么说呢，就是直接套板子就得了，关键一点就是，细心点不要把板子都写错了，接下来我给出几道线段树题解 * 文章目录一：不加修改的区间求最值二：单点修改求区间求最值三：单点修改区间求和四：区间修改，区间求最值五：区间修改，区间就和 一：不加修改的区间求最值 题目1：UPC Contest1461 - 数据结构 G题 数列区间最大值 传送门 问题描述： 输入一串数字，给你M个询问，每次询...
线段树区间乘法+区间加法
u014681071的博客
12-25 1230
/* 线段树区间乘法+区间加法 by sbn */ #include<iostream> #include<cstdio> using namespace std; typedef long long ll; ll n,m,p,z; ll arr[100001]; struct node{ ll l,r; ll sum,add,mul; } tree[
线段树(加法与乘法的lazy标记)
FSYo 的博客
08-19 963
struct Node{int l,r,add,mul;}tree[N]; 开始在想,加了又乘又加,乘法又优先,怎么搞 现在先理清几点 1.add,mul是指现在算了,儿子没算的 2.mul只记儿子要乘的,如果先加在乘,直接把add*val就行了 举个例子 一个区间 1 4 3 2   全部 +1 , *2 ,+1 首先 tree[1].add+=1,mul不变 其次 tr...
P3373 【模板】线段树 2（区间加法+区间乘法+区间求和取模）
nEo.大魔王
04-22 376
#include <bits/stdc++.h> #define lson l,m,rt << 1 #define rson m+1,r,rt << 1|1 using namespace std; typedef long long ll; const int maxn = 1e5+10; int mod = 1000; ll sum[maxn <&l...
银行排队系统
weach的博客
01-14 8675
免责声明 以下内容可能引起不适，请18岁以儿童下在大人配同下观看 主要内容： 设计并实现银行取号模拟系统，模拟取号的整个过程,实现取号、排队、服务、及管理等功能。系统能够记录用户及工作人员信息的统计和分析，可以进一步优化银行营业厅的排队问题，提高银行业务办理效率。 基本要求： （1）首先设计一个含有多个菜单项主控菜单子程序，以链接系统的各项子功能，方便用户使用本系统。 （2）采用链式队列存储银行排队系统中的顾客号信息，用结构数组存放办理银行业务的窗口号信息。 （3）本系统分为一下6个功能模块，分别是：
线段树区间修改和区间求和
10-07
线段树是一种用于解决区间操作的数据结构。对于线段树的区间修改操作，可以通过递归的方式将需要修改的区间划分成更小的区间直到达到叶子节点，然后对叶子节点进行修改。而对于线段树的区间求和操作，可以通过递归的方式将需要求和的区间划分成更小的区间直到达到叶子节点，然后将每个节点的值累加起来即可得到区间的求和结果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值