2017-10-2 清北刷题冲刺班a.m

最新推荐文章于 2020-09-20 15:17:43 发布
最新推荐文章于 2020-09-20 15:17:43 发布
阅读量91 收藏
点赞数
原文链接：http://www.cnblogs.com/thmyl/p/7620388.html
版权

一道图论神题

(god)

Time Limit:1000ms   Memory Limit:128MB

 

题目描述

LYK有一张无向图G={V,E}，这张无向图有n个点m条边组成。并且这是一张带权图，只有点权。

LYK想把这个图删干净，它的方法是这样的。每次选择一个点，将它删掉，但删这个点是需要代价的。假设与这个点相连的还没被删掉的点是u1,u2,…,uk。LYK将会增加a[u1],a[u2],…,a[uk]的疲劳值。

它想将所有点都删掉，并且删完后自己的疲劳值之和最小。你能帮帮它吗？

 

输入格式(god.in)

    第一行两个数n,m表示一张n个点m条边的图。

    第二行n个数ai表示点权。

    接下来m行每行三个数u,v，表示有一条连接u,v的边。数据保证任意两个点之间最多一条边相连，并且不存在自环。

 

输出格式(god.out)

你需要输出这个最小疲劳值是多少。

 

输入样例

4 3

10 20 30 40

1 4

1 2

2 3

 

输出样例

40

 

样例解释

一个合理的方法是先删4号点，此时有10点疲劳值。接下来删3号点，获得20点疲劳值，再删2号点，获得10点疲劳值，最后删1号点，没有疲劳值。总计40点疲劳值。

 

对于30%的数据n<=10。

对于60%的数据n,m<=1000。

对于100%的数据1<=n,m,ai<=100000

/*
    贪心
    每次选择权值最大的点删除即可 
*/
#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;
#define maxn 100010
int n,m,head[maxn],w[maxn];
struct node{
    int to,pre,v;
}e[maxn*2];
struct Node{
    int id,val;
    bool operator < (const Node b)const{
        return val<b.val;
    }
};
priority_queue<Node>q;
int qread(){
    int i=0;
    char ch=getchar();
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch<='9'&&ch>='0'){i=i*10+ch-'0';ch=getchar();}
    return i;
}
void Insert(int from,int to,int v,int num){
    e[num].to=to;
    e[num].pre=head[from];
    e[num].v=v;
    head[from]=num;
}
int main(){
    //freopen("Cola.txt","r",stdin);
    freopen("god.in","r",stdin);freopen("god.out","w",stdout);
    n=qread();m=qread();
    Node now;
    for(int i=1;i<=n;i++){
        w[i]=qread();
        now.id=i;now.val=w[i];
        q.push(now);
    }
    int x,y;
    for(int i=1;i<=m;i++){
        x=qread();y=qread();
        Insert(x,y,w[y],i);Insert(y,x,w[x],i+m);
    }
    long long ans=0;
    while(!q.empty()){
        now=q.top();q.pop();
        int cur=now.id;
        for(int i=head[cur];i;i=e[i].pre){
            ans+=e[i].v;
            if(i<=m)e[i].v=0,e[i+m].v=0;
            if(i>m)e[i].v=0,e[i-m].v=0;
        }
    }
    cout<<ans;
    fclose(stdin);fclose(stdout);
    return 0;
}
100分 贪心

 

位运算2

(bit)

Time Limit:1000ms   Memory Limit:128MB

 

题目描述

LYK拥有一个十进制的数N。它赋予了N一个新的意义：不考虑N的符号，将N每一位都拆开来后再加起来就是N所拥有的价值。例如数字123拥有6的价值，数字999拥有27的价值，数字-233拥有8的价值。

假设数字N的价值是K，LYK想找到一个价值是K+1的数字，当然这个答案实在太多了，LYK想使得这个价值为K+1的数字尽可能大，并且需要保证这个数字小于N。

 

输入格式(bit.in)

    一个整数N。

 

输出格式(bit.out)

一个数表示答案。你需要输出一个整数，且这个数不包含前导0。

 

输入样例1

199

 

输出样例1

-299

 

输入样例2

1520

 

输出样例2

1512

 

对于20%的数据|N|<=10

对于40%的数据|N|<=100

对于60%的数据|N|<=10^9

对于80%的数据|N|<=10^1000

对于100%的数据|N|<=10^100000。

#include<iostream>
#include<cstdio>
#include<cstring>
#define maxn 100010
using namespace std;
int bit[maxn],len,f[maxn],w;
char s[maxn];
bool flag=0;
void dfs(int pos,bool limit,int sum){
    if(flag)return;
    if(sum>w)return;
    if(pos==len+1){
        if(sum==w){
            int start=1;
            while(f[start]==0)start++;
            for(int i=start;i<=len;i++)printf("%d",f[i]);
            flag=1;
        }
        return;
    }
    if(limit){
        for(int i=bit[pos];i>=0;i--){
            f[pos]=i;
            dfs(pos+1,limit&&(i==bit[pos]),sum+i);
        }
    }
    else{
        for(int i=9;i>=0;i--){
            f[pos]=i;
            dfs(pos+1,0,sum+i);
        }
    }
}
int main(){
    //freopen("Cola.txt","r",stdin);
    freopen("bit.in","r",stdin);freopen("bit.out","w",stdout);
    scanf("%s",s+1);
    len=strlen(s+1);
    if(s[1]<='9'&&s[1]>='0')for(int i=1;i<=len;i++)bit[i]=s[i]-'0';
    else {
        for(int i=2;i<=len;i++)bit[i]=s[i]-'0';
        bit[1]=-1;
    }
    if(bit[1]!=-1){//n是正数 
        if(bit[len]<=7&&bit[len-1]>0){
            bit[len]+=2;
            bit[len-1]--;
            for(int i=1;i<=len;i++)printf("%d",bit[i]);
            return 0;
        }
        for(int i=1;i<=len;i++)w+=bit[i];
        w++;
        dfs(1,1,0);
        if(flag)return 0;
        int cnt=0;
        while(w){
            if(w>=9){
                f[++cnt]=9;
                w-=9;
            }
            else f[++cnt]=w,w=0;
        }
        printf("-");
        for(int i=cnt;i>=1;i--)printf("%d",f[i]);
    }
    if(bit[1]==-1){//n是负数 
        int now=len;
        while(now>2&&bit[now]==9)now--;
        if(bit[now]!=9){
            bit[now]++;
            printf("-");
            for(int i=2;i<=len;i++)printf("%d",bit[i]);
            return 0;
        }
        else{
            printf("-1");
            for(int i=2;i<=len;i++)printf("%d",bit[i]);
            return 0;
        }
    }
}
80分 暴力 
/*
    全程特判：
    1.最后一位<8，倒数第二位>0，最后一位+2，倒数第二位-1
    2.6368899->6359999
    3.4566544099->4566543992
        从后往前，统计9-a[i]的和，直到>=2。
        再往前，找第一个>0的数，把这个数-1，  再整理下后面的数（一开始全是9...，尽可能大）
*/
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
using namespace std;
char s[100005];
int len,sum,i,j,FLAG;
int main()
{
    freopen("bit.in","r",stdin);
    freopen("bit.out","w",stdout);
        scanf("%s",s); FLAG=0;
        if (s[0]!='-')
        {
        len=strlen(s); sum=0;
        for (i=len-1; i>=0; i--)
        {
            if (s[i]>='1' && sum>=2)
            {
                s[i]=char(s[i]-1);
                sum=2;
                for (j=i+1; j<len; j++)
                {
                    while (sum && s[j]<'9')
                    {
                        sum--;
                        s[j]=char(s[j]+1);
                    }
                }
                int SS=0;
                for (j=i+1; j<len; j++) SS+=s[j]-'0';
                for (j=i+1; j<len; j++)
                {
                    if (SS>=9) {s[j]='9'; SS-=9;} else {s[j]=char(SS+'0'); SS=0;}
                }
                FLAG=1;
                break;
            }
            sum+='9'-s[i];
        }
        if (FLAG)
        {
            for (i=0; i<len; i++) if (s[i]!='0') break;
            for (j=min(len-1,i); j<len; j++) cout<<s[j]; cout<<endl;
            return 0;
        }
        cout<<'-';
        for (i=len-1; i>=0; i--)
        {
            if (s[i]<'9')
            {
                s[i]=char(s[i]+1);
                FLAG=1;
                break;
            }
        }
        if (FLAG)
        {
            for (i=0; i<len; i++) if (s[i]!='0') break;
            for (j=min(len-1,i); j<len; j++) cout<<s[j]; cout<<endl;
            return 0;
        }
        cout<<1;
            for (i=0; i<len; i++) if (s[i]!='0') break;
            for (j=min(len-1,i); j<len; j++) cout<<s[j]; cout<<endl;
        return 0;
        }

        FLAG=0;
        cout<<'-';
        len=strlen(s);
        for (i=len-1; i>=1; i--)
        {
            if (s[i]<'9')
            {
                s[i]=char(s[i]+1);
                FLAG=1;
                break;
            }
        }
        if (FLAG)
        {
            for (i=1; i<len; i++) if (s[i]!='0') break;
            for (j=min(len-1,i); j<len; j++) cout<<s[j]; cout<<endl;
            return 0;
        }
        cout<<1;
            for (i=1; i<len; i++) if (s[i]!='0') break;
            for (j=min(len-1,i); j<len; j++) cout<<s[j]; cout<<endl;
    return 0;
}
100分

 

逆序对

(pair)

Time Limit:1000ms   Memory Limit:128MB

 

题目描述

LYK最近在研究逆序对。

这个问题是这样的。

一开始LYK有一个2^n长度的数组ai。

LYK有Q次操作，每次操作都有一个参数k。表示每连续2^k长度作为一个小组。假设n=4,k=2，则a[1],a[2],a[3],a[4]为一个小组，a[5],a[6],a[7],a[8]为一个小组，a[9],a[10],a[11],a[12]为一个小组，a[13],a[14],a[15],a[16]也为一个小组。

然后LYK对于每个小组都翻转，也就是说原数组会变成a[4],a[3],a[2],a[1],a[8],a[7],a[6],a[5],a[12],a[11],a[10],a[9],a[16],a[15],a[14],a[13]。之后它想求出这2^n个数的逆序对是多少。

因此你需要输出对于每次操作，操作完后这2^n个数的逆序对有多少对。

两个数ai,aj被称为逆序对当且仅当i<j且ai>aj。

 

输入格式(pair.in)

    第一行一个数n。

接下来一行2^n个数ai表示一开始的数组。

接下来一行一个数Q，表示操作的次数。

接下来一行Q个数，表示每次操作的参数k。

 

输出格式(pair.out)

Q行，表示每次操作后的答案。

 

输入样例

2

2 1 4 3

4

1 2 0 2

 

输出样例

0

6

6

0

 

样例解释

第一次操作，{2,1,4,3}->{1,2,3,4}

第二次操作，{1,2,3,4}->{4,3,2,1}

第三次操作，{4,3,2,1}->{4,3,2,1}       

第四次操作，{4,3,2,1}->{1,2,3,4}

 

对于30%的数据n<=10，Q<=10。

对于50%的数据n<=10，Q<=1000。

对于80%的数据n<=10，Q<=200000。

对于100%的数据n<=17，Q<=200000，1<=ai<=2^n。

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define maxn 131073
int n,a[2][maxn],Q,tr[maxn];
long long ans;
int qread(){
    int i=0;
    char ch=getchar();
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch<='9'&&ch>='0'){i=i*10+ch-'0';ch=getchar();}
    return i;
}
long long query(int pos){
    long long res=0;
    while(pos){
        res+=tr[pos];
        pos-=pos&(-pos);
    }
    return res;
}
void add(int pos,int v){
    while(pos<=(1<<n)){
        tr[pos]++;
        pos+=pos&(-pos);
    }
}
int main(){
    //freopen("Cola.txt","r",stdin);
    //freopen("pair.in","r",stdin);freopen("pair.out","w",stdout);
    n=qread();
    for(int i=1;i<=(1<<n);i++)a[0][i]=qread();
    Q=qread();
    int x;
    for(int i=1;i<=Q;i++){
        memset(tr,0,sizeof(tr));
        x=qread();x=(1<<x);
        for(int j=1;j<=(1<<n);j+=x)//区间反转 
            for(int cnt=1,k=j,l=j+x-1;cnt<=x;cnt++,k++,l--)
                a[i&1][k]=a[(i-1)&1][l];
        ans=0;
        for(int j=1;j<=(1<<n);j++){
            ans+=j-1-query(a[i&1][j]);
            add(a[i&1][j],1);
        }
        cout<<ans<<endl;
    }
    fclose(stdin);fclose(stdout);
    return 0;
}
树状数组（考场代码） 
/*
    12345678
    
    [1,4][5,8]
    56781234
    
    [1,2][3,4]   [5,6][7,8]
    78563412
    
    [1,1][2,2]  [3,3][4,4]  [5,5][6,6]  [7,7][8,8]
    87654321
    
    k=4 -> 
    
    把一个对k的翻转操作  转变成对k,k-1,k-2,...,1的平移操作
    平移操作对答案有什么影响
    对3进行平移，[1,4][5,8] -> [5,8][1,4]  对于所有8个数为一组，答案=逆序对个数的最大值-当前答案
    
    1,2,2,3   当前逆序对（只考虑i属于[1,2]，j属于[3,4]的逆序对）=0  逆序对个数的最大值：2*2-相同对数 = 3
    
    2,3,1,2    答案 = 3-0 = 3
    
    记录一下  所有连续2^k个数的当前逆序对个数，以及逆序对个数的最大值。
    每次操作的时候，转变成平移操作
    
    2^4  16
    [x,y] 令 mid=(x+y)/2  对于所有i属于[x,mid]  j属于[mid+1,y]  这样逆序对的个数
    f[1]=[1,2]+[3,4]+[5,6]+...+[15,16]
    f[2]=[1,4]+[5,8]+[9,12]+[13,16]
    f[3]=[1,8]+[9,16]
    f[4]=[1,16]
    
    g来表示最大的逆序对个数 (总共的对数-相同的对数)
    
    对于每次对k进行操作
    n^2*2^n
    while (Q--)
    {
        cin>>k;
        for (int i=1; i<=k; i++) f[i]=g[i]-f[i];
        ans=0;
        for (int i=1; i<=n; i++) ans+=f[i];
        cout<<ans<<endl;
    }
    [1,4]  [5,8]
    
    [5,8]  [1,4]

*/
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>
#include <vector>
using namespace std;
const int N=(1<<17)+5;
long long st[N][20],ST[N][20];
int p[N],i,sum,o,a[N],b[N],n,T,PP,now,j,A,RR[N];
void gb(int l,int r)
{
    if (l==r) return;
    int mid=(l+r)/2;
    gb(l,mid); gb(mid+1,r);
    int i=l,j=mid+1,o=l;
    for (i=l; i<=r; i++) b[i]=a[i];
    for (i=r; i>=mid; i--) {RR[i]=i; if (i!=r && b[i+1]==b[i]) RR[i]=RR[i+1];}
    i=l; j=mid+1;
    while (i<=mid && j<=r)
    {
        if (b[i]<=b[j]) {a[o++]=b[i];if (b[i]==b[j]) ST[l][p[r-l+1]]+=RR[j]-j+1; i++;} else
        {
            a[o++]=b[j]; st[l][p[r-l+1]]+=mid-i+1;

            j++;
        }
    }
    if (i<=mid) for (j=i; j<=mid; j++) a[o++]=b[j]; else
    if (j<=r) for (i=j; i<=r; i++) a[o++]=b[i];
}
long long t[105],TT[105];
int main()
{
    freopen("pair.in","r",stdin);
    freopen("pair.out","w",stdout);
    scanf("%d",&n);
    sum=(1<<n);
    for (i=1; i<=sum; i++) scanf("%d",&a[i]);
    for (i=1; i<=17; i++) p[1<<i]=i;
    gb(1,sum);
    scanf("%d",&T);
    for (i=1; i<=n; i++)
      for (j=1; j<=(1<<n); j+=(1<<i))
      {
          t[i]+=st[j][i];
          TT[i]+=ST[j][i];
      }
    long long ans=0;
    while (T--)
    {
        int Q;
        scanf("%d",&Q);
        for (i=1; i<=Q; i++) t[i]=1ll*(1<<i-1)*(1<<i-1)*(1<<n-i)-TT[i]-t[i];
        for (i=1; i<=n; i++) ans+=t[i];
        printf("%I64d\n",ans); ans=0;
    }
    return 0;
}
100分 区间反转->区间平移

 

转载于:https://www.cnblogs.com/thmyl/p/7620388.html

weixin_30885111
关注
【剑指Offer面试编程题】题目1348：数组中的逆序对--九度OJ
一路向前
12-24 795
本题还是有一定的难度的，首先我们不可能通过遍历的方案来完成，时间复杂度过高。然后我们可以想象，是否我们可以通过分块完成，完成字块的统计后，我们使字块有序，然后继续统计其他字块。最后我们合并统计字块。我们融入一种合并排序的思想，通过小块的统计并有序来构造更大的有序块，直到最后全部合并完成。对于两个有序小块之间包含的逆序对，我们只需要判断有限的组合即可完成统计。
数组中出现逆序对的个数
ZWE7616175的博客
08-22 469
题目： 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007 思路： 最简单的思路就是，双层循环，每次比较，当前元素逆序对的个数加1，最后按要求返回。但OJ只可以过50%，原因是在审题是没有注意输入的的范围。 题目保证输入的数组中没有的...
2017-10-4 清北刷题冲刺班p.m
weixin_30594001的博客
10-04 135
P102zhx a 【问题描述】你是能看到第一题的 friends 呢。——hja两种操作：1、加入一个数。2、询问有多少个数是?的倍数。【输入格式】第一行一个整数?，代表操作数量。接下来?行，每行两个数???,?。其中???表示是哪种操作，第二个?是操作的参数。【输出格式】一行一个整数，代表所有询问答案的异或值。【样例输入】51 21 32 21 62 3【样例输出】3【数据范围与规定】对于...
LeetCode 剑指offer Q51数组中的逆序对个数
c630565685的博客
04-11 254
思路 暴力解法很简单但是效率很低，通不过。 通过归并排序进行统计逆序的个数。 首先归并排序包括划分和合并两个步骤。合并就是将两个已经排好序的子数组进行有序合并。有序合并的代码是一个简单题。就是从头到尾俩俩比较即可。 if(left[i]<=right[j]){ 如果是左边的比右边的小，则为升序，直接放入一个临时数组即可。 }else{ 此时为逆序,left[i]>right[j]，则需...
数组中的逆序对--编程题
m0_46611181的博客
06-09 317
标题： 【数组中的逆序对】 有一组数，对于其中任意两个数组，若前面一个大于后面一个数字，则这两个数字组成一个逆序对。请设计一个高效的算法，计算给定数组中的逆序对个数。 给定一个int数组A和它的大小n，请返回A中的逆序对个数。保证n小于等于5000。 测试样例： 输入描述： [1,2,3,4,5,6,7,0],8 输出描述： 返回：7 ...
2017-10-4 清北刷题冲刺班a.m
weixin_30856725的博客
10-04 198
P101zhx a 【问题描述】你是能看到第一题的 friends 呢。——hjaHja 拥有一套时光穿梭技术，能把字符串以超越光速的速度传播，但是唯一的问题是可能会 GG。在传输的过程中，可能有四种情况：1、字符串没有发生改变。2、字符串的某一位由 0 变 1 或者由 1 变 0。3、某一位消失了。4、多了一位。为了防止字符串 GG，Hja 保证发送的字符串只由 01 组成，并且所有字符串开...
2020哈工大深圳学硕上岸，控制原理133，英一84.
Pilgrim0的博客
09-20 1520
本文一共1万字，分为综述、数一篇、英一篇、控制原理篇（哈工大）、政治篇以及考试篇。之前在考研帮发过一次，不知道为什么被删了，在这边再发一次。 综述 考研什么时候开始呢？个人认为三月份比较好，寒假开始亦可，暑假开始相对比较晚了，基础不好不建议。开始的早好处非常多，容错率高，即使走了弯路也有时间改正，复习得更全面，而且后期心态好，不容易崩。至于有人认为战线拉太长导致后期乏力，这个问题，我认为大家都有，暑假开始复习，到了十一月份可能也很难顶，不想学习。而且对于基础不太好，学习能力不强的同学，如果晚开始，学到九月份
2020中传计算机专硕考研经验贴
文艺圈不知名刘先生
05-29 3890
2020中传计算机专硕考研经验贴劝退环节初试部分英语一数学一政治数据结构复试部分总成绩构成专业知识与综合素养部分英语听说能力部分复试名单问题写在最后 本文仅仅是我个人的经验贴，记录下考研总结和反思，如果能给你带来一点收获，那就太好了。 对了，纯主观，不接受反驳，爱看看，不看滚。 劝退环节 ​ 如果你还没考虑好是不是要考中传，那下面这些点可能会直接把你劝退，如果很坚决的想考，那么这些也一定要知道。我只拿专硕举例，学硕我也没什么发言权。 优先一志愿问题：官网写的调剂和一志愿分别排名，优先一志愿。
梦里不觉秋已深
Ab.Ever
10-30 1511
一篇长长的文字堆砌
南大算法设计与分析课程OJ答案代码（2）最大子序列和问题、所有的逆序对
weixin_30237281的博客
03-24 353
问题 A: 最大子序列和问题 时间限制: 1 Sec内存限制: 4 MB提交: 184解决: 66提交状态算法问答 题目描述 给定一整数序列 a1, a2, …, an，求 a1~an 的一个子序列 ai~aj，使得从 ai 到 aj 的和最大。 只需要求出最大子序列的和，而不需要求出最大的那个序列。 ...
A1078. 逆序对个数
cyh
01-21 731
问题描述 　　在一个数列(a1, a2, a3, …, an)中，对于1aj，则称(i,j)是一个逆序对。 　　如在数列(3, 1, 5, 2)中，有(1,2), (1,4), (3,4)共3个逆序对。 　　给定一个数列，求数列中的逆序对的个数。 输入格式 　　输入的第一行包含一个正整数n（1 　　第二行包含n个非负整数，为a1,a2,…,an。数列中的每个元素都不大于10
逆变器PQ控制模型、逆变器并网模型（Simulink） 直流侧电压650V～2000V均可 交流测电压为380V 有功功率和无功
10-10
逆变器PQ控制模型、逆变器并网模型（Simulink） 直流侧电压650V～2000V均可 交流测电压为380V 有功功率和无功功率可达10kW或10kVar，甚至更高
SpringBoot+Vue工厂生产设备维护管理系统答辩PPT.ppt
10-10
计算机毕业设计答辩PPT
CPA 税法 马兆瑞 基础班 第10章-本章概述-PPT-8页.pdf
最新发布
10-10
CPA 税法 马兆瑞 基础班 第10章-本章概述-PPT-8页.pdf
CCS软件之工程模板的创建
10-10
工程模板创建的基础文件
nmpc非线性模型预测控制从原理到代码实践 含4个案例 自动泊车轨迹优化； 倒立摆上翻控制； 车辆运动学轨迹跟踪； 四旋翼无人机
10-10
nmpc非线性模型预测控制从原理到代码实践 含4个案例 自动泊车轨迹优化； 倒立摆上翻控制； 车辆运动学轨迹跟踪； 四旋翼无人机轨迹跟踪。
SpringBoot+Vue多媒体素材管理系统答辩PPT.pptx
10-10
计算机毕业设计答辩PPT
cmake-3.30.1-windows-arm64.msi win11 on arm 通过cmake编译&运行C++代码
10-10
cmake-3.30.1-windows-arm64.msi 安装完毕后一定要设置环境变量。 可以参考：https://blog.csdn.net/feng8403000/article/details/142767555
数据结构考研冲刺讲义：逻辑结构与存储方式解析
"2009考研计算机冲刺班数据结构讲义-崔微.doc" 这篇文档是针对准备2009年计算机专业考研的学生所编写的关于数据结构的讲义，作者为崔微。文档旨在帮助考生梳理数据结构的核心概念和重要知识点。 1. 数据结构的定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值