一篇文章学会树套树（禁止套娃）

已于 2023-04-27 19:20:30 修改
阅读量962 收藏 9
点赞数 1
分类专栏： # 算法学习笔记 文章标签： 数据结构 算法 c++ 学习
于 2023-04-10 11:29:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/GROZAX/article/details/129978379
版权

树套树并不是一个新的数据结构，它是由我们已经学过的数据结构，如线段树、平衡树、树状数组等相互结合而成，难度并不高，重点在于编码。由于是多个数据结构结合，所以对模板的运用需要达到融会贯通的程度。如果还不会一些基础的数据结构，建议先学习基础数据结构后再战。

首先看一道用STL处理的问题，来初步理解一下树套树的思想：（Acwing2488)

不难看出这是一题单点修改、区间查询的问题，用线段树维护这个序列可以达到O(nlogn)的复杂度，但是这个区间查询似乎有些不一样——查询某个数的前驱，这意味着如果仅仅是简单的线段树维护，查询的复杂度将最坏达到查询整个区间找前驱的O(n^2logn)的复杂度。可以考虑将原线段树中的每个子区间改成set，set查询一个数的前缀的复杂度为O(logn)，这样以来总复杂度将控制在O(nlog^2n)。

那么线段树节点可以改成这样：

struct node {
    int l, r;
    multiset<int> s;
}tr[N * 4];

建树的时候我们可以在set中插入两个哨兵INF和-INF，这样可以保证一定可以查询到某个数的前驱


void build(int u, int l, int r) {
    tr[u] = {l, r};
    tr[u].s.insert(INF); tr[u].s.insert(-INF);
    for (int i = l; i <= r; i++) tr[u].s.insert(num[i]);
    if (l == r) return;
    int mid = l + r >> 1;
    build(u << 1, l, mid); build(u << 1 | 1, mid + 1, r);
}

那么修改某个数的时候，我们可以通过set的删除（erace）添加（insert）函数完成

void modify(int u, int p, int x) {
    tr[u].s.erase(tr[u].s.find(num[p]));
    tr[u].s.insert(x);
    if (tr[u].l == tr[u].r) return;
    int mid = tr[u].l + tr[u].r >> 1;
    if (p <= mid) modify(u << 1, p, x);
    else modify(u << 1 | 1, p, x);
}

查询某个数的时候可以通过set的内置函数low_bound二分查找某个数的前驱

int query(int u, int l, int r, int x) {
    if (tr[u].l >= l && tr[u].r <= r) {
        auto it = tr[u].s.lower_bound(x);
        --it;
        return *it;
    }
    int mid = tr[u].l + tr[u].r >> 1, res = -INF;
    if (mid >= l) res = max(res, query(u << 1, l, r, x));
    if (mid < r) res = max(res, query(u << 1 | 1, l, r, x));
    return res;
}

这样即可完成题目所需要求。

最后附上主函数

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> num[i];
    build(1, 1, n);
    while (m--) {
        int op;
        cin >> op;
        if (op == 1) {
            int p, x;
            cin >> p >> x;
            modify(1, p, x);
            num[p] = x;
        }
        else {
            int l, r, x;
            cin >> l >> r >> x;
            cout << query(1, l, r, x) << endl;
        }
    }
    return 0;
}

看完这题之后想必你对树套树的思想有一个大概的了解了，但是并不是每题都可以通过STL来节省代码量的，如果遇到大量需要手动维护的节点信息，还是手写数据结构比较好，例如（洛谷P3380二逼平衡树）：

 首先观察到总体是一个区间查询和单点修改的问题，考虑用线段树维护整个序列，再观察每一个查询操作，需要找前驱、后继和排名，可以考虑用平衡树来维护，那么我们可以将每一个线段树的节点替换成一棵splay树，便于维护每个数的排名和前后继。

通过splay一章的学习我们知道查询某个数的排名可以用get_k函数得到，但是如何得到区间内的排名是谁呢？观察到排名是一个连续的单调递增区间，如果我们任取某个数查询排名，可以知晓我们查询的这个数相较于要查的结果是满足大小关系的，整体满足二段性，可以用二分来查找。

其他操作不难，与基础知识一致。

小tips：树套树的函数众多，要同时写出线段树和splay两个数据结构大户的所有函数，这里建议先将所有函数声明，再写函数就不用考虑先后顺序了。

附代码：

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 2000010, INF = 1e9;

struct node {
    int s[2], p, v;
    int size;
    void init(int _v, int _p) {
        v = _v; p = _p;
        size = 1;
    }
}tr[N];
int L[N], R[N], T[N], w[N];
int n, m, idx;

void pushup(int u);
void rotate(int x);
void splay(int &root, int x, int k);
void insert(int& root, int v);
int get_k(int root, int x);
void update(int &root, int x, int y);
void build(int u, int l, int r);
int query(int u, int l, int r, int x);
void modify(int u, int p, int x);
int get_suc(int root, int x);
int query_suc(int u, int l, int r, int x);
int get_pre(int root, int x);
int query_pre(int u, int l, int r, int x);

void pushup(int u) {
    tr[u].size = tr[tr[u].s[0]].size + tr[tr[u].s[1]].size + 1;
}

void rotate(int x) {
    int y = tr[x].p, z = tr[y].p;
    int k = tr[y].s[1] == x;
    tr[z].s[tr[z].s[1] == y] = x; tr[x].p = z;
    tr[y].s[k] = tr[x].s[k ^ 1]; tr[tr[x].s[k ^ 1]].p = y;
    tr[x].s[k ^ 1] = y; tr[y].p = x;
    pushup(y); pushup(x);
}

void splay(int &root, int x, int k) {
    while (tr[x].p != k) {
        int y = tr[x].p, z = tr[y].p;
        if (z != k) {
            if ((tr[y].s[1] == x) ^ (tr[z].s[1] == y)) rotate(x);
            else rotate(y);
        }
        rotate(x);
    }
    if (!k) root = x;
}

void insert(int& root, int v) {
    int u = root, p = 0;
    while (u) p = u, u = tr[u].s[tr[u].v < v];
    u = ++idx;
    if (p) tr[p].s[tr[p].v < v] = u;
    tr[u].init(v, p);
    splay(root, u, 0);
}

int get_k(int root, int x) { //查找平衡树root的x的排名
    int u = root, res = 0;
    while (u) {
        if (tr[u].v < x) res += tr[tr[u].s[0]].size + 1, u = tr[u].s[1];
        else u = tr[u].s[0];
    }
    return res;
}

void update(int &root, int x, int y) {
    int u = root;
    while (u) {
        if (tr[u].v == x) break;
        u = tr[u].s[tr[u].v < x];
    }
    splay(root, u, 0);
    int l = tr[u].s[0], r = tr[u].s[1];
    while (tr[l].s[1]) l = tr[l].s[1];
    while (tr[r].s[0]) r = tr[r].s[0];
    splay(root, l, 0); splay(root, r, l);
    tr[r].s[0] = 0;
    pushup(r); pushup(l);
    insert(root, y);
}

void build(int u, int l, int r) {
    L[u] = l; R[u] = r;
    insert(T[u], -INF); insert(T[u], INF);
    for (int i = l; i <= r; i++) insert(T[u], w[i]);
    if (l == r) return;
    int mid = l + r >> 1;
    build(u << 1, l, mid); build(u << 1 | 1, mid + 1, r);
}

int query(int u, int l, int r, int x) { //查询区间[l, r]里x的排名
    if (L[u] >= l && R[u] <= r) return get_k(T[u], x) - 1;
    int res = 0, mid = L[u] + R[u] >> 1;
    if (l <= mid) res += query(u << 1, l, r, x);
    if (r > mid) res += query(u << 1 | 1, l, r, x);
    return res;
}

void modify(int u, int p, int x) {
    update(T[u], w[p], x);
    if (L[u] == R[u]) return;
    int mid = L[u] + R[u] >> 1;
    if (p <= mid) modify(u << 1, p, x);
    else modify(u << 1 | 1, p, x);
}

int get_suc(int root, int x) {
    int u = root, res = INF;
    while(u) {
        if (tr[u].v > x) res = min(res, tr[u].v), u = tr[u].s[0];
        else u = tr[u].s[1];
    }
    return res;
}

int get_pre(int root, int x) {
    int u = root, res = -INF;
    while(u) {
        if (tr[u].v < x) res = max(res, tr[u].v), u = tr[u].s[1];
        else u = tr[u].s[0];
    }
    return res;
}

int query_pre(int u, int l, int r, int x) {
    if (L[u] >= l && R[u] <= r) return get_pre(T[u], x);
    int mid = L[u] + R[u] >> 1, res = -INF;
    if (l <= mid) res = max(res, query_pre(u << 1, l, r, x));
    if (r > mid) res = max(res, query_pre(u << 1 | 1, l, r, x));
    return res;
}

int query_suc(int u, int l, int r, int x) {
    if (L[u] >= l && R[u] <= r) return get_suc(T[u], x);
    int mid = L[u] + R[u] >> 1, res = INF;
    if (l <= mid) res = min(res, query_suc(u << 1, l, r, x));
    if (r > mid) res = min(res, query_suc(u << 1 | 1, l, r, x));
    return res;
}


int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
    build(1, 1, n);

    while (m--) {
        int op, a, b, x;
        scanf("%d", &op);
        if (op == 1) {
            scanf("%d%d%d", &a, &b, &x);
            printf("%d\n", query(1, a, b, x) + 1);
        }
        else if (op == 2)
        {
            scanf("%d%d%d", &a, &b, &x);
            int l = 0, r = 1e8;
            while (l < r)
            {
                int mid = l + r + 1 >> 1;
                if (query(1, a, b, mid) + 1 <= x) l = mid;
                else r = mid - 1;
            }
            printf("%d\n", r);
        }
        else if (op == 3)
        {
            scanf("%d%d", &a, &x);
            modify(1, a, x);
            w[a] = x;
        }
        else if (op == 4)
        {
            scanf("%d%d%d", &a, &b, &x);
            printf("%d\n", query_pre(1, a, b, x));
        }
        else
        {
            scanf("%d%d%d", &a, &b, &x);
            printf("%d\n", query_suc(1, a, b, x));
        }
    }
    return 0;
}

最后再来看一条线段树套线段树的题目：

这题虽短，但涉及的知识点还是很多的，离散化、权值线段树、动态开点、标记持久化等，我们依次分析。

首先我们分析一下操作类型，第一个操作是区间修改，如果把每个位置看作集合，那么就是在一段连续的集合里同时加上一个数，第二个操作是区间查询，那么考虑线段树维护查询操作，内层的树如果用平衡树的话，那么对于集合的维护就很复杂，所以我们可以把外层的树设置为权值线段树。（因为权值的范围为1<<31，而点点个数最多只有50000，所以需要离散化一下。）

权值线段树和线段树维护的东西刚好相反，线段树是建立在下标上的，维护的是每个下标有哪些权值，而权值线段树是建立在权值（数轴）上的，维护的是每个权值在哪些下标里。那么对于第一个操作，线段树上是在一段连续的下标里加上一个权值c，在权值线段树里就是在权值为c的地方加上一段连续的下标。此时的区间修改就变成了单点修改，对于权值c，我们最多修改logn层权值线段树即可。

由于权值线段树里的每个节点都是一棵普通线段树，用来维护下标的修改，所以每执行一次第一个操作，我们就在内层的线段树的a-b所在的位置加上1，这个操作可以用懒标记来维护。

而对于内层的线段树来说，需要维护的操作只有add一个，所以我们可以用一个标记持久化的思想，把add作为线段树的自身属性，这样就不用每次都pushdown操作了，可以节省不少时间。

再其次由于线段树的空间占用非常之大，但是利用率并不高，并且有的节点用过一次之后就不会再被使用了，所以我们可以动态开点，用一个数组存储下所有的节点，相当于节点分配站，当我需要的时候再给他分配。

最后附上完整代码

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

using namespace std;

typedef long long LL;

const int N = 50010, P = N * 17 * 17, M = N * 4;

int n, m;
struct Tree
{
    int l, r;
    LL sum, add;
}tr[P];
int L[M], R[M], T[M], idx;
struct Query
{
    int op, a, b, c;
}q[N];
vector<int> nums;

int get(int x)
{
    return lower_bound(nums.begin(), nums.end(), x) - nums.begin();
}

void build(int u, int l, int r)
{
    L[u] = l, R[u] = r, T[u] = ++ idx;
    if (l == r) return;
    int mid = l + r >> 1;
    build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
}

int intersection(int a, int b, int c, int d)
{
    return min(b, d) - max(a, c) + 1;
}

void update(int u, int l, int r, int pl, int pr)
{
    tr[u].sum += intersection(l, r, pl, pr);
    if (l >= pl && r <= pr)
    {
        tr[u].add ++ ;
        return;
    }
    int mid = l + r >> 1;
    if (pl <= mid)
    {
        if (!tr[u].l) tr[u].l = ++ idx;
        update(tr[u].l, l, mid, pl, pr);
    }
    if (pr > mid)
    {
        if (!tr[u].r) tr[u].r = ++ idx;
        update(tr[u].r, mid + 1, r, pl, pr);
    }
}

void change(int u, int a, int b, int c)
{
    update(T[u], 1, n, a, b);
    if (L[u] == R[u]) return;
    int mid = L[u] + R[u] >> 1;
    if (c <= mid) change(u << 1, a, b, c);
    else change(u << 1 | 1, a, b, c);
}

LL get_sum(int u, int l, int r, int pl, int pr, int add)
{
    if (l >= pl && r <= pr) return tr[u].sum + (r - l + 1LL) * add;
    int mid = l + r >> 1;
    LL res = 0;
    add += tr[u].add;
    if (pl <= mid)
    {
        if (tr[u].l) res += get_sum(tr[u].l, l, mid, pl, pr, add);
        else res += intersection(l, mid, pl, pr) * add;
    }
    if (pr > mid)
    {
        if (tr[u].r) res += get_sum(tr[u].r, mid + 1, r, pl, pr, add);
        else res += intersection(mid + 1, r, pl, pr) * add;
    }
    return res;
}

int query(int u, int a, int b, int c)
{
    if (L[u] == R[u]) return R[u];
    int mid = L[u] + R[u] >> 1;
    LL k = get_sum(T[u << 1 | 1], 1, n, a, b, 0);
    if (k >= c) return query(u << 1 | 1, a, b, c);
    return query(u << 1, a, b, c - k);
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i ++ )
    {
        scanf("%d%d%d%d", &q[i].op, &q[i].a, &q[i].b, &q[i].c);
        if (q[i].op == 1) nums.push_back(q[i].c);
    }
    sort(nums.begin(), nums.end());
    nums.erase(unique(nums.begin(), nums.end()), nums.end());

    build(1, 0, nums.size() - 1);

    for (int i = 0; i < m; i ++ )
    {
        int op = q[i].op, a = q[i].a, b = q[i].b, c = q[i].c;
        if (op == 1) change(1, a, b, get(c));
        else printf("%d\n", nums[query(1, a, b, c)]);
    }

    return 0;
}

浅谈树套树(线段树套平衡树)&学习笔记
dingzongdu1901的博客
01-22 1014
0XFF 前言 *如果本文有不好的地方，请在下方评论区提出，Qiuly感激不尽！ 0X1F 这个东西有啥用? 树套树------线段树套平衡树，可以用于解决待修改区间\(K\)大的问题，当然也可以用 树套树------树状数组套可持久化线段树，但是 线段树套平衡树 更加容易理解，更加便于新手理解，所以一般也作为树套树的入门类别。 对于静态区间\(K\)大，我们可以用小巧精悍的主席树...
BuuCTF [GXYCTF2019]禁止套娃详解（两种方法）
2301_76690905的博客
10-28 887
点入题目没有提示，常规抓包看源码扫目录，用dirsearch扫目录的时候扫出git第一眼看见第二个if语句，if(';R)?\)/', NULL, $_GET['exp']))可以看出这是典型的无参数rce,然后是后面的if (!preg_match('/et|na|info|dec|bin|hex|oct|pi|log/i', $_GET['exp'])，这里限制了phpinfo()，getcwd()这些函数用不了。
【以前的空间】树套树入门总结
weixin_33755554的博客
03-02 218
树套树 名字看上去很高端很酷炫，其实不难，说白了就是树上建树。什么是树上建树？比如一个区间【1，5】，那么建成线段树就有【1，5】【1，3】【4，5】【1，2】【3】【4】【5】【1】【2】这么多个节点，现在我们把这个节点都变成一棵树（平衡树或者线段数），然后把区间内每个点都上入这个平衡树中，比如【1，3】，那么我们就把【1，3】里面三个数都加到一棵平衡树中，这样就可以直接得到【1，3】中每个树...
树套树 初步
qq_56326461的博客
07-24 837
树套树，顾名思义是将如 线段树、树状数组、平衡树 等树形数据结构结合起来，以实现更复杂的信息的维护。
[学习笔记]树套树
weixin_34068198的博客
11-23 578
说白了，就是在一个树形数据结构上，每个点不再是一个节点，而是另外一个树形数据结构。 空间时间复杂度大多数都是O(nlogn) 线段树套平衡树 许多树套树都可以用线段树套平衡树解决。 空间O(nlogn)是很可观的。 各种区间找值的问题，可以游刃有余解决。 （虽然常数比较大） 例如模板： 【模板】二逼平衡树（树套树） 下标线段树里套权值平衡树 线段树节点O(4*N) 平衡...
树套树
MachoMan_1069的博客
04-01 255
前言： 什么，你说线段树码量大？那来写平衡树吧~~~ 什么，你又说平衡树码量大？那来写树套树吧~~~ 如果你想，可以将以前学过的数据结构自由组合一下 不过经常会用到的只有两种——线段树套平衡树和树状数组套主席树 正文： 线段树套平衡树 假设你对平衡树的各种操作已经很熟练了（你为什么那么熟练~~~） 那么如果要你写一种数据结构支持查询区间排名，区间前驱，区间后继等 你会怎...
I. Yukino With Subinterval 树套树入门题
qq_44335608的博客
10-22 193
I. Yukino With Subinterval 题意：有两种操作，第一种修改一个位置的值，第二种求给定区间[l,r]内有多少合法区间。合法区间定义：al = al+1 = … = ar ,且该区间为最长。 题解：如果这题不带修改，主席树就写完了。那么带修改动态开点线段树套树状数组。 注意：这题卡常，需要快读。 #include<bits/stdc++.h> #define m (...
buuctf-[GXYCTF2019]禁止套娃
qq_42728977的博客
12-24 3896
[GXYCTF2019]禁止套娃考点复现法一：单纯构造GET参数法二：构造session组合拳参考 考点 正则表达、无参数rce、git泄露 复现 法一：单纯构造GET参数 打开就一句 然后查看源码，空空如也。想到扫描后台文件，使用御剑很慢，使用dirsearch，一直429，查找资料，加了-s参数，也就是扫描不能太快。 python3 .\dirsearch.py -u http://5c0edec0-316a-4de9-999a-669f813c771b.node4.buuoj.cn:81/ -e
[GXYCTF2019]禁止套娃
box
10-20 340
这题多少有点变态 首先是 git源码泄露，使用 lijiejie的 GitHack.py 获取 .git源码 python2 GitHack.py http://b83677d6-46c1-46e1-b740-8dc6102420b6.node4.buuoj.cn/.git index.php 代码分析一波 <?php include "flag.php"; echo "flag在哪里呢？<br>"; if(isset($_GET['exp'])){ if (!preg_ma
禁止套娃？嘿嘿，用Python写一个文字套娃的程序
qq_46614154的博客
05-18 707
前言 本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理。 对于俄罗斯套娃 ，大家想必都了解，说白了就是一层层的嵌套，大的里面套着小的，就像下面的图一样。 虽然小编无法教给大家如何制作俄罗斯套娃，但是小编可以教给大家如何使用python来制作文字套娃，今天，小编就通过面向对象编程的方式，带领大家编写一个文字套娃的程序。 01.原理解释 首先，我们要理解，如何实现文字的套娃呢，我们知道，每一张图片都是由像素构成的...
树套树数据结构从入门到精通
10-16
树套树数据结构从入门到精通,包教包会树套树就是你有一种树形数据结构，它的每个节点也是一颗树形的数据结构。
【学习笔记3】buu [GXYCTF2019]禁止套娃
weixin_43553654的博客
05-08 402
知识点：1. /.git泄露2.无参数RCE3.各种php函数的使用解题 首先登录进去后发现什么都没有，查看源码，抓包也什么都没信息，去瞄了一眼大佬的wp知道了这是.git文件泄露从而导致的源码的泄露，不过别人是用扫描器跑出来的，可是我试了一试，因为我请求的次数太多，什么都没有跑出来。不过知道后就可以用Githack脚本跑了，这个脚本是python2环境，可以放在kali下跑，命令就是p...
初学树套树：线段树套Treap
CXR的博客
10-06 632
前言 树套树是一个十分神奇的算法，种类也有很多：像什么树状数组套主席树、树状数组套值域线段树、zkwzkwzkw线段树套vectorvectorvector等等。 不过，像我这么弱，当然只会最经典的 线段树套TreapTreapTreap 啦。 LinkLinkLink TreapTreapTreap 详见博客 简析平衡树（二）——Treap 基本思想 线段树套TreapTreapTreap...
树套树学习
Step by step
11-28 439
标题扯的有点宽泛，树套树分很多种吧，会慢慢学习下，然后学习笔记会更新到这里(立flag 中。。。)线段树套树状数组从这个题 “Dynamic” Inversion 说起吧！就是求动态逆序对，比较经典的问题，解法也比较多。（博主偷懒中。。。。）
Luck and Love(树套树)
Fau的博客
05-08 188
题目链接: Luck and Love 大致题意 解题思路 区间线段树 套 区间线段树 首先提一下这个题注意的点, H1和H2 以及 A1和A2的大小是没有指定的, 需要判断. 其次题目数据中说L的范围是[0.0, 100.0], 但是实际上好像不存在等于0的情况. 因为我用0作为未找到的值时, 最后查询判断是否为0也可以AC. 原来二维线段树就是树套树啊 回归正题, 题目中要求在[h1, h2] 且 [a1, a2]的区间中找到最大值, 那么我们如果任意去掉一个条件, 发现就是个RMQ. 但是由于还多了一
树套树浅谈
weixin_30443747的博客
05-26 167
今天来说一下线段树套Splay。顺便我也来重新敲一遍模板。 首先，明确一下Splay套线段树用来处理什么问题。它可以支持：插入x，删除x，单点修改，查询x在区间[l,r]的排名，查询区间[l,r]中排名为k的数，以及一个数在区间[l,r]中的前驱，后继。（应该还可以查询区间和等东西，还没写过） 其实它的常数非常大，但是这是树套树中最容易理解的一种。 首先，我们知道，对于一个区间，我们给它建一...
算法笔记：树套树（树状数组套主席树+线段树套平衡树）
I1I1I11I1I1的博客
02-27 3303
从我短暂的ACMer生涯当中学到一件事———越是玩弄数据结构，就越会发现树的能力是有极限的… 除非超越树。 那就再套一层树！Wryyyyy！！！ 最近打算研究一波树套树，平衡树怎么套还没搞懂，目前学习了一点套主席树的方法，平衡树的内容可能也会补在这吧。 ...
写一个解压套娃压缩包的python脚本
最新发布
11-29
下面是一个简单的脚本示例，它递归地解压所有嵌套的ZIP文件： ```python import os import zipfile def extract_nested_zip(input_zip, output_dir): if not os.path.exists(output_dir): os.makedirs(output_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值