Codeforces Round #536 (Div. 2) A~F 个人题解

最新推荐文章于 2022-10-24 20:22:18 发布
最新推荐文章于 2022-10-24 20:22:18 发布
阅读量1.3k 收藏
点赞数 2
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53446104/article/details/124351933
版权

Dashboard - Codeforces Round #536 (Div. 2) - Codeforces

A. Lunar New Year and Cross Counting

题意：给一个n*n的网格，网格由'.'和'X'构成，问M(i,j)=M(i−1,j−1)=M(i−1,j+1)=M(i+1,j−1)=M(i+1,j+1)= 'X'.有多少对(i,j) ? (其实就是问网格上有多少个长3宽3的X图形)

知识点：暴力

思路：对于每一个（i，j）暴力判他的本身,左上,左下,右上,右下是不是都是'X'就可以了

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N = 5e5+5;
const ll mod =998244353;
char mp[505][505];
void solve(){
    ll n;cin>>n;
    for(int i=1;i<=n;++i){
        for(int j=1;j<=n;++j){
            cin>>mp[i][j];
        }
    }ll ans=0;
    for(int i=2;i<n;++i){
        for(int j=2;j<n;++j){
            if(mp[i][j]=='X'){//本身
                if(mp[i+1][j+1]=='X'//右下
                 &&mp[i+1][j-1]=='X'//右上
                 &&mp[i-1][j+1]=='X'//左下
                 &&mp[i-1][j-1]=='X'){//左上
                    ans++;
                }
            }
        }
    }
    cout<<ans<<'\n';
}
int main() {
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
    int _=1;//cin>>_;
    while(_--){
        solve();
    }
    return 0;
}

B. Lunar New Year and Food Ordering

题意：有n种物品，每种物品有对应的价值c_i和个数a_i，现在有m个顾客，每个顾客有自己喜爱的物品种类和要点的个数，如果当前这个顾客喜爱的种类的个数不能满足要求，则再还有的物品中拿价值最小的物品来补充，如果仍然没有满足顾客需要的个数，顾客就会离开（不花费钱）。问m个顾客一共要花费多少钱。

知识点：模拟，优先队列

思路：维护一个数组表示每个种类的物品还剩下几个，然后因为有价值最小的补充，可以开一个优先队列来维护还剩下的种类物品的最小价值。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N = 1e5+5;
const ll mod =998244353;
struct dd{
    ll a,c,id;
    inline bool operator <(const dd &r)const{
        return c>r.c;//重载小于号使得小的先出队列
    }
}op[N];
ll n,m,t,d;
void solve(){
    cin>>n>>m;
    for(int i=1;i<=n;++i)cin>>op[i].a,op[i].id=i;
    for(int i=1;i<=n;++i)cin>>op[i].c;
    priority_queue<dd>q;
    for(int i=1;i<=n;++i)q.push(op[i]);//全部插入优先队列中
    for(int i=1;i<=m;++i){
        cin>>t>>d;ll res=0;
        if(op[t].a>=d){//如果当前种类物品比顾客需要的还多
            op[t].a-=d;
            res=d*op[t].c;
            d=0;//说明满足了顾客的需求
        }
        else {//如果当前种类物品比顾客需要的少
            res=op[t].c*op[t].a;
            d-=op[t].a;
            op[t].a=0;
            while(!q.empty()){
                auto g=q.top();q.pop();
                g.a=op[g.id].a;
                if(g.a>=d){
                    res+=d*g.c;
                    g.a-=d;
                    if(g.a)q.push({g.a,g.c,g.id});
                    op[g.id].a=g.a;//更新一下当前种类物品的个数
                    d=0;//说明满足了顾客的需求
                    break;
                }
                else {
                    res+=g.a*g.c;
                    d-=g.a;
                    op[g.id].a=0;//更新一下当前种类物品的个数
                }
            }
        }
        if(d)cout<<0<<'\n';//没有满足顾客需求
        else cout<<res<<'\n';
    }
}
int main() {
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
    int _=1;//cin>>_;
    while(_--){
        solve();
    }
    return 0;
}

C. Lunar New Year and Number Division

题意：给你一个正整数n，n一定是一个偶数，现在有一个长度为n个数组，你需要把这个数组分成任意份，每份要保证元素个数大于等于2，设每份的元素总和为s_i，问\sum_{i}s_i^2最小是多少？

知识点：数学，贪心，蒙（不是

思路：可以大概猜到一个分成n/2份，每份是最大和最小，次大和次小...........以此类推，所以只要排序一下，就能解决问题。

证明1：对于最后的答案一定会出现\sum_{i=1}^{n}a_i^2+w(w类似2a_1a_2+2a_ia_j),因为1\leq a_i，所以对于a_ia_j一定是大于0的，我们要尽可能减少这样的项出现，所以每一份一定是俩个数。

证明2：假设0<a<b<c<d,我们要证明ad+bc<=ab+cd  和 ad+bc<=ac+bd

第一个很好证明

移项后变成 a(d-b)+c(b-d)<=0

也就是 (a-c)(d-b)<=0这是显然的

第二个的话

同样的 移项后变成 a(d-c)+b(c-d)<=0

也就是 (a-b)(d-c)<=0这也是显然的

所以我们猜的那个结论是正确的

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N = 3e5+5;
const ll mod =998244353;
ll n,a[N];
void solve(){
    cin>>n;
    for(int i=1;i<=n;++i)cin>>a[i];
    sort(a+1,a+n+1);
    ll ans=0;
    for(int i=1;i<=(n/2);++i){
        ans+=(a[i]+a[n-i+1])*(a[i]+a[n-i+1]);//注意理清楚下标
    }
    cout<<ans<<'\n';
}
int main() {
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
    int _=1;//cin>>_;
    while(_--){
        solve();
    }
    return 0;
}

D. Lunar New Year and a Wander

题意：一个有n个点，m条边（双向）的图，可能有重边和自环，有一个人从点1开始走，这个人开始的时候手上有一个数字，每次走到一个没有走过的点就会把手上的数字+1，并且把这个点的d_i赋值为手上的数字，问最小的d序列？

知识点：BFS

思路：要让序列最小，肯定想每次先走现在可以走的最小的序号，所以我们可以想到BFS来解决，开一个以序号从小到大排序的优先队列就可以了。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N = 1e5+5;
const ll mod =998244353;
ll n,m;
vector<ll>mp[N],ans;
bool vis[N];
void bfs(){
    priority_queue<ll,vector<ll>,greater<ll> >q;//从小到大排序的优先队列
    q.push(1);//1先进去
    vis[1]=true;
    while(!q.empty()){
        ll g=q.top();q.pop();
        ans.push_back(g);//记录答案
        for(auto v:mp[g]){
            if(vis[v])continue;
            vis[v]=true;
            q.push(v);//把现在能走的点都扔进队列里
        }
    }
}
void solve(){
    cin>>n>>m;
    for(ll i=1,u,v;i<=m;++i){
        cin>>u>>v;
        mp[u].push_back(v);
        mp[v].push_back(u);
    }
    bfs();
    for(auto w:ans)cout<<w<<' ';
}
int main() {
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
    int _=1;//cin>>_;
    while(_--){
        solve();
    }
    return 0;
}

E. Lunar New Year and Red Envelopes

题意：现在有k个红包，第i个红包只能在s_i到t_i的时间获取w_i的钱，并且在获取后直到时间d_i都不能拿别的红包，现在有一个十分贪婪的人，他会有n个时间去获取红包，只要当前时间能拿红包，他就会拿当前时间能拿红包的最大值，如果有最大值相同的拿d最大的，现在你可以干扰他m个时间，让他不拿，问他拿到的钱数的最小值？

知识点：DP，数据结构

思路：其实很容易想到dp[i][j],表示前i个时间干扰m次他能拿到钱数的最小值，转移的话,

如果第i个时间不能拿任何红包，那么dp[i][j]=max dp[i-1][j]

如果第i个时间能拿红包且我们去干扰，那么dp[i][j]=max dp[i-1][j-1]]

如果第i个时间能拿红包且我们不去干扰，那么dp[ d ][j]=max dp[i-1][j]]+w

所以现在只有一个问题就是如何知道当前时间所能选到的w_i的最大值，并且要知道d_i。

我们可以先按s,t 排序 ，再开一个以w和d排序的优先队列，每次把s<=i的点扔进队列里，把t<i的点扔出去，这样就可以解决问题了。（具体可以看代码）

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N = 1e5+5;
const ll mod =998244353;
ll n,m,k;
struct dd{
    ll s,t,d,w;
    inline bool operator <(const dd &r)const{
        if(s==r.s){
            return t<r.t;//如果俩个s大小相等，t小的排前面
        }
        return s<r.s;//s小的排前面
    }
}op[N];
struct up{
    ll s,t,d,w;
    inline bool operator <(const up &r)const{
        if(w==r.w){
            return d<r.d;//w相等，d大的先看
        }
        return w<r.w;//w大的先看
    }
};
ll dp[N][205];
void solve(){
    cin>>n>>m>>k;
    priority_queue<up>q;
    for(int i=1;i<=k;++i){
        cin>>op[i].s>>op[i].t>>op[i].d>>op[i].w;
    }
    sort(op+1,op+k+1);
    for(int i=1;i<=n;++i){
        for(int j=0;j<=m;++j)dp[i][j]=1e18;//初始化，因为有取min
    }
    ll l=1;
    for(int i=1;i<=n;++i){
        while(l<=k&&op[l].s<=i){
            q.push({op[l].s,op[l].t,op[l].d,op[l].w});//如何当前点的s小于等于i那他一定包含了
            l++;
        }
        ll w=0,d=0;
        while(!q.empty()){
            auto g=q.top();
            if(g.s<=i&&i<=g.t){//如果符合，就是找到了
                w=g.w;d=g.d;
                break;
            }
            else q.pop();//不符合说明i>t了，pop出去
        }
        for(int j=0;j<=m;++j){
            if(w){//有红包
                if(j>=1)dp[i][j]=min(dp[i-1][j-1],dp[i][j]);//不干扰
                dp[d][j]=min(dp[d][j],dp[i-1][j]+w);//干扰
            }
            else {//没红包
                dp[i][j]=min(dp[i-1][j],dp[i][j]);
            }
        }
    }ll ans=1e18;
    for(int i=0;i<=m;++i){
        ans=min(ans,dp[n][i]);//找答案
    }
    cout<<ans<<'\n';
}
int main() {
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
    int _=1;//cin>>_;
    while(_--){
        solve();
    }
    return 0;
}
/*
*/

F. Lunar New Year and a Recursive Sequence

题意：给你一个长度为k的序列b和p=998244353,定义f_i=\prod_{j=1}^{k}f_{i-j}^{b_j}\mod\ p

现在知道f_1=f_2=f_3...=f_{k-1}=1，并且知道f_n=m

求f_k \mod \ p 等于几？如果不存在输出 -1

知识点：原根，矩阵快速幂，BSGS

思路：先观察定义，发现是个次幂的形式，这样不好找联系，发现p是个大质数，那么我们就可以转化次幂成乘法通过原根。

我们定义原根G

这里我们用到原根的：G的0~p-2次幂可以唯一的表示1~p-1（其实不是很严谨，但这里可以这么说

也就是我们可以转化定义为G^{z_i}=\prod_{j=1}^{k}G^{z_{i-j}\times b_j}\mod\ p

再化一下z_i=\prod_{j=1}^{k}z_{i-j}\times b_j\mod\ p

也就是我们可以通过矩阵快速幂来转移了，构造矩阵

\left[ \begin{matrix} z_{n} \\ z_{n-1} \\ \vdots \\ z_{n-k+1} \\ \end{matrix} \right]= \left[ \begin{matrix} b_1 & b_2 & \cdots &b_k\\ 1 & 0 & \cdots &0\\ 0 & \ddots &\vdots &0\\ 0&\cdots&1&0\\ \end{matrix} \right]^{n-k} \times \left[ \begin{matrix} z_{k} \\ z_{k-1} \\ \vdots \\ z_{1} \\ \end{matrix} \right]

因为f_1=f_2=f_3...=f_{k-1}=1，所以z_1=z_2=z_3=...=z_{k-1}=0, (G^0=1)

所以z_n=D(1,1) \times z_k,(D(i,j)表示矩阵快速幂运算完后的矩阵第i行第j列的元素)

再带回去，G^{z_n}\equiv G^{z_k\times D(1,1)} \mod p,也就是m\equiv (G^{D(1,1)})^{z_k} \mod\ p

这个怎么求z_k的值呢，我们可以通过BSGS算出，就求出来了，

最后答案f_k=G^{z_k}.

那G又是多少呢，如果学过一点点NTT，我们可以知道998244353的原根是3，不知道也可以通过求原根的方法算出来。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N = 1e5+5;
const ll mod =998244352;
const ll Mod = 998244353;
const int maxl=105;
struct Matrix {
    ll a[maxl][maxl];
    int n,m;
    inline Matrix(int n,int m) : n(n) , m(m) {
        for(int i=0;i<n;++i){
            for(int j=0;j<m;++j)a[i][j]=0;
        }
    }
    inline void init(){
        for(int i=0;i<n;++i){
            for(int j=0;j<m;++j)a[i][j]=0;
            a[i][i]=1;
        }
    }
    inline void Clear(){
        for(int i=0;i<n;++i){
            for(int j=0;j<m;++j)a[i][j]=0;
        }
    }
    inline Matrix operator * (const Matrix &t){
        Matrix io(n,t.m);
        for(int i=0;i<n;++i){
            for(int j=0;j<t.m;++j){
                for(int k=0;k<m;++k){
                    io.a[i][j]=(io.a[i][j]+a[i][k]*t.a[k][j]%mod+mod)%mod;
                }
            }
        }
        return io;
    }
    inline Matrix operator + (const Matrix &t){
        Matrix io(n,m);
        for(int i=0;i<n;++i){
            for(int j=0;j<m;++j){
                io.a[i][j]=(a[i][j]+t.a[i][j]+mod)%mod;
            }
        }
        return io;
    }
    inline Matrix ksm(ll b){
        Matrix ans(this->n,this->m),a=*this;
        ans.init();
        while(b){
            if(b&1)ans=ans*a;
            a=a*a;
            b>>=1;
        }
        return ans;
    }
};
ll ksm(ll a,ll b,ll p){
    ll ans=1;
    while(b){
        if(b&1)ans=ans*a%p;
        a=a*a%p;
        b>>=1;
    }
    return ans;
}
ll BSGS(ll a,ll b,ll p){//求a^x=b %p的最小的x
    a%=p;b%=p;
    if(!a){
        if(!b)return 1;
        else return -1;
    }
    if(b==1)return 0;
    ll n=ceil(sqrt(p)),res=b;
    map<ll,ll>mp;
    for(ll i=0;i<n;++i){
        mp[res]=i;
        res=res*a%p;
    }a=ksm(a,n,p);res=a;
    for(ll i=1;i<=n;++i){
        if(mp.find(res)!=mp.end()){
            return i*n-mp[res];
        }
        res=res*a%p;
    }
    return -1;
}
ll b[105],n,m;
void solve(){
    ll k;cin>>k;
    for(int i=1;i<=k;++i)cin>>b[i];
    cin>>n>>m;
    Matrix now(k,k);
    for(int i=0;i<k;++i)now.a[0][i]=b[i+1];//构建
    for(int i=1;i<k;++i)now.a[i][i-1]=1;//   矩阵
    now=now.ksm(n-k);//矩阵的n-k次幂
    ll ans=BSGS(ksm(3,now.a[0][0],Mod),m,Mod);//BSGS求出z_k
    if(ans==-1)cout<<ans<<'\n';//无解
    else cout<<ksm(3,ans,Mod)<<'\n';//输出答案
}
int main() {
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
    int _=1;//cin>>_;
    while(_--){
        solve();
    }
    return 0;
}
/*
*/

Rh_hipper
关注
Codeforces Round #834 (Div. 3) A~E题解
weixin_63927680的博客
11-19 1674
题目：D. Make It Round 题意： 给定一个n和m，k的取值范围在1~m,求出最大的n*k并满足有最多的末尾0。首先10 = 2*5,所以要有末尾0，首先必须出现2和5，所以我们先分解n，看一下n有多少个5，多少个2，假设n分解之后有4个2，1个5，它本身1个2和1个5相乘等于10，所以剩下3个2，那么此时，k就先补3个5，既5*5*5 = 125，如果此时k还没有超出范围的话，就继续乘10，如果乘10后超出范围了，就在1~9之间相乘，找到最大的那个k。如果k在补5的时候超出
Codeforces Round #787 (Div. 3)个人题解
weixin_51767904的博客
05-06 1129
Codeforces Round #787 (Div. 3)个人题解 Codeforces Round #787 (Div. 3) A. Food for Animals B. Make It Increasing C. Detective Task D. Vertical Paths E. Replace With the Previous, Minimize F. Vlad and Unfinished Business G. Sorting Pancakes
Codeforces Round #536 (Div. 2)
banshen0201的博客
02-01 94
A. Lunar New Year and Cross Counting 签. 1 #include <bits/stdc++.h> 2 using namespace std; 3 4 #define N 510 5 int n; 6 char G[N][N]; 7 8 int main() 9 { 10 w...
Codeforces Round #536 (Div. 2)解题报告（有待更新）
满月照亮的路
01-31 340
题目链接：http://codeforces.com/contest/1106 第一题： #include&lt;bits/stdc++.h&gt; using namespace std; #define debug puts("YES"); #define rep(x,y,z) for(int (x)=(y);(x)&lt;(z);(x)++) #define ll long long...
Codeforces Round #684 (Div. 2) A - C2 题解
avgstuBoboge的博客
11-18 1031
Codeforces Round #684 (Div. 2) A - C2 题解 A Buy the String 题意 给定一个长度为 nnn 的01串，你可以用 hhh 的代价把字符串中任意一个字符取反，最终你要把这个01串买下来，0的单价为c0c_0c0​，1的单价为 c1c_1c1​。现给你n,h,c0,c1n,h,c_0,c_1n,h,c0​,c1​以及一个01串，问你最少花多少可以买下这个串。输出最小总价。 思路 贪心，设c0<c1c_0 \lt c_1c0​<c1​，若c1−c0
Codeforces Round #829 (Div. 2)部分题解A B C1 E
weixin_63927680的博客
10-24 962
​Codeforces Round #829 (Div. 2)部分题解A B C1 E 原题地址：Dashboard - Codeforces Round #829 (Div. 2) - Codeforces A. Technical Support 题意： 有一个只包含“Q”和"A"的字符串，Q代表问题，A代表回答，有问必有答，也就是Q后面一定有n个A（n>=0） B. Kevin and Permutation 题意： 给定 ​
Codeforces Round #664 (Div. 2)题解
Adrian099的博客
08-13 339
A Boboniu Likes to Color Balls 题意思路 : 给定四种颜色通过以下操作判断能否组成回文串 操作： 前三个减一 后一个加一 思路 : 判断奇数的个数 若和为奇数 则最多有一个奇数 若为偶数 0个 代码： #include<bits/stdc++.h> using namespace std; int c[4]; bool f(){ int sum1 = 0; int sum2 = 0; for(int i = 0; i < 4; i++){ sum
Codeforces Round #536 (Div. 2) D. Lunar New Year and a Wander（BFS+优先队列）
C_Dreamy的博客
03-06 174
给出一张图，遍历每一个节点，使得节点顺序字典序最小；图中可能有环和多重边 思路并不难想，下面做一下时间复杂度的讨论， //A: while(q.size()){ int x=q.top(); q.pop(); ans.pb(x); int len=G[x].size(); for(int i=0;i<len;i++){ int tmp=G[x][i]; if(vis[tmp]) continue; ...
Codeforces Round #536 (Div. 2) B. Lunar New Year and Food Ordering（优先队列+模拟）
C_Dreamy的博客
03-08 248
有 n 盘菜，输入其对应的数量和菜价，有 m 个客人依次来购买，对于每一位客人，输入其想买菜的编号和数量，如果没有这种菜，就怂恿客人把店里便宜的先买了，如果客人需要的数量>店里所拥有的菜的数量，那么客人会很生气，并且免费拿走这些 由于每拿走一些菜品数量都会减少，因为每次都要用最小的来补充，所以用优先队列存取价格，但是优先不能及时维护菜品数量，所以不能够维护菜品数量 在使用单调队列时，尽量避免结构体的使用 const int N=2e5+5; int n,...
Codeforces Round #536 (Div. 2) A-D题解报告
甦萌的博客
02-01 177
比赛链接：http://codeforces.com/contest/1106 A:数据不大，暴力遍历一遍就行 #include&lt;bits/stdc++.h&gt; using namespace std; string str[505]; int n; int access(int x,int y) { if((y+1)&lt;n &amp;&amp; (y+1)&gt;=0 &...
Codeforces Round #536 (Div. 2)【己亥年农历新年赛】简略题解
周道-Althen的博客
02-15 448
【题目地址】 写在前面 &amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;amp;ThinSpace;\ \ \ \ \ \ \,&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp
Codeforces Round #536 (Div. 2)题解
FLY_WHITE的博客
02-07 341
Codeforces Round #536 (Div. 2)题解 http://codeforces.com/contest/1106 A. Lunar New Year and Cross Counting 解题思路 暴力对全图进行以此搜索即可 AC代码 #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;iostream&gt;...
Codeforces Round #536 (Div. 2)（A,B,C,D）题解
不二君
02-10 493
比赛链接 A. Lunar New Year and Cross Counting Lunar New Year is approaching, and you bought a matrix with lots of "crosses". This matrix MM of size n×nn×n contains only 'X' and '.' (without quotes). Th...
CodeForces Round#536(Div2) 部分题解
Sensente的博客
02-01 234
原来是农历新年专场，但是CF卡的不行。。。始终无法log in。 只能看题目假装自己在OJ。又是八点半的场次。。忘记了时间。 粗略写了两题，今天早上交了AC。   A. Lunar New Year and Cross Counting   题目大意： 简单的字符查找，找一个图案。直接暴力，本来以为会卡时间，但是也过了。 #include &lt;iostream&gt; u...
Tavas and Karafs CodeForces - 536A
CS33sun的博客
12-29 334
Karafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis people love Karafs and they use Karafs in almost any kind of food. Tavas, himself, is crazy about Karafs. Each Karafs has
CodeForces 536A---Tavas and Karafs（二分）
我和我的三只猫
04-11 335
Tavas and KarafsTime Limit:2000MS     Memory Limit:262144KB     64bit IO Format:%I64d &amp; %I64uCodeForces 536ADescriptionKarafs is some kind of vegetable in shape of an 1 × h rectangle. Tavaspolis p...
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级别更...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值