【题解】Codeforces Round #600(Div.2)

Codeforces Round #600(Div.2)

https://codeforces.com/contest/1253/problem

A.Single Push

思路：数组各位相减，得到b-a之后的。如果全为0，或者只有一段非0且数字相同则可行，否则不可行。具体实现的话，可以左右两边指针向中间搜到第一个不为0的数，再判断中间是否均为同一个数。复杂度\(O(n)\)。

注意：多组数据一定要判断是否需要清空。这里我a[n+1]没有清0，结果WA on test55……

AC代码：

#include<bits/stdc++.h>
using namespace std;
const int M=1e5+20;
int a[M];
int main(){
    int T;
    scanf("%d",&T);
    for (int z=1;z<=T;++z){
        int n;
        scanf("%d",&n);
        for (int i=1;i<=n;++i)
            scanf("%d",&a[i]);
        a[n+1]=0;
        int c;
        for (int i=1;i<=n;++i){
            scanf("%d",&c);
            a[i]-=c;
        }
        bool v=true;
        int l=1,r=n;
        while(l<=n&&a[l]==0)
            ++l;
        while(r>l&&a[r]==0)
            --r;
        int std=a[l];
        if (std>0)
            v=false;
        else
            for (int i=l;i<=r;++i)
                if (a[i]!=std){
                    v=false;
                    break;
                }
        if (v)
            printf("YES\n");
        else
            printf("NO\n");
    }
    return 0;
}

B.Silly Mistake

思路：可以用unordered_set记录目前在office里面的人，用unordered_map来记录一个人是否进入过office。对于每个event，如果为正，则判断一下是否之前已经进入过，如果已经进入过则非法，否则就记录这个人为1，并加入set；如果为负，则先判断一下是否在set里，如果没有则非法，否则就删掉这个人，这里再判断一下office是否空了，如果空了就直接当做一天结束（因为题目说天可以随便划分）。复杂度\(O(n)\)。

注意：

  1. \(O(1)\)清空STL：直接建一个相同的，每次直接st=st0；
  2. 很多情况可以用unordered_set和unordered_map来优化复杂度（去掉log），不过小心被卡掉（哈希）。不过可以想办法保证不被卡掉，大概意思是自己写一个随机化的哈希，详情见neal的博客（cf上）。

AC代码：

#include<bits/stdc++.h>
using namespace std;
const int M=2e6+20,P=1e6;
vector<int> vec;
unordered_set<int> st;
unordered_map<int,int> mp,mp0;
int c[M];
int main(){
    int n;
    scanf("%d",&n);
    bool v=true;
    for (int i=1;i<=n;++i)
        scanf("%d",&c[i]);
    for (int i=1;i<=n;++i){
        if (c[i]>0){
            if (mp[c[i]+P]){
                v=false;
                break;
            }
            else
                st.insert(c[i]),mp[c[i]+P]=1;
        }
        else{
            if (st.count(-c[i])){
                st.erase(-c[i]);
                if (st.empty())
                    vec.push_back(i),mp=mp0;
            }
            else{
                v=false;
                break;
            }
        }
    }
    if (!st.empty())
        v=false;
    if (!v)
        printf("-1\n");
    else{
        printf("%d\n%d",vec.size(),vec[0]);
        for(int i=1;i<vec.size();++i)
            printf(" %d",vec[i]-vec[i-1]);
    }
    return 0;
}

C.Sweets Eating

思路：首先贪心很容易想到，每次总是先吃\(a_i\)更大的糖，这样总penalty最少。但题目要求输出k=1-m的所有情况。举几个例子之后可以发现，只要从小到大排序，那么k每增加1，答案会加上排序后的\(a[k\%m],a[k\%m+m],a[k\%m+2m]……\)，下标不大于k。那么只要先排个序，之后再预处理每个\(k\%m\)的前缀和，再扫一遍输出答案即可。复杂度\(O(nlogn)\)。

注意：不开LL见祖宗。

AC代码：

#include<bits/stdc++.h>
#define LL long long
using namespace std;
const int M=2e5+20;
int a[M];
vector<LL> mmd[M];
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;++i)
        scanf("%d",&a[i]);
    sort(a+1,a+n+1);
    for(int i=0;i<m;++i){
        int j=1;
        mmd[i].push_back(a[i]);
        while(j*m+i<=n)
            mmd[i].push_back(mmd[i][j-1]+a[j*m+i]),++j;
    }
    LL ans=a[1];
    printf("%lld",ans);
    for (int i=2;i<=n;++i){
        ans+=mmd[i%m][i/m];
        printf(" %lld",ans);
    }
    putchar('\n');
    return 0;
}

D.Harmonious Graph

思路：这道题可以发现，题目的描述等价于：如果l到r有一条路径，那么l,r之间所有点都必须是连通的。那么我们可以想到用并查集（dsu）来处理。

首先遍历每一条边进行合并，之后再扫一遍将每个集合找出来，记录每个集合的元素个数cnt，最小点序号mn和最大点序号mx。

如果mx-mn+1=cnt，那么说明这个集合中的元素为mn\(\sim\)mx，满足了题意条件。

如果mx-mn+1<cnt，那么说明有些点在其他的集合里，我们必须要将这两个集合连起来才可以把缺失的点放进来。那么连接两个集合只需要添加一条边，直接答案加1即可。

当然，连接完之后的集合变大了，可能仍然不满足mx-mn+1=cnt，那么就继续上述步骤直到满足了该条件为止。当所有的集合都满足条件之后，就输出答案即可。

那么怎么来找到缺失的点所在的集合呢？我们对每个并查集只记录cnt,mn,mx，将所有并查集按照mn从小到大排序。若第i个集合不满足条件，那么肯定会缺失第i+1个集合的mn点，就将i和i+1集合合并，如果不满足就继续合并，直到满足了为止。这可以用优先队列来实现。

复杂度为并查集和优先队列的\(O(nlogn)\)，实现常数有点大，不过140ms过掉了。

注意：好像有\(O(n+m)\)的做法……回头看Tutorial吧。

AC代码：

#include<bits/stdc++.h>
using namespace std;
const int M=2e5+20;
int road[M];
int fnd(int x){
    return (x==road[x])?x:road[x]=fnd(road[x]);
}
void merge(int u,int v){
    road[fnd(u)]=fnd(v);
}
struct Bcj{
    int mn,mx,cnt;
    Bcj(int a=1e9+7,int b=0,int c=0):mn(a),mx(b),cnt(c){}
    void proc(int i){
        mn=min(mn,i);
        mx=max(mx,i);
        ++cnt;
    }
    void clear(){
        mn=1e9+7;
        mx=cnt=0;
    }
    void merg(Bcj x){
        mn=min(mn,x.mn);
        mx=max(mx,x.mx);
        cnt+=x.cnt;
    }
}bcj[M];
struct cmp{
    bool operator()(Bcj x,Bcj y){
        return x.mn>y.mn;
    }
};
priority_queue<Bcj,vector<Bcj>,cmp> q;
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    int a,b;
    for (int i=1;i<=n;++i)
        road[i]=i;
    for (int i=1;i<=m;++i){
        scanf("%d%d",&a,&b);
        merge(a,b);
    }
    for(int i=1;i<=n;++i)
        bcj[i].mx=bcj[i].mn=i,bcj[i].cnt=1;
    for(int i=1;i<=n;++i)
        if (i!=fnd(i)&&bcj[i].mx)
            bcj[fnd(i)].proc(i),bcj[i].clear();
    //for(int i=1;i<=n;++i)
    //  cout<<bcj[i].mn<<' '<<bcj[i].mx<<bcj[i].cnt<<endl;
    for(int i=1;i<=n;++i)
        if (bcj[i].mx)
            /*cout<<bcj[i].mn<<' '<<bcj[i].mx<<' '<<bcj[i].cnt<<endl,*/q.push(bcj[i]);
    Bcj prs;
    int ans=0;
    while(!q.empty()){
        Bcj prs=q.top();
        q.pop();
        while(prs.cnt!=prs.mx-prs.mn+1){
            prs.merg(q.top());
            q.pop();
            ++ans;
        }
    }
    printf("%d\n",ans);
    return 0;
}

E.Antenna Coverage

题意：一条街道m个点[1,m]，有n个发射站，每个发射站有两个参数\(x_i\)和\(s_i\)，表示发射站位于\(x_i\)，能覆盖\([x_i-s_i,s_i+s_i]\)。我们可以花1coin将每个发射站的\(s_i\)增加1，问最少花费多少coins能够完全覆盖[1,m]。保证两个发射站不会位于同一个地点。\(1\leq n\leq 80\)，\(n\leq m\leq 100000\)。

思路：VP的时候看数据范围猜到了应该是dp，但没想到怎么转移。实际上应该不算很难想。设dp[i]表示覆盖[1,i]的最小花费，那么转移方式有两种：

  1. 从[1,i-1]的方案直接转移过来。如果i处已经被覆盖了，那么dp[i]=dp[i-1]；如果i处没有被覆盖，那么就让覆盖了i-1的那个基站再扩大1，有dp[i]=dp[i-1]+1。
  2. 从右端点<=i的基站转移过来。有dp[i]=min(dp[i],i-ant[j].r+dp[max(2*ant[j].x-i-1,0)])。其中ant[j]表示第j个基站，r表示基站的\(x_j+s_j\)。这一步要枚举所有符合条件的基站，转移复杂度为\(O(n)\)。

答案为dp[m]，判断是否被覆盖需要预先对[1,m]的区间建立vis数组预处理，最坏复杂度是\(O(nm)\)，dp复杂度也是\(O(mn)\)，所以总复杂度是\(O(nm)\)。

注意：

  1. 要增加一个(x=0,s=0)的基站。由于用这个基站去覆盖任何区间的方案都是最差的，因此不会影响答案（每次都取最小值）。
  2. 注意预处理和dp的时候不要越界，左侧最小是0。

AC代码：

#include<bits/stdc++.h>
using namespace std;
const int M=1e5+20;
struct Ant{
    int x,s,l,r;
    Ant(int a=0,int b=0,int c=0,int d=0):x(a),s(b),l(c),r(d){}
    bool operator<(Ant x){
        return r<x.r;
    }
}ant[100];
int dp[M],vis[M];
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;++i){
        int x,s;
        scanf("%d%d",&x,&s);
        ant[i]=Ant(x,s,x-s,x+s);
        for(int j=max(0,x-s);j<=min(m,x+s);++j)
            vis[j]=1;
    }
    dp[0]=0;
    for (int i=1;i<=m;++i){
        if (vis[i])
            dp[i]=dp[i-1];
        else
            dp[i]=dp[i-1]+1;
        for (int j=1;j<=n;++j)
            if (ant[j].r<=i)
                dp[i]=min(dp[i],i-ant[j].r+dp[max(2*ant[j].x-i-1,0)]);
    }
    printf("%d\n",dp[m]);
    return 0;
}

总结

这次把D题做出来了，虽然ABC代码实现和大佬们差不多，但感觉前面写的老有问题，写的有点慢，而且ABC各WA一发，说明写代码的风格和习惯还是不太好，D题想的比较快，表扬自己。E题没想出来其实不太应该，不过当时也是不太想写了。明晚cf争取上1800。

原文地址：https://www.cnblogs.com/diorvh/p/11886557.html

时间： 2024-10-10 17:31:40

【题解】Codeforces Round #600(Div.2)的相关文章

【cf比赛记录】Codeforces Round #600 (Div. 2)

Codeforces Round #600 (Div. 2) ---- 比赛传送门 昨晚成绩还好,AC A,B题,还能上分(到底有多菜) 补了C.D题,因为昨晚对C.D题已经有想法了,所以补起题来也快.(C题TLE了,D题想用并查集没好) A // http://codeforces.com/contest/1253/problem/A /* 如果YES,则b[i] - a[i] 在一个区间里的差肯定是相同的且不小于0 */ #include<iostream> #include<cst

Codeforces Round #600 (Div. 2) E. Antenna Coverage

Codeforces Round #600 (Div. 2) E. Antenna Coverage(dp) 题目链接 题意: m只蚂蚁,每只蚂蚁的位置是\(x_i\),分数是\(s_i\),覆盖范围是\([x_i - s_i; x_i + s_i]\),每个硬币可以使一直蚂蚁的\(s_i\)+1,求覆盖整个\([1;m]\)的最少硬币 思路: \(f[pos][0]\)表示\([1,pos]\)没有被覆盖还要花费的最少硬币,\(f[pos][1]\)表示\([1,pos]\)被覆盖的最小花费硬

题解Codeforces Round #595 (Div. 3)（CF1249）

开题1小时(雾)严重影响我的提交以及做题心情..我刚开题就发现有人阿克了.. 实际上这场div3真心简单良心很休闲. A:送分题,先排序,每次枚举一下这个数可以加到哪个集合里,加进去就行. 1 #include<stdio.h> 2 #include<algorithm> 3 #define it register int 4 #define il inline 5 using namespace std; 6 const int N=1000005; 7 int a[N],o[N

Codeforces Round #600 (Div. 2)

A - Single Push 题意:给数组a和数组b,可以选择一段连续的区间[l,r]使得ai全部加k(k>0)至多一次.求能不能从a变成b. 题解:一开始作差排序去重,然后判断差是不是只有1个(且>=0)或只有两个(且c1=0,c2>0),但这样是错的,比如下面的样例. 1 5 1 1 1 1 1 2 1 2 2 2 因为虽然差都是1但不是连续的区间. 做法是作差,然后判断是否有至多一个正的方波.可以用两个变量,一个记录是否进入了方波,且方波的高是多少.另一个记录是否离开了方波. #

第五天打卡 Codeforces Round #600 (Div. 2)

A题: #include<bits/stdc++.h> using namespace std; #define ll long long const int N = 1e5+10; int a[N],b[N]; int main(){ int t; scanf("%d",&t); while(t--) { int n; scanf("%d",&n); int need = -9999999; bool ok = true; for(in

题解——Codeforces Round #508 (Div. 2) T2 (构造)

按照题意构造集合即可 注意无解情况的判断 #include <cstdio> #include <algorithm> #include <cstring> #include <cmath> #include <vector> #include <map> using namespace std; int n,sum; int main(){ scanf("%d",&n); if(n==1){ printf

题解——Codeforces Round #508 (Div. 2) T1 (模拟)

依照题意暴力模拟即可A掉 #include <cstdio> #include <algorithm> #include <cstring> #include <set> using namespace std; char s[100100]; int n,k,barrel[30]; int main(){ scanf("%d %d",&n,&k); scanf("%s",s+1); for(int i

题解——Codeforces Round #508 (Div. 2) T3 （贪心）

贪心的选取最优解 然后相减好 记得要开long long #include <cstdio> #include <algorithm> #include <cstring> #include <set> #include <queue> #define int long long using namespace std; int ansa=0,ansb=0,posa=1,posb=1,n,a[1000100],b[1000100]; bool c

题解Codeforces Round #597 (Div. 2)

A:送分,裸的gcd. 1 #include<stdio.h> 2 #define il inline 3 #define it register int 4 int T,a,b,d; 5 il void gcd(int a,int b){ 6 if(!b){d=a;return;} 7 gcd(b,a%b); 8 } 9 il void fr(int &num){ 10 num=0;char c=getchar();int p=1; 11 while(c<'0'||c>'