2023CCPC东北四省赛题解

原创 已于 2025-05-22 20:44:07 修改 · 828 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #数据结构 #c++ #xcpc

于 2025-05-22 20:42:32 首次发布
K. The Secret Comparison

签到题，比大小。

#include <bits/stdc++.h>
#define x first
#define y second
#define int long long

using namespace std;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int N = 1000010, M = N * 2, mod = 1e9 + 7, P = 131;
int n, a, b, c;

void solve()
{
    int a, b;
    cin >> a >> b;
    if (a > b)
        cout << "orz teralem is the king!";
    else if (a == b)
        cout << "even even seven EIeven.";
    else
        cout << "orz overflowker is the king!";
}

signed main()
{
    std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int t = 1;
    // cin >> t;
    while (t--)
        solve();
    return 0;
}
A. Cask Effect

木桶原理，给n块木板从其中一块切下来一段给另一块，最小值最大是多少。
先排序，用最大的给最小的补最优。

#include <bits/stdc++.h>
#define x first
#define y second
#define int long long

using namespace std;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int N = 100010, M = N * 2, mod = 1e9 + 7, P = 131;
int n;
double a[N];

void solve()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    sort(a + 1, a + n + 1);
    if (n == 1)
    {
        printf("%.1lf\n", a[1]);
    }
    else if (n == 2)
    {
        printf("%.1lf\n", (a[1] + a[2]) / 2.0);
    }
    else {
        if((a[1] + a[n]) >= a[2] * 2) {
            printf("%.1lf\n", a[2]);
        }
        else {
            printf("%.1lf\n", (a[1] + a[n]) / 2.0);
        }
    }
}

signed main()
{
    // std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int t = 1;
    // cin >> t;
    while (t--)
        solve();
    return 0;
}
M. Easy Problem of Prime

f[i]f[i]f[i]表示iii最少由多少个质数组成，让我们求∑2nf[i]\sum_{2}^{n}f[i]∑2n​f[i]。
首先求f[i]f[i]f[i]，如果i是质数，f[i]=1f[i]=1f[i]=1，根据哥德巴赫猜想，如果i是偶数，f[i]=2f[i]=2f[i]=2，那么如果i是奇数并且不是偶数呢，我们可以把他拆成奇质数+偶数，f[i]=3f[i]=3f[i]=3。问题解决，线性筛+前缀和。

#include <bits/stdc++.h>
#define x first
#define y second
#define int long long

using namespace std;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int N = 10000010, M = N * 2, mod = 1e9 + 7, P = 131;
int p[N], cnt, f[N];
bool st[N];

void init()
{
    for (int i = 2; i <= N - 10; i++)
    {
        if (!st[i])
            p[cnt++] = i;
        for (int j = 0; p[j] * i <= N - 10; j++)
        {
            st[p[j] * i] = true;
            if (i % p[j] == 0)
                break;
        }
    }
    for (int i = 2; i <= N - 10; i++)
    {
        if (!st[i])
            f[i] = f[i - 1] + 1;
        else if (i % 2 == 0)
            f[i] = f[i - 1] + 2;
        else if (!st[i - 2])
            f[i] = f[i - 1] + 2;
        else
            f[i] = f[i - 1] + 3;
    }
}
void solve()
{
    int x;
    cin >> x;
    cout << f[x] << "\n";
}

signed main()
{
    std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int t = 1;
    init();
    cin >> t;
    while (t--)
        solve();
    return 0;
}
I. Subsetting and Summing

题意是说给n个向量(x1,x2,x3)(x_1,x_2,x_3)(x1​,x2​,x3​)，让你从中选取几个组成新的向量y=(y1,y2,y3)y=(y_1,y_2,y_3)y=(y1​,y2​,y3​)，求∣y1∣+∣y2∣+∣y3∣|y_1|+|y_2|+|y_3|∣y1​∣+∣y2​∣+∣y3​∣的最大值。
看上去毫无头绪，因为我们不知道对于每个向量来说具体每个位置的贡献。但我们可以枚举啊，我们枚举最终答案每一位上的正负情况，这样就可以计算每个向量的贡献了。

#include <bits/stdc++.h>
#define x first
#define y second
#define int long long

using namespace std;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int N = 10000010, M = N * 2, mod = 1e9 + 7, P = 131;
int n;
vector<vector<int>> q;

int check(int a, int b, int c)
{
    int res = 0;
    vector<int> t;
    for (int i = 0; i < n; i++)
    {
        int s = 0;
        if (a)
            s += q[i][0];
        else
            s -= q[i][0];
        if (b)
            s += q[i][1];
        else
            s -= q[i][1];
        if (c)
            s += q[i][2];
        else
            s -= q[i][2];
        t.push_back(s);
    }
    sort(t.begin(), t.end(), greater<int>());
    for (int i = 0; i < t.size(); i++)
        if (t[i] > 0)
            res += t[i];
    return res;
}
void solve()
{
    cin >> n ;
    for (int i = 0; i < n; i++)
    {
        int x, y, z;
        cin >> x >> y >> z;
        q.push_back({x, y, z});
    }
    int res = 0;
    res = max({res, check(1, 1, 1), check(1, 1, 0), check(1, 0, 1), check(0, 1, 1)});
    res = max({res, check(1, 0, 0), check(0, 1, 0), check(0, 0, 1), check(0, 0, 0)});
    cout << res << "\n";
}

signed main()
{
    std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int t = 1;
    // cin >> t;
    while (t--)
        solve();
    return 0;
}
H. Light the Street

由数学知识推结论：两个灯中间和两个端点最暗，那么当这两个地方相等的时候最小亮度最高。假设两个灯之间是xxx，端点距离第一个灯是yyy，得到2dx22=dy2\frac{2d}{\frac{x}{2}^2} =\frac{d}{y^2}2x​22d​=y2d​，得到y=2x4y=\frac{\sqrt{2}x}{4}y=42​x​，(k−1)x+2∗y=n(k-1)x+2*y=n(k−1)x+2∗y=n。求出xxx后也就能得出亮度了。

#include <bits/stdc++.h>
#define x first
#define y second
#define int long long

using namespace std;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int N = 10000010, M = N * 2, mod = 1e9 + 7, P = 131;
double n, k, d;

void solve()
{
    scanf("%lf%lf%lf", &n, &k, &d);
    double x = n / (k - 1 + (sqrt(2) / 2.0));
    double res = 2 * d / ((x / 2.0) * (x / 2.0));
    printf("%.6lf\n", res);
}

signed main()
{
    // std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
        solve();
    return 0;
}
G. Expected Sum

递推，最后一位的贡献一定是s[n]，倒数第二位的贡献则可能是s[n−1]∗p[n−1]/100+s[n−1]∗(1−p[n−1])/10s[n-1]*p[n-1]/100+s[n-1]*(1-p[n-1])/10s[n−1]∗p[n−1]/100+s[n−1]∗(1−p[n−1])/10，一步步推就可以发现每一位的贡献，需要注意的时这里有分数需要用到逆元。

#include <bits/stdc++.h>
#define x first
#define y second
#define int long long

using namespace std;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int N = 2000010, M = N * 2, mod = 998244353, P = 131;
int n;
string s;
int p[N];

int qmi(int a, int k)
{
    int res = 1;
    while (k)
    {
        if (k & 1)
            res = res * a % mod;
        a = a * a % mod;
        k >>= 1;
    }
    return res;
}
void solve()
{
    cin >> n >> s;
    s = " " + s;
    for (int i = 1; i <= n - 1; i++)
        cin >> p[i];
    int res = (s[n] - '0'), u = 1;
    for (int i = n - 1; i >= 1; i--)
    {
        u = (u * (100 - p[i])) % mod * qmi(10, mod - 2) % mod;
        u = (u + p[i] * qmi(100, mod - 2) % mod) % mod;
        res = (res + (s[i] - '0') * u % mod) % mod;
    }
    cout << res << "\n";
}

signed main()
{
    // std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int t = 1;
    // cin >> t;
    while (t--)
        solve();
    return 0;
}
D. Concrete Painting

实际上这道题目还是从贡献入手，一段区间对答案的贡献就是(2x−1)∗(2n−x)(2^x-1)*(2^{n-x})(2x−1)∗(2n−x)，x是覆盖这个一段区间的线段数量。只有都不选这段的时候才没有贡献，所以是(2x−1)(2^x-1)(2x−1)，选了的情况，只跟不覆盖这段的线段有关，也就是(2n−x)(2^{n-x})(2n−x)。方法有了现在只需要离散化+逆元就可以解决。

#include <bits/stdc++.h>
#define x first
#define y second
#define int long long

using namespace std;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int N = 6000010, M = N * 2, mod = 998244353, P = 131;
int n, cnt, res;
vector<PII> q;
int s[N];

int qmi(int a, int k)
{
    int sum = 1;
    while (k)
    {
        if (k & 1)
            sum = sum * a % mod;
        a = a * a % mod;
        k >>= 1;
    }
    return sum;
}
void solve()
{
    cin >> n;
    vector<int> u;
    for (int i = 1; i <= n; i++)
    {
        int x, y;
        cin >> x >> y;
        q.push_back({x, y});
        u.push_back(x), u.push_back(y);
        u.push_back(y + 1);
    }
    sort(u.begin(), u.end());
    map<int, int> mp, ump;
    for (int i = 0; i < u.size(); i++)
        if (!mp.count(u[i]))
        {
            mp[u[i]] = ++cnt;
            ump[cnt] = u[i];
        }
    for (int i = 0; i < n; i++)
    {
        int l = mp[q[i].x], r = mp[q[i].y];
        s[l + 1]++, s[r + 1]--;
    }
    for (int i = 1; i <= cnt; i++)
    {
        s[i] += s[i - 1];
    }
    for (int i = 2; i <= cnt; i++)
    {
        int l = ump[i - 1], r = ump[i], x = s[i];
        // cout << l << " " << r << " " << x << "\n";
        res = (res + (r - l) * (qmi(2, x) - 1 + mod) % mod * qmi(2, n - x) % mod) % mod;
    }
    cout << res << "\n";
}

signed main()
{
    // std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int t = 1;
    // cin >> t;
    while (t--)
        solve();
    return 0;
}
E. Triangle Pick

可以直接暴力搜的，至于判断射线是否与三角相交可以用Möller–Trumbore 算法。

#include <bits/stdc++.h>
#define x first
#define y second
#define int long long
#define double long double

using namespace std;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int N = 6000010, M = N * 2, mod = 998244353, P = 131;
int n, m;
struct node
{
    int x1, x2, x3, y1, y2, y3, z1, z2, z3;
} a[1010];

void solve()
{
    cin >> n >> m;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i].x1 >> a[i].y1 >> a[i].z1 >> a[i].x2 >> a[i].y2 >> a[i].z2 >> a[i].x3 >> a[i].y3 >> a[i].z3;
    }
    while (m--)
    {
        int x, y, z;
        cin >> x >> y >> z;
        int res = 0;
        double mx = 1e18;
        for (int i = 0; i < n; i++)
        {
            double e1x = a[i].x2 - a[i].x1, e1y = a[i].y2 - a[i].y1, e1z = a[i].z2 - a[i].z1;
            double e2x = a[i].x3 - a[i].x1, e2y = a[i].y3 - a[i].y1, e2z = a[i].z3 - a[i].z1;

            double px = y * e2z - z * e2y, py = z * e2x - x * e2z, pz = x * e2y - y * e2x;
            double det = e1x * px + e1y * py + e1z * pz;
            if (fabs(det) < 1e-8)
                continue;
            double invdet = 1.0 / det;

            double sx = 0.0 - a[i].x1, sy = 0.0 - a[i].y1, sz = 0.0 - a[i].z1;
            double u = (sx * px + sy * py + sz * pz) * invdet;
            if (u < 0.0 || u > 1.0)
                continue;

            double qx = sy * e1z - sz * e1y, qy = sz * e1x - sx * e1z, qz = sx * e1y - sy * e1x;
            double v = (x * qx + y * qy + z * qz) * invdet;
            if (v < 0.0 || u + v > 1.0)
                continue;

            double tval = (e2x * qx + e2y * qy + e2z * qz) * invdet;
            if (tval > 1e-8 && tval < mx)
            {
                mx = tval;
                res = i + 1;
            }
        }
        cout << res << "\n";
    }
}

signed main()
{
    // std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int t = 1;
    // cin >> t;
    while (t--)
        solve();
    return 0;
}
F. MPFT

大大大大模拟，但我wa了，改了一个多小时，不想写了，代码放这了，等发现了错误或者大佬指正再来改。

#include <bits/stdc++.h>
#define x first
#define y second
#define int long long
#define double long double

using namespace std;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
const int N = 1000010, M = N * 2, mod = 998244353, P = 131;
int n, m, t, k, sum;
int s[N];
bool st[N];

void solve()
{
    cin >> n >> m >> t >> k;
    priority_queue<PII, vector<PII>, greater<PII>> h;
    priority_queue<int, vector<int>, greater<int>> p[N];
    vector<PII> res;
    while (m--)
    {
        int ti, pi;
        cin >> ti >> pi;
        if (!st[pi])
        {
            if (sum == n)
            {
                while (h.size())
                {
                    if (!st[h.top().y])
                    {
                        h.pop();
                        continue;
                    }
                    if (s[h.top().y] > 1)
                    {
                        s[h.top().y]--;
                        h.pop();
                    }
                    else
                    {
                        st[h.top().y] = 0;
                        while (p[h.top().y].size())
                            p[h.top().y].pop();
                        s[h.top().y] = 0;
                        res.push_back({ti, h.top().y});
                        h.pop();

                        h.push({ti, pi});
                        p[pi].push(ti);
                        s[pi] = 1;
                        st[pi] = 1;
                        break;
                    }
                }
            }
            else
            {
                while (p[pi].size() && ti - p[pi].top() > t)
                {
                    p[pi].pop();
                }
                if (p[pi].size() + 1 >= k)
                {
                    res.push_back({ti, pi});
                    s[pi] = 0;
                    st[pi] = 0;
                    while (p[pi].size())
                        p[pi].pop();
                }
                else
                {
                    sum++;
                    h.push({ti, pi});
                    p[pi].push(ti);
                    s[pi] = 1;
                    st[pi] = 1;
                }
            }
        }
        else
        {
            while (p[pi].size() && ti - p[pi].top() > t)
            {
                p[pi].pop();
            }
            if (p[pi].size() + 1 >= k)
            {
                res.push_back({ti, pi});
                s[pi] = 0;
                st[pi] = 0;
                sum--;
                while (p[pi].size())
                    p[pi].pop();
            }
            else
            {
                s[pi]++;
                h.push({ti, pi});
                p[pi].push(ti);
            }
        }
    }

    cout << res.size() << " " << sum << "\n";
    for (int i = 0; i < res.size(); i++)
    {
        cout << res[i].x << " " << res[i].y << "\n";
    }
    for (int i = 1; i <= 1000000; i++)
        if (st[i])
            cout << i << " ";
}

signed main()
{
    std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    int t = 1;
    // cin >> t;
    while (t--)
        solve();
    return 0;
}
2024CCPC东北四省赛复盘/补题记录 (11/13) (ADEFGHIJKLM)
Inter_River的博客
06-03 4021
2024CCPC东北四省赛复盘/补题记录 (11/13) (ADEFGHIJKLM)
2023 ccpc 网络赛 L 题解
Salute
08-24 2303
主席树+决策单调性分治
2021CCPC东北四省赛 解题报告
Fau的博客
09-05 1701
2021CCPC东北四省赛 A. Matrix 大致题意 你需要用[1,n2][1, n^2][1,n2]的所有数字去填充一个n×nn \times nn×n的矩阵. 定义a[]a[]a[], 其中aia_iai​为矩阵中第iii行中的最小值. 定义S={a1,a2,...,an}∩{1,2,...,n}S = \{ a_1, a_2, ..., a _n\} \cap \{ 1, 2, ..., n\}S={a1​,a2​,...,an​}∩{1,2,...,n}. 我们需要计算所有情况的∑∣S∣\sum
2024年CCPC东北四省联赛
Water_Sunzhipeng的博客
05-29 1126
输出39.20即可，保留两位小数，WA了一发...开方log（n）级别，次数少，不会超时。当时想法就是，如果开方不能整开开的数，那么他就能构成 (k - 1) + 1个数，如果能整开，平方就不会出现新数。前面都按照最优的拿，到最后只会有1，2，3个石子， 所以都会输...
2023CCPC黑龙江省赛补题记录
CurleyD的博客
05-21 1959
菜鸡的补题OvO
【解题报告】2021CCPC东北四省赛
鱼竿钓鱼干
06-18 5075
【解题报告】2021CCPC东北四省赛 重现赛链接 第一次打了正式的比赛（虽然是线上）摸了个铜，感觉还行但还是失误很多。 签到题开局和学长一起读错题目（英语水平大雾）十多分钟才出了第一题。 还好后面A的题目全都是1发，保了个铜尾。 题目 C-Vertex Deletion 思路 树形DP没写过，以前只写过一道依赖背包有点类似树形DP。 既然没学过那就学吧！ 树形DP入门题：没有上司的舞会 代码 在这里插入代码片 E-Easy Math Problem 思路 数论构造6p=p+2p+3p6p=p+2p+3
CCPC 2025 吉林省赛题解(A题 交互题)
m0_72904031的博客
05-26 1186
操作结束后可能仍然没有比较出大小，但是位数已经降到了合理的范围内，因此在最后直接交叉相乘即可比较两分数大小。由于最多进行 6666 次操作，所以一定要充分利用，保证让数字的位数降到一个不会爆的范围内。两个分子减去商与分母的乘积（对被除数取模）为何能保证等号方向不变？
第16届东北四省赛题解
m0_51780913的博客
07-23 980
然后就是做一遍树型DP求出来每个点往下延申的最长深度，接着二分答案最小化的城市距离，一遍dfs，如果当前点到往下延伸的点的距离大于k意味着当前点也需要被选上，check最终选的点的数量是否...
2019 东北四省赛部分题解 The 13th Chinese Northeast Collegiate Programming Contest
Verymuch
05-27 2404
2019 东北地区四省赛部分题解 The 13th Chinese Northeast Collegia 比赛链接 :https://codeforces.com/gym/102220 J题: 按题意模拟就行
2024CCPC东北四省赛 The 2024 CCPC National Invitational Contest(ADEJL)
wh233z的博客
05-30 3150
今天由于cf服务器炸了，导致我们赛时不能提交代码，不过我们赛前有做过ADJ这三道签到题，所以很快就a了，然后我们就开始想E题，E题就是一个二进制转换的问题，弄懂这题可以补前导0很快就能写出来，剩下时间又是坐牢······，先不说题目提交不上去对我们心里造成的压力，那I题和L题这两道题看起来简单做起来难，L题也是我赛后才完全搞懂，赛时想了半天只搞懂了1操作对最终序列影响不大，主要还是2操作影响最终序列，只能说题目还是见太少了，还得多刷题。
CCPC-Online-2023-题解.pdf
08-20
本资源是 CCPC Online 2023 网络赛题解，由 Claris、quailty、tangjz 等作者编写，包含了四道题目的解析，即 Almost Prefix Concatenation、Palindromic Beads、CClique Challenge 和 Discrete Fourier Transform。...
2022河南省ccpc省赛题解
weixin_49865561的博客
10-05 1589
2022ccpc
2024CCPC东北省赛.Problem A. Paper Watering（规律&枚举）
陈进士学习的博客
05-24 942
当开方的时候当开方发生向下取整时，累计一次答案，因为开方并且取整的数再次向上平方必然不同。显然不断平方的时候不需要考虑，肯定为。
2024CCPC网络赛题解
weixin_73725403的博客
04-01 1013
【代码】2024CCPC网络赛题解。
【算法】排序算法汇总1
weixin_47220117的博客
10-23 454
本文比较了六种排序算法：冒泡排序（O(n²)最优O(n)）、鸡尾酒排序（双向冒泡，时间复杂度同冒泡）、快速排序（平均O(nlogn)最坏O(n²)）、堆排序（稳定O(nlogn)）、计数排序（O(n+k)需整数键值）和桶排序（最优O(n)需均匀分布）。各算法在时间复杂度、空间复杂度及稳定性上表现不同，适用于不同场景。其中快排和堆排序效率较高，计数和桶排序在特定条件下最优，冒泡类排序简单但效率较低。
力扣475. 供暖器
2301_80219163的博客
10-23 393
力扣475. 供暖器 二分答案+排序+双指针
算法并查集
2401_88154394的博客
10-19 595
摘要： 并查集（DSU）是一种高效管理动态连通分量的数据结构，支持查找（Find）和合并（Union）操作，核心应用包括图论（如Kruskal算法、环检测）、动态连通性问题等。通过路径压缩（查找时扁平化路径）和按秩合并（合并时平衡树高）优化，操作时间复杂度可降至近常数级（(O(\alpha(n)))）。典型实现使用父节点数组和秩数组，空间复杂度为(O(n))。代码示例展示了C++/C的优化实现，并查集在工程和算法中具有广泛实用性。 关键词：并查集、路径压缩、按秩合并、动态连通性、Kruskal算法
DeepLab系列算法介绍
he1223991940的博客
10-19 485
特性传统 DeepLab (v3+等)范式像素分类掩码分类核心输出每个像素的类别概率一组对架构基础CNN + ASPP + 解码器双路径Transformer损失函数逐像素交叉熵损失匈牙利匹配 + Dice/Focal 损失任务定位主要是语义分割统一的语义/全景分割关键思想多尺度上下文、恢复分辨率物体查询、端到端集合预测简单来说，Max Deeplab 可以理解为将 DeepLab 的语义分割能力与 DETR 的端到端物体检测思想深度融合的产物。
算法17.0
最新发布
2301_81348189的博客
10-23 292
滑动窗口~
2024ccpc吉林省赛ccpc题解L
03-21
### 题目分析 题目描述涉及动态规划（DP），并提到父子节点之间的关系以及奇偶位置的选择。这表明该问题是基于树结构的动态规划问题，其中需要考虑子树的状态转移。 #### 动态规划定义 设 `dp[u][0]` 表示以节点 `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

安特尼

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

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

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

打赏作者

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

抵扣说明：

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

余额充值