Codeforces Round #684 (Div. 2)

最新推荐文章于 2024-07-16 11:49:50 发布
最新推荐文章于 2024-07-16 11:49:50 发布
阅读量1k 收藏 2
点赞数 2
分类专栏： Codeforces 文章标签： 模拟 思维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fighting_Peter/article/details/109759895
版权

A - Buy the String

要么全变成1要么全变成0要么一个都不改变，三种情况取最小。

#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#pragma GCC optimize(2)
#include<set>
#include<map>
#include<cmath>
#include<stack>
#include<queue>
#include<random>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
int main()
{
    IO;
    int T=1;
    cin>>T;
    while(T--)
    {
        int n;
        cin>>n;
        int a,b,c;
        cin>>a>>b>>c;
        string s;
        cin>>s;
        int res1=0;
        for(int i=0;i<n;i++)
        {
            if(s[i]=='0') res1+=a;
            else res1+=b;
        }
        int res2=0;
        for(int i=0;i<n;i++)
        {
            if(s[i]=='0') res2+=b+c;
            else res2+=b;
        }
        int res3=0;
        for(int i=0;i<n;i++)
        {
            if(s[i]=='0') res3+=a;
            else res3+=a+c;
        }
        cout<<min(res1,min(res2,res3))<<'\n';
    }
    return 0;
}

B - Sum of Medians

数学题，取后面几个中位数即可
任意考虑一个不降序列 a 1   a 2   a 3 … a n a_1 \ a_2 \ a_3\dots a_n a1​ a2​ a3​…an​，按照题目意思中位数为 a ⌊ 1 + n 2 ⌋ a_{\lfloor \frac{1+n}{2}\rfloor} a⌊21+n​⌋​，我们那么中位数后面的数的个数为 n − ⌊ 1 + n 2 ⌋ n-\lfloor \frac{1+n}{2}\rfloor n−⌊21+n​⌋意味着如果你选择一个数作为中位数那么一定要有 n − ⌊ 1 + n 2 ⌋ n-\lfloor \frac{1+n}{2}\rfloor n−⌊21+n​⌋不小于它的数。

那么本题只需要每次选择第 n − ⌊ 1 + n 2 ⌋ + 1 n-\lfloor \frac{1+n}{2}\rfloor+1 n−⌊21+n​⌋+1大的数作为每个数组的中位数即可。

#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#pragma GCC optimize(2)
#include<set>
#include<map>
#include<cmath>
#include<stack>
#include<queue>
#include<random>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N=1000010;
int n,k;
ll a[N];
int main()
{
    IO;
    int T=1;
    cin>>T;
    while(T--)
    {
        cin>>n>>k;
        for(int i=1;i<=n*k;i++) 
        {
            a[i]=0;
            cin>>a[i];
            
        }
        sort(a+1,a+1+n*k);
        
        int m=(n+1)/2;
        int cnt=n-m;
        ll res=0;
        for(int i=n*k,j=1;i>=1,j<=k;j++,i-=cnt+1)
            res+=a[i-cnt];
        cout<<res<<'\n';
    }
    return 0;
}

C1 - Binary Table (Easy Version)

[ 1 1 1 1 ] → [ 1 0 0 0 ] → [ 1 1 0 0 ] → [ 1 1 1 0 ] → [ 0 0 0 0 ] \begin{bmatrix}1 &1\\ 1&1\end{bmatrix}\to \begin{bmatrix}1 &0\\ 0&0\end{bmatrix}\to \begin{bmatrix}1 &1\\ 0&0\end{bmatrix} \to \begin{bmatrix}1 &1\\ 1&0\end{bmatrix} \to \begin{bmatrix}0 &0\\ 0&0\end{bmatrix} [11​11​]→[10​00​]→[10​10​]→[11​10​]→[00​00​]
每次考虑变换4个格子，每4个格子最多变换4次，我们会把4个数全部变成0，如果行列都是偶数，那么保证mn次操作内绝对能够全变成0
由于行列奇偶行可能导致出现某些元素重复变换导致nm次过不了（这也是更难的版本

#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#pragma GCC optimize(2)
#include<set>
#include<map>
#include<cmath>
#include<stack>
#include<queue>
#include<random>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N=110;
int n,m;
char tmp[N][N];
int g[N][N];
pii a[4];
bool st[4];
vector<pii> ans;
void work(pii a[])
{
    memset(st,0,sizeof st);
    int cnt=0;
    for(int i=0;i<4;i++)
    {
        int x=a[i].first,y=a[i].second;
        cnt+=g[x][y];
    }
    if(cnt==1)
    {
        int now=0;
        for(int i=0;i<4;i++) 
        {
            int x=a[i].first,y=a[i].second;
            if(now<2&&!g[x][y])
            {
                st[i]=1;
                ans.push_back({x,y});
                g[x][y]=1;
                now++;
            }
        }
        for(int i=0;i<4;i++) 
        {
            int x=a[i].first,y=a[i].second;
            if(!st[i]&&g[x][y])
            {
                ans.push_back({x,y});
                g[x][y]=0;
                break;
            }
        }
        work(a);
    }
    else if(cnt==2)
    {
        for(int i=0;i<4;i++) 
        {
            int x=a[i].first,y=a[i].second;
            if(!g[x][y])
            {
                st[i]=1;
                ans.push_back({x,y});
                g[x][y]=1;
            }
        }
        for(int i=0;i<4;i++) 
        {
            int x=a[i].first,y=a[i].second;
            if(!st[i]&&g[x][y])
            {
                ans.push_back({x,y});
                g[x][y]=0;
                break;
            }
        }
        work(a);
    }
    else if(cnt==3)
    {
        for(int i=0;i<4;i++) 
        {
            int x=a[i].first,y=a[i].second;
            if(g[x][y])
            {
                ans.push_back({x,y});
                g[x][y]=0;
            }
        }
    }
    else if(cnt==4)
    {
        for(int i=0;i<3;i++) 
        {
            int x=a[i].first,y=a[i].second;
            if(g[x][y])
            {
                ans.push_back({x,y});
                g[x][y]=0;
            }
        }
        work(a);
    }
    else return;
}
int main()
{
    IO;
    int T=1;
    cin>>T;
    while(T--)
    {
        cin>>n>>m;
        for(int i=1;i<=n;i++) cin>>tmp[i]+1;
        for(int i=1;i<=n;i++)   
            for(int j=1;j<=m;j++)   
                g[i][j]=tmp[i][j]-'0';
        
        for(int i=1;i<=n;i+=2)
            for(int j=1;j<=m;j+=2)
            {
                if(i+1<=n&&j+1<=m)
                    a[0]={i,j},a[1]={i+1,j},a[2]={i,j+1},a[3]={i+1,j+1};
                else if(i+1>n&&j+1<=m)
                    a[0]={i,j},a[1]={i-1,j},a[2]={i,j+1},a[3]={i-1,j+1};
                else if(i+1<=n&&j+1>m)
                    a[0]={i,j},a[1]={i+1,j},a[2]={i,j-1},a[3]={i+1,j-1};
                else
                    a[0]={i,j},a[1]={i-1,j},a[2]={i,j-1},a[3]={i-1,j-1};
                work(a);
            }
        cout<<ans.size()/3<<'\n';
        int cnt=0;
        for(auto t:ans)
        {
            cnt++;
            cout<<t.first<<' '<<t.second<<' ';
            if(cnt%3==0) cout<<'\n';
        }
        ans.clear();
    }
   
    return 0;
}

C2 - Binary Table (Hard Version)

对于行列数是奇数可能导致nm操作不能搞的情况：其实我们只要首先把一行全部变成0（行数是奇数）或者一列全部变成0（列数是奇数），我们就能把操作次数控制在 n 2 + 1 + m 2 + 1 + ( m − 1 ) × ( n − 1 ) \frac{n}{2}+1+\frac{m}{2}+1+(m-1)×(n-1) 2n​+1+2m​+1+(m−1)×(n−1)次以内

#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#pragma GCC optimize(2)
#include<set>
#include<map>
#include<cmath>
#include<stack>
#include<queue>
#include<random>
#include<bitset>
#include<string>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N=110;
int n,m;
char tmp[N][N];
int g[N][N];
pii a[4];
bool st[4];
vector<pii> ans;
void work(pii a[])
{
    memset(st,0,sizeof st);
    int cnt=0;
    for(int i=0;i<4;i++)
    {
        int x=a[i].first,y=a[i].second;
        cnt+=g[x][y];
    }
    if(cnt==1)
    {
        int now=0;
        for(int i=0;i<4;i++) 
        {
            int x=a[i].first,y=a[i].second;
            if(now<2&&!g[x][y])
            {
                st[i]=1;
                ans.push_back({x,y});
                g[x][y]=1;
                now++;
            }
        }
        for(int i=0;i<4;i++) 
        {
            int x=a[i].first,y=a[i].second;
            if(!st[i]&&g[x][y])
            {
                ans.push_back({x,y});
                g[x][y]=0;
                break;
            }
        }
        work(a);
    }
    else if(cnt==2)
    {
        for(int i=0;i<4;i++) 
        {
            int x=a[i].first,y=a[i].second;
            if(!g[x][y])
            {
                st[i]=1;
                ans.push_back({x,y});
                g[x][y]=1;
            }
        }
        for(int i=0;i<4;i++) 
        {
            int x=a[i].first,y=a[i].second;
            if(!st[i]&&g[x][y])
            {
                ans.push_back({x,y});
                g[x][y]=0;
                break;
            }
        }
        work(a);
    }
    else if(cnt==3)
    {
        for(int i=0;i<4;i++) 
        {
            int x=a[i].first,y=a[i].second;
            if(g[x][y])
            {
                ans.push_back({x,y});
                g[x][y]=0;
            }
        }
    }
    else if(cnt==4)
    {
        for(int i=0;i<3;i++) 
        {
            int x=a[i].first,y=a[i].second;
            if(g[x][y])
            {
                ans.push_back({x,y});
                g[x][y]=0;
            }
        }
        work(a);
    }
    else return;
}
void print()
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++) cout<<g[i][j]<<' ';
        cout<<endl;
    }
}
int main()
{
    IO;
    int T=1;
    cin>>T;
    while(T--)
    {
        cin>>n>>m;
        for(int i=1;i<=n;i++) cin>>tmp[i]+1;
        for(int i=1;i<=n;i++)   
            for(int j=1;j<=m;j++)   
                g[i][j]=tmp[i][j]-'0';
        if(n%2==0&&m%2==0)
        {
            for(int i=1;i<=n;i+=2)
                for(int j=1;j<=m;j+=2)
                {
                    a[0]={i,j},a[1]={i+1,j},a[2]={i,j+1},a[3]={i+1,j+1};
                    work(a);
                }
        }
        else if(n%2==0&&m%2!=0)
        {
            for(int i=1;i<=n;i+=2)
            {
                if(g[i][1]==0&&g[i+1][1]==0) continue;
                else if(g[i][1]==1&&g[i+1][1]==0)
                {
                    ans.push_back({i,1}); g[i][1]=1-g[i][1];
                    ans.push_back({i,2}); g[i][2]=1-g[i][2];
                    ans.push_back({i+1,2}); g[i+1][2]=1-g[i+1][2];
                }
                else if(g[i][1]==0&&g[i+1][1]==1)
                {
                    ans.push_back({i+1,1}); g[i+1][1]=1-g[i+1][1];
                    ans.push_back({i,2}); g[i][2]=1-g[i][2];
                    ans.push_back({i+1,2}); g[i+1][2]=1-g[i+1][2];
                }
                else 
                {
                    ans.push_back({i,1}); g[i][1]=1-g[i][1];
                    ans.push_back({i+1,1}); g[i+1][1]=1-g[i+1][1];
                    
                    ans.push_back({i+1,2}); g[i+1][2]=1-g[i+1][2];
                }

            }
            
            for(int i=1;i<=n;i+=2)
                for(int j=2;j<=m;j+=2)
                {
                    a[0]={i,j},a[1]={i+1,j},a[2]={i,j+1},a[3]={i+1,j+1};
                    work(a);
                }
        }
        else if(n%2!=0&&m%2==0)
        {
            for(int j=1;j<=m;j+=2)
            {
                if(g[1][j]==0&&g[1][j+1]==0) continue;
                else if(g[1][j]==1&&g[1][j+1]==0)
                {
                    ans.push_back({1,j});g[1][j]=1-g[1][j];
                    ans.push_back({2,j});g[2][j]=1-g[2][j];
                    ans.push_back({2,j+1});g[2][j+1]=1-g[2][j+1];
                }
                else if(g[1][j]==0&&g[1][j+1]==1)
                {
                    ans.push_back({1,j+1});g[1][j+1]=1-g[1][j+1];
                    ans.push_back({2,j});g[2][j]=1-g[2][j];
                    ans.push_back({2,j+1});g[2][j+1]=1-g[2][j+1];
                }
                else 
                {
                    ans.push_back({1,j});g[1][j]=1-g[1][j];
                    ans.push_back({1,j+1});g[1][j+1]=1-g[1][j+1];
                    ans.push_back({2,j});g[2][j]=1-g[2][j];
                    
                }
            }
                
                for(int i=2;i<=n;i+=2)
                    for(int j=1;j<=m;j+=2)
                    {
                        a[0]={i,j},a[1]={i+1,j},a[2]={i,j+1},a[3]={i+1,j+1};
                        work(a);
                    }
                
            //print();
            
        }
        else
        {
            for(int i=1;i<=n;i+=2)
            {
                int x=i+1;
                if(x>n) x-=2;
                if(g[i][1]==0&&g[x][1]==0) continue;
                else if(g[i][1]==1&&g[x][1]==0)
                {
                    ans.push_back({i,1}); g[i][1]=1-g[i][1];
                    ans.push_back({i,2}); g[i][2]=1-g[i][2];
                    ans.push_back({x,2}); g[x][2]=1-g[x][2];
                }
                else if(g[i][1]==0&&g[x][1]==1)
                {
                    ans.push_back({x,1}); g[x][1]=1-g[x][1];
                    ans.push_back({i,2}); g[i][2]=1-g[i][2];
                    ans.push_back({x,2}); g[x][2]=1-g[x][2];
                }
                else 
                {
                    ans.push_back({x,1}); g[x][1]=1-g[x][1];
                    ans.push_back({i,1}); g[i][1]=1-g[i][1];
                    ans.push_back({x,2}); g[x][2]=1-g[x][2];
                }
        
            }
            for(int j=2;j<=m;j+=2)
            {
                int y=j+1;
                if(y>m) y-=2;
                if(g[1][j]==0&&g[1][y]==0) continue;
                else if(g[1][j]==1&&g[1][y]==0)
                {
                    ans.push_back({1,j});g[1][j]=1-g[1][j];
                    ans.push_back({2,j});g[2][j]=1-g[2][j];
                    ans.push_back({2,y});g[2][y]=1-g[2][y];
                }
                else if(g[1][j]==0&&g[1][y]==1)
                {
                    ans.push_back({1,y});g[1][y]=1-g[1][y];
                    ans.push_back({2,j});g[2][j]=1-g[2][j];
                    ans.push_back({2,y});g[2][y]=1-g[2][y];
                }
                else 
                {
                    ans.push_back({1,j});g[1][j]=1-g[1][j];
                    ans.push_back({2,j});g[2][j]=1-g[2][j];
                    ans.push_back({1,y});g[1][y]=1-g[1][y];
                }
            }
            //print();


            for(int i=2;i<=n;i+=2)
                    for(int j=2;j<=m;j+=2)
                    {
                        a[0]={i,j},a[1]={i+1,j},a[2]={i,j+1},a[3]={i+1,j+1};
                        work(a);
                    }
            
        }

        
        cout<<ans.size()/3<<'\n';
        int cnt=0;
        for(auto t:ans)
        {
            cnt++;
            cout<<t.first<<' '<<t.second<<' ';
            if(cnt%3==0) cout<<'\n';
        }
        ans.clear();
    }
   
    return 0;
}

这模拟就离谱好吧~~

写了4题太晚了（希望不被fst，就没有在往后看

E. Greedy Shopping

今天补了一下E. Greedy Shopping
要加油哦~

Fighting_Peter
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
codeforces round 961 (div. 2)
最新发布
07-25
### Codeforces Round 961 (Div. 2) A题解析 #### 题目背景 Codeforces Round 961 (Div. 2) 是一场针对中级水平程序员的编程竞赛，通常会包含几个不同难度级别的题目。A题作为入门级题目，旨在测试参赛者的基础算法...
Codeforces Round 958 (Div. 2)
鱼香rose_的博客
07-16 1339
CodeforcesRound958(Div.2)\Huge{Codeforces Round 958 (Div. 2)}CodeforcesRound958(Div.2)给出一个数组，每次可以选择数组中的一个数，并将其拆为不超过kkk个数。问最少需要几次可以构造出全111数组（数组中只包含111）。贪心的想，我们每次可以将选出的数字x拆为1+1+1+…+(x-k+1)。那么结果即为： ⌈n−1k−1⌉ \left \lceil \frac{n-1}{k-1} \right \rceil ⌈k−1n−1​
Codeforces Round 917 (Div. 2)
Lanthamum的博客
12-24 578
############################################################################B.不会。A.考虑有没有负数，偶数（把没有负数考虑进去了）就要改变一个数为0，为min，如果是奇数就不用考虑
Codeforces Round 915 (Div. 2)
Lanthamum的博客
12-16 563
【代码】Codeforces Round 915 (Div. 2)
Codeforces Round 948 (Div. 2)
2301_80041146的博客
05-27 619
思路：有个非常重要的性质，对于某一列，假设确定了这一列的哪一行有1，那么这个图已经可以确定了。思路：如果n<m，显然不行。再看n>=m的情况，可以先假定放刚好m个，在思考是否可以在接下来的步骤使方块数不变。题意：给定一个数组，找到一个子数组，需使这个子数组的lcm（最小公倍数）不存在于给定的数组，问这个子数组的最大长度是多少。题意：有n次机会，每次可以选择放一个方块或者拿走一个，问最后是否可以有m个方块。题意：构造题，懒得描述了，直接看，其中第三条可以转换成不存在连续的1或-1。
codeforces round 948(div.2）
2301_79426686的博客
05-27 733
codeforces round 948(div.2) AB
Codeforces Round #763 (Div. 2)
m0_56005735的博客
01-24 503
codeforces Round #763 (Div. 2)1.A - Robot Cleaner.2.B - Game on Ranges.3.C - Balanced Stone Heaps
Codeforces Round 892 (Div. 2)
qq_64289808的博客
08-13 330
Codeforces Round 892 (Div. 2)
Codeforces Round 876 (Div. 2)
qq_61657632的博客
06-04 674
C.最后如果是1放不了，要想让最后的0变成1只能从后面放0所以最后的不能为1。可以手玩一下，排序ai ai层最多可以取ai件，且ai不会影响到ai+1层。放0直接放最前面，保证连续的0变成连续的1不会导致后面的状态改变。然后连续的1其实只要从末尾插入个0就能把前面都变成1。所以从小往大取即可贪心拿最大的物品。贪心放1的时候直接放i。
Codeforces Round #816 (Div. 2)
AC__dream的博客
09-24 502
Codeforces Round #816 (Div. 2)
Codeforces Round #823 (Div. 2)
weixin_52255583的博客
09-26 622
A B C
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
就是把所有相等的数放到一个vector里，如果他出现大于2次，看最远的间距是否大于2即可，找到一个就可以 代码： #include #include #include #include #include #include #include #include #include #include #...
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include ...typedef long long l
Codeforces Round #479 (Div. 3) E. Cyclic Components
01-03
E. Cyclic Components 题目链接-E. Cyclic Components 题目大意 给你nnn个点和mmm条边，求所构成图中单圈环的个数 ...并查集并查集并查集 很明显单圈环每个点的度都为222，所以我们可以用数组cnt[]记录每个点的度，...
codeforces1485 E. Move and Swap（dp）
Fighting_Peter的博客
02-13 2462
E. Move and Swap Hel 由于红色硬币向下一层走的时候只能走儿子，而蓝色无限制（对后续操作无影响），这里 状态表示：fif_ifi​表示当前是红色硬币，向下一层走后的最大价值。 #define IO ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr) #pragma GCC optimize(2) #include<cstring> #include<iostream> #include<
codeforces1485 F. Copy or Prefix Sum（dp）
Fighting_Peter的博客
02-13 2298
F. Copy or Prefix Sum Venice technique简要就是懒标记思想。 由于前缀和数组和原数组一一对应，这里我们选择求aia_iai​的前缀和数组的方案数（下面aia_iai​表示原题数组的前缀和） 不难得知原题目的两个条件即 bi=ai−ai−1→ai=bi+ai−1b_i=a_i-a_{i-1} \to a_i=b_i+a_{i-1}bi​=ai​−ai−1​→ai​=bi​+ai−1​ bi=ai→ai=bib_i=a_i \to a_i=b_ibi​=ai​→ai​=b
Grakn Forces 2020——D题Pecco模型总结
Fighting_Peter的博客
10-01 1934
今天是双节但是为什么我今天好自闭啊啊啊，自己在寝室自闭了一下午，好无聊。明天一定要精神满满啊！ A - Circle Coloring 签到题 #define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0) #pragma GCC optimize(2) #include<iostream> #include<algorithm> using namespace std; const int N=110; int a[N],c
codeforces1151 E. Number of Components（计数）
Fighting_Peter的博客
02-10 1364
E. Number of Components 方法一：考虑每个点的贡献，认为一个联通块里让编号最大的点产生贡献 那么，对于一个点 iii，如果对答案产生贡献，一定要点 iii 存在，而点 i+1i + 1i+1 不存在。 #define IO ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr) #pragma GCC optimize(2) #include<iostream> #include<algorithm
codeforces round #772 (div. 2)
03-16
好的，Codeforces Round #772 (Div. 2) 是一场由Codeforces主办的在线编程竞赛。 该比赛的比赛链接为：https://codeforces.com/contest/772。 该比赛分为两个级别：Div.1和Div.2。 Div. 1级别通常比Div. 2级别更...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值