Codeforces Gym 2015 ACM Arabella Collegiate Programming Contest

最新推荐文章于 2019-03-19 00:00:00 发布
最新推荐文章于 2019-03-19 00:00:00 发布
阅读量2.7k 收藏
点赞数
分类专栏： Codeforces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quailty/article/details/47078009
版权

比赛链接：

http://codeforces.com/gym/100676

题目链接：

http://codeforces.com/gym/100676/attachments/download/3333/acm-arabella-collegiate-programming-contest-en.pdf


A. Relational Operator

直接模拟，复杂度O(1)。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
int main()
{
    int T;
    scanf("%d",&T);
    int a,b;
    char c[5];
    while(T--)
    {
        scanf("%d%s%d",&a,c,&b);
        if(strlen(c)==1)
        {
            if(c[0]=='<')printf("%s\n",(a<b ? "true" : "false"));
            else printf("%s\n",(a>b ? "true" : "false"));
        }
        else
        {
            if(c[0]=='!')printf("%s\n",(a!=b ? "true" : "false"));
            else if(c[0]=='=')printf("%s\n",(a==b ? "true" : "false"));
            else if(c[0]=='<')printf("%s\n",(a<=b ? "true" : "false"));
            else printf("%s\n",(a>=b ? "true" : "false"));
        }
    }
    return 0;
}

B. Three Angles

判断三个角度是否均为正且和为180即可，复杂度O(1)。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
int main()
{
    int T;
    scanf("%d",&T);
    int a,b,c;
    while(T--)
    {
        scanf("%d%d%d",&a,&b,&c);
        printf("%s\n",(a>0 && b>0 && c>0 && a+b+c==180 ? "YES" : "NO"));
    }
    return 0;
}

C. Memory is Full

贪心，先移除占用内存较大的软件，复杂度O(nlogn)。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;
int a[105];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int k,m,n;
        scanf("%d%d%d",&k,&m,&n);
        int sum=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        int emp=k-sum;
        if(emp>=m)
        {
            printf("0\n");
            continue;
        }
        sort(a+1,a+n+1,greater<int>());
        for(int i=1;i<=n;i++)
        {
            emp+=a[i];
            if(emp>=m)
            {
                printf("%d\n",i);
                break;
            }
        }
    }
    return 0;
}

D. Sudoku

直接模拟，复杂度O(1)。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
char s[15][15];
bool vis[15];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        for(int i=0;i<9;i++)scanf("%s",s[i]);
        bool isok=1;
        for(int i=0;i<9;i++)
        {
            bool flag=1;
            memset(vis,0,sizeof(vis));
            for(int j=0;j<9;j++)vis[s[i][j]-'1']=1;
            for(int j=0;j<9;j++)flag&=vis[j];
            isok&=flag;
        }
        for(int i=0;i<9;i++)
        {
            bool flag=1;
            memset(vis,0,sizeof(vis));
            for(int j=0;j<9;j++)vis[s[j][i]-'1']=1;
            for(int j=0;j<9;j++)flag&=vis[j];
            isok&=flag;
        }
        for(int i=0;i<9;i+=3)
            for(int j=0;j<9;j+=3)
            {
                memset(vis,0,sizeof(vis));
                for(int p=i;p<i+3;p++)
                    for(int q=j;q<j+3;q++)
                        vis[s[p][q]-'1']=1;
                bool flag=1;
                for(int p=0;p<9;p++)flag&=vis[p];
                isok&=flag;
            }
        printf("%s\n",(isok ? "Valid" : "Invalid"));
    }
    return 0;
}

E. Time Limit Exceeded?

记下每个数出现的次数，维护前缀和后可以O(1)计算每个数作为较小数时的贡献，复杂度O(n)。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
int cnt[10005],pre[10005];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        int in;
        memset(cnt,0,sizeof(cnt));
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&in);
            cnt[in]++;
        }
        for(int i=1;i<=10000;i++)pre[i]=pre[i-1]+cnt[i];
        int ans=0;
        for(int i=1;i<=10000;i++)
        {
            ans+=cnt[i]*(cnt[i]-1)/2;
            ans+=cnt[i]*(pre[min(10000,i+31)]-pre[i]);
        }
        printf("%d\n",ans);
    }
    return 0;
}

F. Palindrome

若s[i]与s[j]相同，则将s[i]与s[j]合并到同一集合中，并选取集合的代表元素，可以利用并查集维护，

在选取代表元素时，若集合中只有"?"，则选"?"为代表元素，否则任意选取一个不为"?"的字符，

完成合并过程后，逐个检查元素及其代表元素是否一致，并统计元素全为"?"的集合个数，复杂度O(nlogn)。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
const int MAXN=50005;
const int Mod=1000000007;
int fast_pow(int a,int k)
{
    int res=1;
    while(k>0)
    {
        if(k&1)res=1LL*res*a%Mod;
        a=1LL*a*a%Mod;
        k>>=1;
    }
    return res;
}
char s[MAXN];
int p[MAXN];
bool vis[MAXN];
void Init(int n)
{
    for(int i=0;i<n;i++)p[i]=i;
}
int Find(int x)
{
    return x==p[x] ? x : p[x]=Find(p[x]);
}
void Union(int x,int y)
{
    x=Find(x);
    y=Find(y);
    if(x==y)return;
    if(s[x]=='?')p[x]=y;
    else p[y]=x;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n,m;
        scanf("%d%d",&n,&m);
        scanf("%s",s);
        Init(n);
        for(int i=0;i<n/2;i++)
            Union(i,n-1-i);
        int x,y;
        while(m--)
        {
            scanf("%d%d",&x,&y);
            Union(x-1,y-1);
        }
        bool isok=1;
        int cnt=0;
        memset(vis,0,sizeof(vis));
        for(int i=0;i<n;i++)
        {
            int t=Find(i);
            if(s[t]=='?')
            {
                if(!vis[t])
                {
                    vis[t]=1;
                    cnt++;
                }
            }
            else isok&=(s[t]==s[i] || s[i]=='?');
        }
        if(isok)printf("%d\n",fast_pow(26,cnt));
        else printf("0\n");
    }
    return 0;
}

G. Training Camp

状压dp，用dp[s]表示选取了s集合的最大收益，

根据拓扑序检验状态合法性并进行转移即可，复杂度O(n*2^n)。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<sstream>
#include<algorithm>
#include<string>
#include<vector>
#include<map>
using namespace std;
map<string,int>mp;
string s[25];
int w[25],dp[1<<18];
vector<pair<int,int> >e;
bool used[25],in[25];
void init()
{
    e.clear();
    mp.clear();
}
int main()
{
    ios::sync_with_stdio(false);
    stringstream ss;
    int T;
    cin>>T;
    while(T--)
    {
        int n,m;
        cin>>n>>m;
        string str;
        getline(cin,str);
        init();
        for(int i=1;i<=n;i++)
        {
            w[i]=0;
            getline(cin,str);
            ss.clear();
            ss.str(str);
            string name="",word="";
            while(ss>>word)
            {
                if(word[0]>='0' && word[0]<='9')
                    for(int j=0;j<word.size();j++)
                        w[i]=w[i]*10+word[j]-'0';
                else name+=word+" ";
            }
            mp[name]=i;
        }
        /*
        for(int i=1;i<=n;i++)
            cout<<s[i]<<" "<<w[i]<<endl;
        */
        for(int i=1;i<=m;i++)
        {
            getline(cin,str);
            ss.clear();
            ss.str(str);
            string name="",word="";
            int st,ed;
            while(ss>>word)
            {
                if(word[0]=='-')
                {
                    st=mp[name];
                    name.clear();
                }
                else name+=word+" ";
            }
            ed=mp[name];
            e.push_back(make_pair(st,ed));
        }
        memset(dp,0,sizeof(dp));
        for(int mask=0;mask<(1<<n);mask++)
        {
            memset(used,0,sizeof(used));
            int day=1;
            for(int i=0;i<n;i++)
                if(mask&(1<<i))
                {
                    day++;
                    used[i+1]=1;
                }
            bool isok=1;
            for(int i=0;i<e.size();i++)
                if(!used[e[i].first] && used[e[i].second])
                {
                    isok=0;
                    break;
                }
            if(!isok)continue;
            memset(in,0,sizeof(in));
            for(int i=0;i<e.size();i++)
                if(!used[e[i].first])
                    in[e[i].second]=1;
            for(int i=0;i<n;i++)
                if(!used[i+1] && !in[i+1])
                    dp[mask|(1<<i)]=max(dp[mask|(1<<i)],dp[mask]+day*w[i+1]);
        }
        cout<<dp[(1<<n)-1]<<endl;
    }
    return 0;
}

H. Capital City

双连通分量缩点，对得到的树进行两次bfs得到直径，然后枚举直径上的点求出重心，

考虑到可能有重边以及自环，需要进行去重，

去重时利用并查集维护，如果两个点之间有多条路径，则将这两个点合并为一个点，

由于要输出最小的标号，还需要选取每个集合中标号最小的点作为代表元素，复杂度O(nlogn+mlogm)。

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
const int MAXN=100005;
const int MAXM=400005;
const int INF=0x3f3f3f3f;
//BCC
struct Edge
{
    int to,next,cost;
    bool cut;
}edge[MAXM];
int head[MAXN],tot;
int Low[MAXN],DFN[MAXN],Stack[MAXN],Belong[MAXN];
int Get[MAXN];
int Index,top;
int block;
bool Instack[MAXN];
int bridge;
void addedge(int u,int v,int cost)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    edge[tot].cut=0;
    edge[tot].cost=cost;
    head[u]=tot++;
}
void Tarjan(int u,int pre)
{
    int v;
    Low[u]=DFN[u]=++Index;
    Stack[top++]=u;
    Instack[u]=1;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(v==pre)continue;
        if(!DFN[v])
        {
            Tarjan(v,u);
            if(Low[u]>Low[v])Low[u]=Low[v];
            if(Low[v]>DFN[u])
            {
                bridge++;
                edge[i].cut=1;
                edge[i^1].cut=1;
            }
        }
        else if(Instack[v] && Low[u]>DFN[v])
            Low[u]=DFN[v];
    }
    if(Low[u]==DFN[u])
    {
        block++;
        do
        {
            v=Stack[--top];
            Instack[v]=0;
            Belong[v]=block;
        }
        while(v!=u);
    }
}
void init()
{
    tot=0;
    memset(head,-1,sizeof(head));
}
void get_BCC(int n)
{
    memset(DFN,0,sizeof(DFN));
    memset(Instack,0,sizeof(Instack));
    Index=top=block=bridge=0;
    Tarjan(1,0);
    memset(Get,INF,sizeof(Get));
    for(int i=1;i<=n;i++)
        Get[Belong[i]]=min(Get[Belong[i]],i);
}
//DSU
int p[MAXN];
void DSU_Init(int n)
{
    for(int i=1;i<=n;i++)p[i]=i;
}
int DSU_Find(int x)
{
    return x==p[x] ? x : p[x]=DSU_Find(p[x]);
}
void DSU_Union(int x,int y)
{
    x=DSU_Find(x);
    y=DSU_Find(y);
    if(x==y)return;
    p[x]=y;
}
void DSU_Compress(int n)
{
    for(int i=1;i<=n;i++)p[i]=DSU_Find(i);
}
//InputData
struct Input
{
    int u,v,cost;
    Input(){}
    Input(int _u,int _v,int _cost)
    {
        if(_u>_v)swap(_u,_v);
        u=_u;
        v=_v;
        cost=_cost;
    }
    bool operator < (const Input &t)const
    {
        return v==t.v ? u<t.u : v<t.v;
    }
};
set<Input>s;
int vis[MAXN];
int Stand[MAXN];
//Tree
vector<pair<int,int> >e[MAXN];
void Prepare(int n)
{
    for(int i=1;i<=n;i++)e[i].clear();
    for(int i=1;i<=n;i++)
        for(int j=head[i];j!=-1;j=edge[j].next)
            if(edge[j].cut)
            {
                e[Belong[i]].push_back(make_pair(Belong[edge[j].to],edge[j].cost));
                e[Belong[edge[j].to]].push_back(make_pair(Belong[i],edge[j].cost));
            }
}
pair<int,int> pre[MAXN];
ll dis[MAXN];
int BFS(int st)
{
    for(int i=1;i<=block;i++)dis[i]=(1LL<<62)-1;
    queue<int>q;
    q.push(st);
    pre[st].first=pre[st].second=-1;
    dis[st]=0;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=0;i<e[u].size();i++)
        {
            int v=e[u][i].first;
            int c=e[u][i].second;
            if(dis[v]>dis[u]+c)
            {
                q.push(v);
                dis[v]=dis[u]+c;
                pre[v]=make_pair(u,c);
            }
        }
    }
    int loc=st;
    ll Max=0;
    for(int i=1;i<=block;i++)
        if(dis[i]>Max)
        {
            loc=i;
            Max=dis[i];
        }
    return loc;
}
//Main
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        init();
        int n,m;
        scanf("%d%d",&n,&m);
        DSU_Init(n);
        s.clear();
        int a,b,c;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(a==b)continue;
            Input t=Input(DSU_Find(a),DSU_Find(b),c);
            if(s.find(t)==s.end())s.insert(t);
            else DSU_Union(a,b);
        }
        DSU_Compress(n);
        int cnt=0;
        memset(Stand,INF,sizeof(Stand));
        memset(vis,0,sizeof(vis));
        for(int i=1;i<=n;i++)
        {
            int t=DSU_Find(i);
            if(!vis[t])vis[t]=++cnt;
            Stand[vis[t]]=min(Stand[vis[t]],i);
        }
        set<Input>::iterator itr;
        for(itr=s.begin();itr!=s.end();itr++)
        {
            Input t=*itr;
            int t1=DSU_Find(t.u);
            int t2=DSU_Find(t.v);
            if(t1==t2)continue;
            else
            {
                addedge(vis[t1],vis[t2],t.cost);
                addedge(vis[t2],vis[t1],t.cost);
            }
        }
        get_BCC(cnt);
        Prepare(cnt);
        int end1=BFS(1);
        int end2=BFS(end1);
        ll len=dis[end2];
        stack<pair<int,ll> >sst;
        ll now=0;
        sst.push(make_pair(end2,max(now,len-now)));
        for(int i=end2;i!=end1 && i!=-1;i=pre[i].first)
        {
            now+=pre[i].second;
            ll t=max(now,len-now);
            while(!sst.empty() && t<sst.top().second)sst.pop();
            if(sst.empty() || t==sst.top().second)sst.push(make_pair(pre[i].first,t));
        }
        int ans_loc=INF;
        ll ans_pat=sst.top().second;
        while(!sst.empty())
        {
            ans_loc=min(ans_loc,Stand[Get[sst.top().first]]);
            sst.pop();
        }
        printf("%d %I64d\n",ans_loc,ans_pat);
    }
    return 0;
}


quailty
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Codeforces gym模拟赛
06-16
CF gym模拟赛CF gym模拟赛CF gym模拟赛CF gym模拟赛
Codeforces Gym 2015 ACM Arabella Collegiate Programming Contest（二月十日训练赛）
weixin_33726313的博客
02-11 126
A（By talker）： 　　 题意分析：以a(int) op b(int)形式给出两个整数和操作符， 求两个整数是否存在操作符所给定的关系 ，有则输出ｔｒｕｅ，无则输出ｆａｌｓｅ； 思路：由于无时间复杂度的限制，做为 签到题怎么快怎么写（比赛时，赛后 可以考虑尽量压缩代码），裸暴 力，ｉｆ　ｅｌｓｅ拉伸判断每一个就 好了．．处理起来的难点可能是中间字 符的读入处...
ACM Arabella Collegiate Programming Contest 2015 H. Capital City 边连通分量
weixin_34014555的博客
04-21 149
题目链接：http://codeforces.com/gym/100676/attachments 题意： 有 n 个点，m 条边，图中，边强连通分量之间可以直达，即距离为 0 ，找一个点当做首都，其他点到首都的最大距离最小。 参考：http://www.cnblogs.com/ost-xg/p/6395100.html 仔细研究了大佬的思路，很牛逼，但是也有一点细节遗漏了，但是还...
2015 ACM Arabella Collegiate Programming Contest
ddmxynl793173的博客
03-17 143
　　题目链接：https://vjudge.net/contest/154238#overview。 　　ABCDE都是水题。 　　F题，一开始分类讨论，结果似乎写挫了，WA了一发。果断换并查集上，A了。 　　G题，状态压缩DP，不难写，但是时限有点紧，读入也比较恶心。。值得注意的是计算一个数二进制下有几个1可以用__builtin_popcount(mask)；判断a和b在二进制...
2015 ACM Arabella Collegiate Programming Contest（F题）
一点也不二
05-04 1547
题意：给你一个字符串，串中只能出现小写字母和‘?’。'?'可以代替任何小写字母。现在给你m对(x,y)，必须使得第x个字符和第y个字符相同，并且该字符串必须为回文串。现在问组成回文串的方案数。
【容斥】2017 ACM Arabella Collegiate Programming Contest
测试
03-19 211
比赛连接G. Snake RanaOld Macdonald wants to build a new hen house for his hens. He buys a new rectangular area of size N by M. The night before he builds the hen house, sna...
ICPC-ACM_C++_Codeforces_
09-30
【ICPC-ACM】ICPC（International Collegiate Programming Contest）是全球最知名的大学生程序设计竞赛，旨在提升学生的问题解决和团队合作能力。ACM是ICPC的前称，两者现在通常并用，代表了同一项赛事。 在解题...
codeforces-ACM竞赛题目-2833道.tgz
10-25
codeforces-ACM竞赛题目-2833道.tgz
ProgrammingContest
03-09
1. LeetCode、HackerRank、Codeforces等在线平台提供丰富的编程题目，可用来练习和提升编程能力。 2. "算法图解"、"Python算法导论"等书籍，帮助深入理解算法和数据结构。 3. Python官方文档和社区论坛，如Stack ...
Codeforces:解决Codeforce问题的方法
05-01
解决问题的方法教育Codeforces回合101 - 2/6 常规托架顺序-接受红色和蓝色-接受Codeforces回合＃686（Div.3） 2/6 特殊排列-接受唯一出价拍卖-接受序列转换-接受编号成序列-接受Codeforces回合＃685（分区2） 2/7 减...
G - Galactic Collegiate Programming Contest（Gym - 101572G 树状数组）
remember_your_dream的博客
07-24 462
题意：一场比赛，每次有队伍做出一题就输出队伍1的排名。题量多的排名前，相同题量罚时少靠前，如果题量罚时都相同，排名一样，排名是指成绩比它好的队伍数。给出n个队伍、m个事件，下面m行t p 表示队伍t做出一题，罚时为p。思路：设得分为(a,b)表示做出a题，罚时为b。先读入所有的事件，存下所有可能的得分。然后对其按规则排序，建立树状数组，结点保存每个得分的队伍数，那么...
2017-2018 ACM-ICPC, NEERC Problem G Galactic Collegiate Programming Contest（树状数组）
yuki4503
10-20 322
ccpc哈尔滨站前在网吧的小练习…其实做了一半就去吃饭了题意http://codeforces.com/gym/101572/attachments宇宙acm比赛，n个队(1e5),m个事件(1e5)。每次事件，代表某个队伍做出一道题。给出这个队的编号和这题的罚时。排名按照ac数多的排名靠前，相同ac数罚时少的靠前来定。每次操作输出一次第1个队的排名思路把所有出现过的状态(ac数，罚时)存下来，离散
Codeforces Gym 2015 ACM Amman Collegiate Programming Contest
quailty's
07-20 2989
比赛链接： http://codeforces.com/gym/100712 题目链接： http://codeforces.com/gym/100712/attachments/download/3454/acm-amman-collegiate-programming-contest-en.pdf A. Who Is The Winner? 直接排序，复杂度O(nlo
GYM - 101572G Galactic Collegiate Programming Contest 离散化 + 线段树或树状数组
litmxs的博客
10-15 751
题目链接: GYM - 101572题目大意一场比赛, 每个队伍的分数由(a, b)组成, a是做题数量, b是总罚时, 题量多的排名前, 相同题量罚时少靠前, 如果题量罚时都相同, 排名一样, 例如, (1, 1), (1, 1), (0, 0)三支队伍排名为1, 1, 2 现在有n支队伍, m个事件, 每个事件由(t, p)组成, 代表队伍t以罚时p做出了一题 让你输出每个事件后, 队伍1的
[NCPC2017]Galactic Collegiate Programming Contest
qq_41652258的博客
08-30 351
题目描述 One hundred years from now, in 2117, the International Collegiate Programming Contest (of which the NCPC is a part) has expanded significantly and it is now the Galactic Collegiate Programming Co...
2015 ACM Amman Collegiate Programming Contest 简要题解。
u011481752的专栏
09-19 1007
抱LF巨巨和LC巨巨的大腿打了一场康复性训练。12题做了10题。。。然而水题一大堆。 讲讲简要题解。 A：两个关键字的结构体排序。 B：N^2的枚举，O(N)的计数，最后再加上前缀和的思想（N^2枚举过程中利用三个先前的计数的前缀和进行最值的维护）。 C：模拟，处理好当前有的灯可以照亮的地方，标记好，LF在这里纱布了一下，直接把可以照亮的地方又变成了灯，结果当即被我给槽了。处理完后直接三个一
quailty's Contest #1 题解
quailty's
02-05 3288
比赛链接： http://www.bnuoj.com/v3/contest_show.php?cid=7561A. 道路修建 如果使用可持久化并查集，二分答案判定连通性，复杂度是O(mlog^3n)，不能在时限内出解。考虑到并查集实际上是一棵树，可以尝试在边上维护一些信息，假设t时刻加了一条边(u,v)，若u和v此时未连通，则在root(u)和ro
hihoCoder挑战赛14 A题 1223
duxinyuhi的专栏
10-05 529
时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 给定n个关于X的不等式，问最多有多少个成立。 每个不等式为如下的形式之一： X X X = C X > C X >= C 输入 第一行一个整数n。 以下n行，每行一个不等式。 数据范围: 1 输出 一行一个整数，
Galactic Collegiate Programming Contest
fx714848657的博客
09-07 225
这题虽然说是模板题，但是确实有很多地方第一次学有点难懂。 先看一下树状数组的介绍： https://blog.csdn.net/flushhip/article/details/79165701 https://www.cnblogs.com/George1994/p/7710886.html   本题参考博客： https://blog.csdn.net/a664607530/art...
ACM刷codeforces指南
最新发布
10-06
ACM刷Codeforces的指南可以从以下几个步骤开始： 1. 首先，了解Codeforces的比赛规则，可以参考[这篇文章](https://codeforces.com/blog/entry/456)和[这篇文章](https://codeforces.com/blog/entry/4088)。 2. 接...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值