CF-Round600比赛总结

Codeforces Round #600 (Div. 2)

A：Single Push
题意：
给出两个长度相等的数组，你可以将第一个数组的一段区间加上一个大于0的数，并且只有一次操作机会，问可以不可以将第一个数组变成第二个数组。
解题思路：
找出两个数组的不同区域有多少个，计算差值，模拟。
代码如下：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10;
int n,m,k,t,ans,T;
int a[N],b[N];
void solve(){
    scanf("%d",&n);
    ans=t=0;
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    for(int i=1;i<=n;i++){
        scanf("%d",&k);
        b[i]=k-a[i];//b[i]记录差值
    }
    for(int i=1;i<=n;i++){
        if(b[i]<0){printf("NO\n");return;}//差值小于0肯定不合法
        if(!b[i])continue;
        if(b[i]&&!t){
            for(int j=i+1;j<=n;j++){
                if(b[j]&&b[j]!=b[i]){printf("NO\n");return;}
                else if(!b[j]){t=1;i=j;break;}
                i=j;
            }
        }else{//说明有超过两个不同的区域了
            printf("NO\n");return;
        }
    }
    printf("YES\n");
}
int main(){
    scanf("%d",&T);
    while(T--){
        solve();
    }
    return 0;
}

B：Silly Mistake
题意：
给出员工的进出信息，问可不可以将这些信息分解为几块，每一块都符合一天内的规则，开始和结束都是空，每一个人只能先进后出，并且只能进去一次。将满足的方案输出。
解题思路：
用一个变量来存储当前的前缀和，若前缀和为0，说明此时若满足条件即可分割，其次若接受一个大于0的数，判断以经接受的数字中有没有该数，若有且此时前缀和大于0，说明没有方案，若接受一个小于0的数，先判断此时以及接受的数种存不存在该数的相反数，若不存在说明不合法。
代码如下：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10;
int n,m,k,t,ans,T,now;
int a[N],b[N];
void solve(){
    scanf("%d",&n);
    bool is=true;
    set<int>s;//已经读取的数字用set存储，方便查询
    vector<int>v;
    for(int i=1;i<=n;i++){
        scanf("%d",&m);
        now+=m;
        if(!is)continue;
        if(m<0){
            if(!s.count(-m)||(now!=0&&s.count(m))){
                is=false;
            }else if(now==0){
                v.push_back(s.size()+1);
                s.clear();//分割之后set清0
            }else s.insert(m);
        }else {
            if(s.count(m)&&now!=0){
                is=false;
            }else s.insert(m);
        }
    }
    if(s.size())is=false;//还要判断最后集合中还有没有数字
    if(is){
        cout<<v.size()<<endl;
        for(int i=0;i<v.size();i++){
            printf("%d ",v[i]);
        }
    }else cout<<-1<<endl;
}
int main(){
    solve();
    return 0;
}

C：Sweets Eating
题意：
给出n个糖果，每一个糖果都有一个糖度，每一天最多可以吃m个，第i天吃糖果的糖度为i*最初的糖度，问吃i个糖最少的糖度是多少。
解题思路：
先贪心的思路，想要吃i个糖的总糖度最小，那么每一天都要吃最多限度的糖，其次，对于第一天来说，肯定是先吃含糖最少的糖先吃，对于大于1天的糖来说，肯定将含糖最少的放在最后一天吃。在考虑转移，最容易想到的是将糖排序之后，对于吃i个糖先把它分成i/m块，每一块都分别计算糖度累加，这样算法的复杂度是O(n^2/m)的，当m=1，时就是n ^2的复杂度了，肯定超时。然后我们可以通过肉眼观察法看出其实吃到前i块糖的最小含糖量就是前一天的最小含糖量加上，前i块糖的含糖量的和。于是转移方程就是dp[i]=dp[i-m]+a[i]。
代码如下：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=2e5+10;
int n,m,k,t,ans,T,now;
LL a[N],dp[N];
void solve(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%lld",&a[i]);
    sort(a+1,a+1+n);
    for(int i=1;i<=n;i++)a[i]+=a[i-1];//求前缀和
    for(int i=1;i<=n;i++){
        if(i>m)dp[i]=dp[i-m]+a[i];
        else dp[i]=a[i];//第一天就相当于前缀和
    }
    for(int i=1;i<=n;i++)printf("%lld ",dp[i]);
}
int main(){
    solve();
    return 0;
}

D：Harmonious Graph
题意：
给出一个图，若对于任意两个可以到达的两个点，若这两个点之间的所有其它点都可以相互到达，那么就称该图为和谐图。判断给出的图至少添加多少条边才能使给出的图变成和谐图。
思路：
对于两两可以到达的点来说，相当于一个连通块，对于每一个联通块，可以看成多条左右端点不同的区间，所以可以对有交集的区间进行合并，将区间左右端点记录下来，然后对于区间内的所有点来说，判断有多少个联通块，这个地方可以用并查集来做，想要使得所有连通块变为相通，就需要添加联通块的数量减1条边。
代码如下：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=2e5+10;
int n,m,k,t,ans,T,x,y;
int f[N];
vector<int>v[N];
struct edge{
    int l,r;
}q[N];
int fi(int x){return f[x]==x?x:f[x]=fi(f[x]);}
void solve(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)f[i]=i;
    for(int i=1;i<=m;i++){
        scanf("%d%d",&x,&y);
        if(x>y)swap(x,y);//每一条边都用编号小的点指向编号大的点
        f[fi(y)]=f[fi(x)];//并查集
        v[x].push_back(y);
    }
    int L=1,R=1;
    for(int i=1;i<=n;i++){//合并联通块的区间
        for(int j=0;j<v[i].size();j++)R=max(R,v[i][j]);
        if(R<=i){
            q[T++].l=L;
            q[T-1].r=R;
            L=i+1;
            R=i+1;
        }
    }
    int now=0,index=0;
    for(int i=1;i<=n&&index<T;i++){
        if(f[i]==i)now++;//判断联通块的数量
        if(i>=q[index].r){//若当前节点等于区间右端点值了，说明该区间信息统计完成，累加答案
            ans+=(now-1);
            now=0;
            index++;//下一个区间
        }
    }
    cout<<ans<<endl;
}
int main(){
    solve();
    return 0;
}

E：Antenna Coverage
题意：
给出一条直线上的n盏灯，每一盏灯都有一个照亮的范围，问你可以花费以块钱将任意一盏灯的左右范围加1，问最小多少花费可以使得长为m的路全部被照亮。
解题思路：
设dp[i]为前长度为i的道路照亮所需要的最小花费，对于位置i来说若有一盏灯覆盖到了它，那么dp[i]=min(dp[i],dp[i-1])，若灯照亮的位置左端点r小于i那么转移方程为dp[i]=min(dp[i],dp[max(0,l-(i-r)-1)]+i-r)，用该盏灯的左端点向左延申i-r个位置需要的最小花费转移过来，max(0,l-(i-r)-1)是因为，有可能减成负数，-1的原因是照亮的是区间。
代码如下：

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=1e5+10;
int n,m,k,ans;
int a[85][2],dp[N];
void solve(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%d%d",&a[i][0],&a[i][1]);
    for(int i=1;i<=m;i++){
        dp[i]=i;//到第i个位置最大花费也只能是i
        for(int j=1;j<=n;j++){
            int l=a[j][0]-a[j][1],r=a[j][0]+a[j][1];
            if(l<=i&&r>=i)dp[i]=min(dp[i],dp[i-1]);//被覆盖了
            if(r<i)dp[i]=min(dp[i],dp[max(0,l-(i-r)-1)]+i-r);
        }
    }
    printf("%d\n",dp[m]);
}
int main(){
    solve();
    return 0;
}