线段树例题 题解

最新推荐文章于 2022-04-04 04:36:15 发布
最新推荐文章于 2022-04-04 04:36:15 发布
阅读量506 收藏
点赞数
分类专栏： OI的那些事 文章标签： 线段树 题解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41996523/article/details/100752199
版权
本文深入探讨线段树在区间问题中的应用，包括区间修改、区间查询、懒标记优化及字符频率维护等高级技巧，通过三个具体题目解析，帮助读者掌握线段树的核心算法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

T1

题目链接

LOJ#10128. 「一本通 4.3 练习 2」花神游历各国

解题思路

首先，由于是区间问题，我们很容易想到使用线段树来维护区间和，完成区间修改操作。
但是区间修改操作并不好处理。如果对于区间里每个数都暴力地开平方，这一次操作的时间复杂度可是会退化成为 O ( n ) O(n) O(n)的！
怎么办呢？我们难以想到好的方法。但是我们发现，处理数据的方式是开平方！
我们联想到指数增长的恐怖，我们就能够发现，对于每一个数，它开几次平方后就会变成0 或 1.我们可以从这个方面来进行剪枝。

详细代码

#define USEFASTERREAD 1

#define rg register
#define inl inline
#define DEBUG printf("qwq\n")
#define DEBUGd(x) printf("var %s is %lld", #x, ll(x))
#define DEBUGf(x) printf("var %s is %llf", #x, double(x))
#define putln putchar('\n')
#define putsp putchar(' ')
#define Rep(a, s, t) for(rg int a = s; a <= t; a++)
#define Repdown(a, t, s) for(rg int a = t; a >= s; a--)
typedef long long ll;
typedef unsigned long long ull;
#include<cstdio>

#if USEFASTERREAD
char In[1 << 20], *ss = In, *tt = In;
#define getchar() (ss == tt && (tt = (ss = In) + fread(In, 1, 1 << 20, stdin), ss == tt) ? EOF : *ss++)
#endif
namespace IO {
	inl void RS() {freopen("test.in", "r", stdin), freopen("test.out", "w", stdout);}
	inl ll read() {
		ll x = 0, f = 1; char ch = getchar();
		for(; ch < '0' || ch > '9'; ch = getchar()) if(ch == '-') f = -1;
		for(; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + int(ch - '0');
		return x * f;
	}
	inl void write(ll x) {
		if(x < 0) {putchar('-'); x = -x;}
		if(x >= 10) write(x / 10);
		putchar(x % 10 + '0');
	}
	inl void writeln(ll x) {write(x), putln;}
	inl void writesp(ll x) {write(x), putsp;}
}
using namespace IO;
template<typename T> inline T Max(const T& x, const T& y) {return y < x ? x : y;}
template<typename T> inline T Min(const T& x, const T& y) {return y < x ? y : x;}
template<typename T> inline void Swap(T& x, T& y) {T tmp = x; x = y; y = tmp;}
template<typename T> inline T Abs(const T& x) {return x < 0 ? -x : x;}
#include<cmath>
#include<cstring>
#define Clear(arr) memset(arr, 0x00, sizeof arr)
const int MAXN = 1e5 + 5;
const int MAXM = 2e5 + 5;
int N, M;
struct Segment_tree {
    #define ls o << 1
    #define rs o << 1 | 1
    int l[MAXN << 2], r[MAXN << 2];
    ll v[MAXN << 2];
    bool flag[MAXN << 2];
    //flag 若是1， 表示该子树不用开根了（是0或1）

    void pushup(int o) {
        v[o] = v[ls] + v[rs];
        flag[o] = flag[ls] && flag[rs];
    }
    void build(int o, int L, int R, int a[]) {
        l[o] = L, r[o] = R;
        if(L == R) {
            v[o] = a[L];
            if(v[o] == 0 || v[o] == 1) flag[o] = 1;
            return;
        }
        int m = (L + R) >> 1;
        build(ls, L, m, a);
        build(rs, m + 1, R, a);
        pushup(o);
    }
    void modify(int o, int x, int y) {
        if(flag[o]) return;
        if(l[o] == r[o]) {
            v[o] = ll(sqrt(v[o]));
            if(v[o] == 1) flag[o] = 1;
            return;
        }
        int m = (l[o] + r[o]) >> 1;
        if(x <= m) modify(ls, x, y);
        if(y > m) modify(rs, x, y);
        pushup(o);
    }
    ll sum(int o, int x, int y) {
        if(x <= l[o] && r[o] <= y) return v[o];
        int m = (l[o] + r[o]) >> 1;
        ll ans = 0;
        if(x <= m) ans += sum(ls, x, y);
        if(y > m) ans += sum(rs, x, y);
        return ans;
    }

    Segment_tree() {
        Clear(l);
        Clear(r);
        Clear(v);
        Clear(flag);
    }
    #undef ls
    #undef rs
}tr;
int delta[MAXN];


int main() {
	//RS();
    N = read();
    for(rg int i = 1; i <= N; i++) delta[i] = read();
    tr.build(1, 1, N, delta);
    M = read();
    while(M--) {
        int opt = read();
        int l = read(), r = read();
        if(opt == 1) {
            writeln(tr.sum(1, l, r));
        }
        else tr.modify(1, l, r);
    }

	return 0;
}

T2

题目链接

#10129. 「一本通 4.3 练习 3」维护序列

解题思路

这道题很明显是维护区间问题，可以用线段树来做。
但是，这道题的编程难点在于 l a z y − t a g lazy-tag lazy−tag的设置。我们为了控制时间复杂度，一定要设置两个 l a z y − t a g lazy-tag lazy−tag，一个管乘，一个管加。那么它们的优先级很值得考虑。
多手玩，多分析，就不会出错。

对于有多个lazy-tag的题目，无后效性考虑每个lazy-tag，并计算其对之后要考虑的lazy-tag的影响（DP思想）

tip：乘法的lazy-tag一开始一定要设为1！！！

详细代码

#define USEFASTERREAD 1

#define rg register
#define inl inline
#define DEBUG printf("qwq\n")
#define DEBUGd(x) printf("var %s is %lld", #x, ll(x))
#define DEBUGf(x) printf("var %s is %llf", #x, double(x))
#define putln putchar('\n')
#define putsp putchar(' ')
#define Rep(a, s, t) for(rg int a = s; a <= t; a++)
#define Repdown(a, t, s) for(rg int a = t; a >= s; a--)
typedef long long ll;
typedef unsigned long long ull;
#include<cstdio>

#if USEFASTERREAD
char In[1 << 20], *ss = In, *tt = In;
#define getchar() (ss == tt && (tt = (ss = In) + fread(In, 1, 1 << 20, stdin), ss == tt) ? EOF : *ss++)
#endif
namespace IO {
	inl void RS() {freopen("test.in", "r", stdin), freopen("test.out", "w", stdout);}
	inl ll read() {
		ll x = 0, f = 1; char ch = getchar();
		for(; ch < '0' || ch > '9'; ch = getchar()) if(ch == '-') f = -1;
		for(; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + int(ch - '0');
		return x * f;
	}
	inl void write(ll x) {
		if(x < 0) {putchar('-'); x = -x;}
		if(x >= 10) write(x / 10);
		putchar(x % 10 + '0');
	}
	inl void writeln(ll x) {write(x), putln;}
	inl void writesp(ll x) {write(x), putsp;}
}
using namespace IO;
template<typename T> inline T Max(const T& x, const T& y) {return y < x ? x : y;}
template<typename T> inline T Min(const T& x, const T& y) {return y < x ? y : x;}
template<typename T> inline void Swap(T& x, T& y) {T tmp = x; x = y; y = tmp;}
template<typename T> inline T Abs(const T& x) {return x < 0 ? -x : x;}
#include <cstring>
#define Clear(arr) memset(arr, 0x00, sizeof arr)
const int MAXN = 1e5 + 5;
int n; ll P;
struct Segment_tree {
    #define ls o << 1
    #define rs o << 1 | 1
    int l[MAXN << 2], r[MAXN << 2];
    ll v[MAXN << 2], la[MAXN << 2], lm[MAXN << 2];

    void pushup(int o) {
        v[o] = (v[ls] + v[rs]) % P;
    }
    int len(int o) {return r[o] - l[o] + 1;}
    void pushdown(int o) {
        if(lm[o] != 1) {
            v[ls] = (v[ls] * lm[o]) % P;
            v[rs] = (v[rs] * lm[o]) % P;
            la[ls] = (la[ls] * lm[o]) % P;
            la[rs] = (la[rs] * lm[o]) % P;
            lm[ls] = (lm[ls] * lm[o]) % P;
            lm[rs] = (lm[rs] * lm[o]) % P;
            lm[o] = 1;
        }
        if(la[o]) {
            v[ls] = (v[ls] + la[o] * len(ls)) % P;
            v[rs] = (v[rs] + la[o] * len(rs)) % P;
            la[ls] = (la[ls] + la[o]) % P;
            la[rs] = (la[rs] + la[o]) % P;
            la[o] = 0;
        }
    }
    void build(int o, int L, int R, int a[]) {
        l[o] = L, r[o] = R; lm[o] = 1;
        if(L == R) {
            v[o] = a[L];
            return;
        }
        int m = (L + R) >> 1;
        build(ls, L, m, a);
        build(rs, m + 1, R, a);
        pushup(o);
    }
    void add(int o, int x, int y, ll k) {
        if(x <= l[o] && r[o] <= y) {
            v[o] = (v[o] + (k * len(o)) % P) % P;
            la[o] = (la[o] + k) % P;
            return;
        }
        pushdown(o);
        int m = (l[o] + r[o]) >> 1;
        if(x <= m) add(ls, x, y, k);
        if(y > m) add(rs, x, y, k);
        pushup(o);
    }
    void mul(int o, int x, int y, ll k) {
        if(x <= l[o] && r[o] <= y) {
            v[o] = (v[o] * k) % P;
            la[o] = (la[o] * k) % P;
            lm[o] = (lm[o] * k) % P;
            return;
        }
        pushdown(o);
        int m = (l[o] + r[o]) >> 1;
        if(x <= m) mul(ls, x, y, k);
        if(y > m) mul(rs, x, y, k);
        pushup(o);
    }
    ll sum(int o, int x, int y) {
        if(x <= l[o] && r[o] <= y) return v[o];
        pushdown(o);
        int m = (l[o] + r[o]) >> 1;
        ll ans = 0;
        if(x <= m) ans = (ans + sum(ls, x, y)) % P;
        if(y > m) ans = (ans + sum(rs, x, y)) % P;
        return ans;
    }
    Segment_tree() {
        Clear(l);
        Clear(r);
        Clear(v);
        Clear(la);
        Clear(lm);
    }
    #undef ls
    #undef rs
}tr;
int a[MAXN];
int M;
int main() {
	//RS();
    n = read(); P = read();
    Rep(i, 1, n) a[i] = read();
    M = read();
    tr.build(1, 1, n, a);
    while(M--) {
        int opt = read();
        int l = read(), r = read();
        if(opt == 1) {
            ll c = read();
            tr.mul(1, l, r, c);
        } else if(opt == 2) {
            ll c = read();
            tr.add(1, l, r, c);
        } else writeln(tr.sum(1, l, r));
    }

	return 0;
}

T3

题目链接

一本通高手训练：字符串排序

解题思路

我们一定要寻找一种高效的排序方式，使每次操作在 l o g log log级别。
于是我们就想到，我们只要维护区间内每个字符出现的次数，就可以根据这26个字母的顺序将这些次数重排。用线段树维护，每次操作时间复杂度为 O ( 26 ∗ l o g n ) O(26*logn) O(26∗logn)

详细代码

#define USEFASTERREAD 1

#define rg register
#define inl inline
#define DEBUG printf("qwq\n")
#define DEBUGd(x) printf("var %s is %lld", #x, ll(x))
#define DEBUGf(x) printf("var %s is %llf", #x, double(x))
#define putln putchar('\n')
#define putsp putchar(' ')
#define Rep(a, s, t) for(rg int a = s; a <= t; a++)
#define Repdown(a, t, s) for(rg int a = t; a >= s; a--)
typedef long long ll;
typedef unsigned long long ull;
#include<cstdio>

#if USEFASTERREAD
char In[1 << 20], *ss = In, *tt = In;
#define getchar() (ss == tt && (tt = (ss = In) + fread(In, 1, 1 << 20, stdin), ss == tt) ? EOF : *ss++)
#endif
namespace IO {
	inl void RS() {freopen("test.in", "r", stdin), freopen("test.out", "w", stdout);}
	inl ll read() {
		ll x = 0, f = 1; char ch = getchar();
		for(; ch < '0' || ch > '9'; ch = getchar()) if(ch == '-') f = -1;
		for(; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + int(ch - '0');
		return x * f;
	}
    inl char readc() {
        char ch = getchar();
        while(ch < 'a' || ch > 'z') ch = getchar();
        return ch;
    }
	inl void write(ll x) {
		if(x < 0) {putchar('-'); x = -x;}
		if(x >= 10) write(x / 10);
		putchar(x % 10 + '0');
	}
	inl void writeln(ll x) {write(x), putln;}
	inl void writesp(ll x) {write(x), putsp;}
}
using namespace IO;
template<typename T> inline T Max(const T& x, const T& y) {return y < x ? x : y;}
template<typename T> inline T Min(const T& x, const T& y) {return y < x ? y : x;}
template<typename T> inline void Swap(T& x, T& y) {T tmp = x; x = y; y = tmp;}
template<typename T> inline T Abs(const T& x) {return x < 0 ? -x : x;}
#include<cstring>
#define Clear(arr) memset(arr, 0x00, sizeof arr);
const int MAXN = 100005;

int n, m;
struct Segment_tree {
    #define ls o << 1
    #define rs o << 1 | 1
    int cnt[MAXN << 2][27];
    int l[MAXN << 2];
    int r[MAXN << 2];
    int la[MAXN << 2];
    void pushup(int o) {
        Rep(i, 1, 26) cnt[o][i] = cnt[ls][i] + cnt[rs][i];
    }
    void build(int o, int L, int R, char s[]) {
        l[o] = L, r[o] = R;
        if(L == R) {
            cnt[o][s[L] - 'a' + 1] = 1;
            return;
        }
        int m = (L + R) >> 1;
        build(ls, L, m, s);
        build(rs, m + 1, R, s);
        pushup(o);
    }
    int len(int o) {return r[o] - l[o] + 1;}
    void pushdown(int o) {
        if(la[o]) {
            Rep(i, 1, 26)
                cnt[ls][i] = cnt[rs][i] = 0;
            cnt[ls][la[o]] = len(ls);
            cnt[rs][la[o]] = len(rs);
            la[ls] = la[rs] = la[o];
            la[o] = 0;
        }
    }
    void modify(int o, int x, int y, int k) {
        if(x <= l[o] && r[o] <= y) {
            Rep(i, 1, 26) cnt[o][i] = 0;
            cnt[o][k] = len(o);
            la[o] = k;
            return;
        }
        pushdown(o);
        int m = (l[o] + r[o]) >> 1;
        if(x <= m) modify(ls, x, y, k);
        if(y > m) modify(rs, x, y, k);
        pushup(o);
    }
    void ask(int o, int x, int y, int t[]) {
        if(x <= l[o] && r[o] <= y) {
            Rep(i, 1, 26) t[i] += cnt[o][i];
            return;
        }
        pushdown(o);
        int m = (l[o] + r[o]) >> 1;
        if(x <= m) ask(ls, x, y, t);
        if(y > m) ask(rs, x, y, t);
    }
    void Write(int o) {
        if(l[o] == r[o]) {
            Rep(i, 1, 26)
                if(cnt[o][i]) {
                    putchar('a' + i - 1);
                    break;
                }
            return;
        }
        pushdown(o);
        Write(ls);
        Write(rs);
    }
    Segment_tree() {
        Clear(cnt);
        Clear(l);
        Clear(r);
        Clear(la);
    }
    #undef ls
    #undef rs
}tr;
char s[MAXN];
int t[MAXN];
int main() {
	//RS();
    n = read(), m = read();
    Rep(i, 1, n) s[i] = readc();
    tr.build(1, 1, n, s);
    while(m--) {

        int l = read(), r = read();
        int opt = read();
        Clear(t);
        tr.ask(1, l, r, t);
        int cup = l;
        if(opt == 1) {
            Rep(i, 1, 26)
                if(t[i]) {
                    tr.modify(1, cup, cup + t[i] - 1, i);
                    cup += t[i];
                }
        } else {
            Repdown(i, 26, 1)
                if(t[i]) {
                    tr.modify(1, cup, cup + t[i] - 1, i);
                    cup += t[i];
                }
        }
    }
    tr.Write(1);
	return 0;
}
线段树 例题
ZCY的博客
07-30 324
A - 敌兵布阵 C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地,Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚,每个工兵营地的人数都有可能发生变动，可能增加或减少若干人手,但这些都逃不过C国的监视。 中央情报局要研究敌人...
分块题解&线段树例题&树状数组例题详解
最新发布
Brilliant_Sky的博客
02-15 1516
分块是什么？详解！线段树和树状数组的例题？搞他！！
线段树习题集
天亮说晚安
02-17 3918
线段树习题集 大部分来源于@NotOnlySuccess  一、点修改 最最基础的线段树,只更新叶子节点,然后把信息用PushUp(int rt)这个函数更新上来 hdu1166 敌兵布阵 线段树功能:update:单点增减 query:区间求和 解题报告 hdu1754 I Hate It 线段树功能:update:单点替换 query:区间最值 解
线段树例题
Tom~~~
08-16 730
线段树是一种二叉搜索树，将原始数据都存在叶节点，依次表示出每个叶节点的根节点。 一般数组开到叶节点数量的4倍。 关于线段树的例题 。HDU1166 敌兵布阵 按照指示来就可以 代码 #include &lt;stdio.h&gt; #include &lt;algorithm&gt; #include &lt;iostream&gt; #include &lt;string&gt; u...
线段树的例题
默的博客
11-29 401
文章目录影子的宽度区间平方和问题：区间开根号问题stars逆序对 影子的宽度 题目描述 桌子上零散地放着若干个盒子，盒子都平行于墙。桌子的后方是一堵墙。如图所示。现在从桌子的前方射来一束平行光， 把盒子的影子投射到了墙上。问影子的总宽度是多少？ 输入 第1行：3个整数L，R，N。-100000 <=L<=R<= 100000，表示墙所在的区间；1<=N<=100000，表示盒子的个数 接下来N行，每行2个整数BL, BR，-100000 <=BL<=BR<=
线段树（例题）
CUCUC1的博客
07-11 250
线段树tq（巨佬太强了）l 题目链接 1、hdu1166敌兵布阵 最基础的线段树应用，这里没有用上区间修改，但是这个题可以当个板子 /*递归方法*/ #include <iostream> #include <cstring> #include <string> #include <cstdio> using namespace std; const int maxn = 50000 + 5;//元素总个数 int p[4 * maxn],add[4 *
可持久化线段树 基本原理与例题题解
SB_zero_mark的博客
11-15 296
可持久化线段树 它可以记录历史状态，对历史状态进行查询。 又名主席树。 因为线段树是从叶节点往上修改，而这个过程中只有修改一些节点，所以，别的节点可以不动。 可持久化线段树就是只对修改过的节点进行复制。别的节点保留不动。这样空间就不会炸。 如果复制一整棵树的话，空间复杂度是 O（n∗m)O（n*m)O（n∗m)。 图解： ...
线段树进阶-染色问题 附poj-2777题解
iwts
08-12 4969
区域染色覆盖问题 假设某大学有一面文化墙，各个学院都可以在上面涂色，要求涂色区域高必须和墙一样，宽度任意但必须是整数（以米为单位）。涂色可以覆盖其他学院的涂色。现在若干个学院涂色之后最终这面墙上能看见多少种颜色。 这就是简单的染色问题了。当然有很多种不同的说法，但整体上离不开这两个问题：1.区域覆盖。2.多种染色方式。既然是区域操作，那么用线段树是比较合理了。用...
线段树入门 + 例题
m0_61405003的博客
10-01 529
目录 一、线段树简介 1、导入线段树 2、线段树的常识 二、线段树的操作 1、建树 2、区间查询 3、区间修改 一、线段树简介 1、导入线段树 如题，已知一个数列，每次操作读入 X : X==1 将[L,R]区间每一个数加上k。 X==2 求出某区间每一个数的和。 这是洛谷的P3372，在你没学线段树之前，有两种很简单地方法： 方法一 方法二 名称 暴力 前缀和 区间加 k 1 R...
神马？是线段树！详解+例题：【线段树】最大值
QAQ54188的博客
08-02 487
首先，线段树，你细品…… em…… 首先，线段树的作用是神马？ 就是找一个区间内的最大值。 “那不是有手就行？” 但是，要替换！ 就像这道非常BT的1.1.1例题： 在N（1<=N<=100000）个数A1…An组成的序列上进行M(1<=M<=100000)次操作，操作有两种： (1)1 x y：表示修改A[x]为y； (1)2 x y：询问x到y之间的最大值。 输入 第一行输入N(1<=N<=100000)，表示序列的长度，接下来N行输入原始序列；接下来一行输入M(1&
线段树例题分析——————
05-31
几个方便理解的线段树例子··················
线段树的各种题目
A_Thinking_Reed_的博客
03-16 832
目录 类型：单点更新、区间查询 题目：敌兵布阵——https://vjudge.net/contest/285952#problem/A 题目：I hate it——https://vjudge.net/contest/285952#problem/B 题目：Balanced Lineup——https://vjudge.net/contest/285952#problem/E 类型...
【例题】【线段树】
ANG
07-08 1152
NKOJ 1321 数列操作问题 时间限制 : 10000 MS 空间限制 : 165536 KB 问题描述 假设有一列数{Ai}(1≤i≤n)，支持如下两种操作： 将Ak的值加D。（k, D是输入的数） 输出As+As+1+…+At。（s, t都是输入的数，S≤T）输入格式 第一行一个整数n， 第二行为n个整数，表示{Ai}的初始值≤10000。 第三行为一个整数m
线段树练习一 题解
Y的博客
08-09 174
线段树练习一 题解 线段树练习一 题目 桌子上零散地放着若干个盒子，桌子的后方是一堵墙。如右图所示。现在从桌子的前方射来一束平行光， 把盒子的影子投射到了墙上。问影子的总宽度是多少？ 样例 input 20 //桌面总宽度 4 //盒子数量 1 5 3 8 7 10 13 19 output 15 数据范围 1<=nnn<=100000,1<=mmm<=100000,保证坐标范围为[1,nnn]. 代码 #include<iostream> #inclu
线段树及经典习题
weixin_42034081的博客
04-04 1188
线段树（Segment Tree） 首先我们知道二叉树，balanced 二叉树可以保证查找的复杂度是logn的复杂度。理解起来十分直观：大概这样子： 如你所见，底层的就是单个的元素，每往上走一层，就会根据底层的元素做一个范围查询（rangeQuery）操作，这个操作可以是求和，求最小，求最大，同时上一层就会cover all the union of the children's range there are four operations in total: build(start,e
蓝桥杯 操作格子（线段树例题）
sinat_37478202的博客
04-08 369
http://www.tudou.com/programs/view/ek_xh3IaBWw/?qq-pf-to=pcqq.group 线段树视频讲解 http://blog.csdn.net/x314542916/article/details/7837276 博客讲解 #include int Testmax(int a,int b)//判断大小的函数 {return a>b?a:
Go语言编程：2000题助你从初学者到专家
- 线段树（Segment Tree）：掌握线段树的数据结构及其在解决区间查询和更新问题中的应用。 - 滑动窗口（Sliding Window）：学习滑动窗口技术在处理字符串和数组问题中的应用。 - 排序（Sort）：掌握Go语言内置的排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

日居月诸Rijuyuezhu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值