Codeforces Round #611 (Div. 3)简要题解

A. Minutes Before the New Year

题意：求当前时间到0点还有多少分钟

分析：用24*60-当前分钟数。

#include <bits/stdc++.h>
using namespace std;
int main(){
    int t;cin>>t;
    while(t--){
        int h,m;
        cin>>h>>m;
        int time = 60*h+m;
        cout<<24*60-time<<endl;
    }
}

B. Candies Division

题意：给小孩分糖果，要求每个人的糖果差距不能超过1，且糖果数量多的人数小于1半。

分析：先均匀分，然后把剩下的/一半人数的糖果分出去。

#include <bits/stdc++.h>
using namespace std;
int main(){
    int t;cin>>t;
    while(t--){
        int n,k;
        scanf("%d%d",&n,&k);
        int ans = n/k*k;
        n-=ans;
        ans += min(n,k/2);
        cout<<ans<<endl;
    }
}

C. Friends and Gifts

题意：简化一下就是构造一个错排。

分析：简单模拟一下就可以了。

By MonogatariKoi, contest: Codeforces Round #611 (Div. 3), problem: (C) Friends and Gifts, Happy New Year!, #
#include <bits/stdc++.h>
using namespace std;
int main(){
    int n;
    cin>>n;
    vector<int>v(n+1);
    set<int>s;
    int fir = -1;
    for (int i = 0; i < n; ++i) {
        s.insert(i+1);
    }
    for (int i = 1; i <= n; ++i) {
        scanf("%d",&v[i]);
        if(v[i]!=0)s.erase(v[i]);
        if(v[i]==0&&fir==-1)fir=i;
    }
    for (int i = 1; i <= n; ++i) {
        if(v[i]==0){
            if(s.size() == 1){
                if(i==*s.begin()){
                   v[i]=*s.begin();
                   swap(v[i],v[fir]);
                }
                else v[i]=*s.begin();
            }
            else {
                auto it = s.begin();
                while(*it == i)it++;
                v[i]=*it;
                s.erase(it);
            }
 
        }
    }
    for (int i = 1; i <= n; ++i) {
        printf("%d ",v[i]);
    }
}

D. Christmas Trees

题意：n颗树，m个人都在坐标轴上，把n个人放上去，求使得每个人离他最近的树的距离之和最小的方案。

分析：一维bfs一下，然后输出bfs到的前m个点和距离和就可以了。

#include <bits/stdc++.h>
using namespace std;
int a[200004];
int f[2]={-1,1};
map<int,bool>mp;
vector<pair<int,int>>v;
int main() {
    int n=200000,m=200000;
    scanf("%d%d",&n,&m);
    queue<pair<int,int>>q;
    for (int i = 0; i < n; ++i) {
        scanf("%d",&a[i]);
        q.push(make_pair(a[i],0));
        mp[a[i]]=1;
    }
    while(v.size()<m){
        pair<int,int> t = q.front();q.pop();
        for (int i = 0; i < 2; ++i) {
            int x = t.first+f[i];
            if(mp.count(x))continue;
            mp[x]=1;
            v.push_back(make_pair(x,t.second+1));
            q.push(make_pair(x,t.second+1));
        }
    }
    long long ans = 0;
    for (int i = 0; i < m; ++i) {
        ans += v[i].second;
    }
    cout<<ans<<endl;
    for (int i = 0; i < m; ++i) {
        printf("%d ",v[i].first);
    }
    puts("");
}

E. New Year Parties

题意：每个数可以+1，-1或者不变，每个数最多操作一次，求去重之后最多/最少有几个数。

分析：最多显然直接贪心求解，排序之后，优先考虑-1，若已经存在x-1这个数，那么就不变，同样的，否则+1。

最少考虑dp求解，同样排序，dp[i][j]表示第i个数+1/-1/不变的最少方案数，然后线性跑一遍就可以了。

#include <bits/stdc++.h>

using namespace std;
int dp[200004][3][2];//012lmr   0min  1max
int a[200004];

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &a[i]);
    }
    sort(a + 1, a + 1 + n);
    for (int i = 0; i <= n; ++i) {
        for (int j = 0; j < 3; ++j) {
            dp[i][j][0] = 0x3f3f3f;
            dp[i][j][1] = 0;
        }
    }
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 2; ++j) {
            dp[1][i][j] = 1;
        }
    }
    for (int i = 2; i <= n; ++i) {
        for (int j = 0; j < 3; ++j) {
            for (int k = 0; k < 3; ++k) {
                dp[i][j][0] = min(dp[i][j][0], dp[i - 1][k][0] + (a[i] + j != a[i - 1] + k));
                dp[i][j][1] = max(dp[i][j][1], dp[i - 1][k][1] + (a[i] + j != a[i - 1] + k));
            }
        }
    }
    set<int>s;
    a[0]=-1;
    for (int i = 1; i <= n; ++i) {
        if(!s.count(a[i]-1))a[i]--;
        else if(!s.count(a[i]))a[i]=a[i];
        else a[i]++;
        s.insert(a[i]);
    }
    cout << min(min(dp[n][0][0], dp[n][1][0]), dp[n][2][0]) << ' ';
    cout<<s.size()<<endl;
//    cout << max(max(dp[n][0][1], dp[n][1][1]), dp[n][2][1]) << ' ';
}

F. DIY Garland

题意：一颗有根树，点标号1-n，从根节点接入电源，第i个点的亮度是2^i，n-1条边，每条边的重要程度是剪掉这条边后，不能发光的点的亮度之和。然后按照边的重要程度从高到低给出每条边的父亲点，将这棵树复原。

分析：首先，重要程度最高的边的父亲点必然是根，显而易见。其次，最低的边的子点必定是编号最小的叶子结点，第二低的边的子点必定是将之前的叶子节点的权值加到父亲节点上，并且把该叶子节点去掉之后的权值最小的叶子节点。那么我们只需要每次找出权值最小的那个点，就可以把树还原。因为点权是2^i，所以每个点只需记录他的编号最大的儿子就能确定大小关系。

并且显而易见的，叶子节点就是没有在输入中出现的点。

#include <bits/stdc++.h>
using namespace std;
int a[200004];
int b[200004];
int maxi[200004];
int main(){
    int n;
    cin>>n;
    multiset<int>ms;
    set<int>s;
    for (int i = 1; i <= n; ++i) {
        s.insert(i);
        maxi[i]=i;
    }
    for (int i = 1; i < n; ++i) {
        scanf("%d",&a[i]);
        s.erase(a[i]);
        ms.insert(a[i]);
    }
    priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> q;
    for(auto it:s)q.push(make_pair(it,it));
    int pos = n-1;
    while(q.size() && ms.size()){
        pair<int,int>t = q.top();q.pop();
        maxi[a[pos]]=max(maxi[a[pos]],t.second);
        ms.erase(ms.find(a[pos]));
        if(!ms.count(a[pos])){
            q.push(make_pair(maxi[a[pos]],a[pos]));
        }b[pos--] = t.second;
    }
    cout<<a[1]<<endl;
    for (int i = 1; i < n; ++i) {
        printf("%d %d\n",a[i],b[i]);
    }
}