Codeforces Global Round 14题解(A~D)

最新推荐文章于 2021-05-08 22:48:05 发布
最新推荐文章于 2021-05-08 22:48:05 发布
阅读量269 收藏
点赞数 1
分类专栏： Codeforces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yfy20020106/article/details/116372325
版权

写这篇题解的目的主要是自我反思，最近两天一天打的比一天拉。虽然跟状态确实有一定关系，但我觉得这还反应了更多的问题，反应了我各方面的不足。

总结

虽然姑且比赛时做了四道，但是wa了好多，做的也慢，也维护了那一条负斜率。做题经验确实不足，思维水准也不够高。

题解

A. Phoenix and Gold
A题还是蛮简单的，题目大意是让我们将一个数组重新排序，使得按重新排序后的前缀和没有恰好等于x的，如果不能，则输出"NO"，否则输出"YES"以及排序后的数组。
我们只需要贪心的思考即可，分析他给我们的数组，我们直接维护一个当前数组的前缀和，如果遇到一个和为x。我们就需要进行判断，如果当前位存在一个后继，直接交换当前位和后继，这样当前位的前缀和就不在是x，而从下一位开始，前缀和一定大于x (注意题目给定的数组的元素是互不相同的)。如果当前位不存在后继，则数组总和为x，那么我们不论怎么排序，最后的和一定是x。
代码（以下代码可以大大简化因为这里考虑了重复元素，请自行修改，不过我相信你们也不需要）

//#include<bits/stdc++.h> ----万能头----
#include <iostream>
#include<stdio.h>
#include<string>
#include<algorithm>
#include<string.h>
#include<cstring>
#include<cmath>
#include<queue>
#include<list>
#include<map>
#include<unordered_map>
#include<stack>
#include<time.h>
using namespace std;
const int p = 1e9+7;
const int N = 2e4+5;
const int maxn = 1e5+5;
const long long INF = 1e18;
#define REP(i,n) for(ll i = 1; i <= n; ++i)
#define REPA(i,j,n) for(ll i = j; i <= n; ++i)
#define RREP(i,n) for(ll i = n; i >= 1; --i)
#define REPR(i,j,n) for(ll i = n; i >= j; --i)
#define lll __int128
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<double,ll> pdi;
int t;
ll n, m, k;

inline int read(){
    char c=getchar();
    int x=0,f=1;
    while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
    while(isdigit(c))x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x*f;
}

int x[N];
void solve() {
    cin>>n>>m;
    for(int i = 1;  i<=n;++i)cin>>x[i];
    ll sum = 0;
    int pos  = -1;
    for(int i = 1 ; i <= n; ++i){
        sum += x[i];
        if(sum == m){
            pos = i;
            break;
        }
    }
    if(pos == -1){
        cout<<"YES"<<'\n';
        for(int i = 1; i <= n; ++i)cout<<x[i]<<" ";
        cout<<'\n';
        return;
    }
    bool f = 1;
    for(int i = pos + 1; i <= n;++i){//这里昨天考虑了可能重复元素的情况，实际上是没有的
        if(x[i] != x[pos]){
            swap(x[i],x[pos]);
            f = 0;
            break;
        }
    }
    if(f){
        cout<<"NO"<<'\n';
    } else {
        cout<<"YES"<<'\n';
        for(int i = 1; i <= n; ++i)cout<<x[i]<<" ";
        cout<<'\n';
    }


}
int main(){
        //ios::sync_with_stdio(0);
        //cin.tie(0);
        //cout.tie(0);
#ifdef ACM
        freopen("in.txt", "r", stdin);
        freopen("out.txt", "w", stdout);
#endif
        t = 1;
        //srand((unsigned)time(NULL));
        scanf("%lld",&t);
        while (t--)

            solve();

        fclose(stdin);
        fclose(stdout);
}

B. Phoenix and Puzzle
B题呢一开始想的太简单了，虽然所有情况样例确实给出了，但对于边长的情况不知为啥会降智那么多QAQ，导致wa了好多发，后来发现了呢，又因为变量名写错，又wa了几发，导致这题基本没分了(我好菜啊)。
B题是给定我们一个数n，判定是否存在一个正方形由n个等腰直角三角形构成，首先不难想到n必须是偶数，由于我们的大正方形必须是由最小的两个基本正方形构成(即有两个等腰直角或四个等腰直角构成的两个最小正方形)，所以这个数必须是2或者4的倍数，那么思考剩下的数会是什么(n/2或者n/4)，由于我们要构成正方形，那么边长一定是原本最小正方形的若干倍(假设我们现在将最小正方形边长看成一)，可以是两倍，也可以是三倍等等,这样对于每一个边长，我们需要的正方形个数就是边长的平方个。
代码如下

//#include<bits/stdc++.h> ----万能头----
#include <iostream>
#include<stdio.h>
#include<string>
#include<algorithm>
#include<string.h>
#include<cstring>
#include<cmath>
#include<queue>
#include<list>
#include<map>
#include<unordered_map>
#include<stack>
#include<time.h>
using namespace std;
const int p = 1e9+7;
const int N = 2e4+5;
const int maxn = 1e5+5;
const long long INF = 1e18;
#define REP(i,n) for(ll i = 1; i <= n; ++i)
#define REPA(i,j,n) for(ll i = j; i <= n; ++i)
#define RREP(i,n) for(ll i = n; i >= 1; --i)
#define REPR(i,j,n) for(ll i = n; i >= j; --i)
#define lll __int128
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<double,ll> pdi;
int t;
ll n, m, k;

inline int read(){
    char c=getchar();
    int x=0,f=1;
    while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
    while(isdigit(c))x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x*f;
}

int x[N];
void solve() {
    cin>>n;
    if(n & 1){
        cout<<"NO"<<'\n';
        return;
    }
    /*if(n == 4){
        cout<<"YES\n";
        return;
    }*/
    ll tmp = n / 2;
    ll now = sqrt((double)tmp);
    if(now*now == tmp){
        cout<<"YES"<<'\n';
        return;
    }
    if(n % 4 == 0) {
        tmp = n / 4;
        now = sqrt((double) tmp);
        if(now * now == tmp){
            cout<<"YES"<<'\n';
            return;
        }
    }
    cout<<"NO"<<'\n';



}
int main(){
        //ios::sync_with_stdio(0);
        //cin.tie(0);
        //cout.tie(0);
#ifdef ACM
        freopen("in.txt", "r", stdin);
        freopen("out.txt", "w", stdout);
#endif
        t = 1;
        //srand((unsigned)time(NULL));
        scanf("%lld",&t);
        while (t--)

            solve();

        fclose(stdin);
        fclose(stdout);
}


C. Phoenix and Towers
C题更是一言难尽，一开始想复杂了，后来玩了会手机冷静下，就直接过了。。。
C题给了我们n个block(英语水平有限，不敢翻译)，m个tower，每个block有一个高度h，这个高度不大于x，要求我们将n个block用尽，且每个tower都至少有一个block，要保证任意两个tower的高度差不超过x，对于这题，我们不能想的太复杂。我们仔细分析一下，注意到每个block高度不大于x，这个条件有什么用呢？我们分析一个已经合法的序列，去最小值mn，最大值mx，mx-mn<x(这里我就懒得用markdown进行美化了)，如果我们把任意一个block给最小值，mn = mn + h[i] <mn + x，如果这个数依旧小于mx那没有任何问题，如果大于了mx，mn+h[i]-mx<h[i]<x，也就是说，如果我们每次给当前序列的最小值加上一个block，序列依旧是合法的，所以直接优先队列维护即可。
代码如下

//#include<bits/stdc++.h> ----万能头----
#include <iostream>
#include<stdio.h>
#include<string>
#include<algorithm>
#include<string.h>
#include<cstring>
#include<cmath>
#include<queue>
#include<list>
#include<map>
#include<unordered_map>
#include<stack>
#include<time.h>
using namespace std;
const int p = 1e9+7;
const int N = 2e5+5;
const int maxn = 1e5+5;
const long long INF = 1e18;
#define REP(i,n) for(ll i = 1; i <= n; ++i)
#define REPA(i,j,n) for(ll i = j; i <= n; ++i)
#define RREP(i,n) for(ll i = n; i >= 1; --i)
#define REPR(i,j,n) for(ll i = n; i >= j; --i)
#define lll __int128
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<double,ll> pdi;
int t;
ll n, m, k;
struct node{
    ll h;
    ll id;
    ll pos;
    bool operator < (const node & w){
        return id < w.id;
    }
}e[N];
inline int read(){
    char c=getchar();
    int x=0,f=1;
    while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
    while(isdigit(c))x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x*f;
}
ll x;
void solve() {
    cin>>n>>m>>x;
    for(int i = 1; i <= n; ++i){
        cin>>e[i].h;
        e[i].id = i;
    }
    if(n < m){
        cout<<"NO"<<'\n';
        return;
    }
    priority_queue<PII,vector<PII>,greater<PII>> q;
    for(int i = 1; i <= m; ++i){
        q.push({0,i});
    }
    for(int i = 1; i <= n; ++i){
        ll var = q.top().second;
        ll sum = q.top().first;
        q.pop();
        sum += e[i].h;
        e[i].pos = var;
        q.push({sum,var});
    }
   // sort(e+1,e+1+n);
        cout<<"YES"<<'\n';
        for(int i = 1; i <= n; ++i){
            cout<<e[i].pos<<" ";
        }
        cout<<'\n';
    
}
int main(){
        //ios::sync_with_stdio(0);
        //cin.tie(0);
        //cout.tie(0);
#ifdef ACM
        freopen("in.txt", "r", stdin);
        freopen("out.txt", "w", stdout);
#endif
        t = 1;
        //srand((unsigned)time(NULL));
        scanf("%lld",&t);
        while (t--)

            solve();

        fclose(stdin);
        fclose(stdout);
}

D. Phoenix and Socks
u1s1我觉得D题是前4题最简单的
D题直接贪心就完事了，如果当前有正好配对的socks直接移除，然后去分析剩下的，考虑到left sock的数量和right sock的数量可能不一致，(如果剩下的左右数正好相同，代价就是左(右)边的数量，由于证明很简单，请自行证明)，根据对称性，我们只需要分析任意一边数量大的情况，那么我假设左边的sock (直接将sock分成左右两边) 数量大于右边的，我们思考每一个剩下的配对的花费，要么是2，要么就是1，我们贪心的想要获取1，减少2的存在，也就意味着我们需要在左边将适当数量的相同颜色的sock进行配对，这样便是最优的，证明很简单，自行证明，那么问题就解决了。
代码如下

//#include<bits/stdc++.h> ----万能头----
#include <iostream>
#include<stdio.h>
#include<string>
#include<algorithm>
#include<string.h>
#include<cstring>
#include<cmath>
#include<queue>
#include<list>
#include<map>
#include<unordered_map>
#include<stack>
#include<time.h>
using namespace std;
const int p = 1e9+7;
const int N = 2e5+5;
const int maxn = 1e5+5;
const long long INF = 1e18;
#define REP(i,n) for(ll i = 1; i <= n; ++i)
#define REPA(i,j,n) for(ll i = j; i <= n; ++i)
#define RREP(i,n) for(ll i = n; i >= 1; --i)
#define REPR(i,j,n) for(ll i = n; i >= j; --i)
#define lll __int128
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<double,ll> pdi;
int t;
ll n, m, k;
struct node{
    ll h;
    ll id;
    ll pos;
    bool operator < (const node & w){
        return id < w.id;
    }
}e[N];
inline int read(){
    char c=getchar();
    int x=0,f=1;
    while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
    while(isdigit(c))x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x*f;
}
ll l , r;
int lc[N], rc[N];
int c[N];
void solve() {
    cin>>n>>l>>r;
    ll suml = l, sumr = r;
    for(int i = 1; i <= n; ++i)cin>>c[i],lc[i]=0,rc[i] = 0;
    for(int i = 1; i <= l; ++i)lc[c[i]]++;
    for(int i = l + 1; i <= n; ++i){
        rc[c[i]]++;
        if(lc[c[i]]){
            lc[c[i]]--;
            suml--;
            rc[c[i]]--;
            sumr--;
        }
    }
    ll cost = 0;
    if(suml == sumr){
        cout<<suml<<'\n';
        return;
    }
    if(suml < sumr){
        for(int i = l + 1; i <= n; ++i){
            if(rc[c[i]] >= 2){
                int get = rc[c[i]]/2;
                if(sumr - 2*get < suml){
                    cost += (sumr-suml)/2; sumr = suml;
                    break;
                }
                sumr -= 2*get;
                cost += get;
                rc[c[i]] -= 2*get;
            }
        }
        if(suml < sumr){
            ll mid = suml + sumr >> 1;
            cost += sumr - mid;
        }
        cost += ((suml + sumr)>>1);
        cout<<cost<<'\n';
    } else {
        for(int i = 1; i <= l; ++i){
            if(lc[c[i]] >= 2){
                int get = lc[c[i]]/2;
                if(suml - 2*get < sumr){
                    cost += (suml - sumr)/2;
                    suml = sumr;
                    break;
                }
                suml -= 2*get;
                lc[c[i]] -= 2* get;
                cost += get;
            }
        }
        ll mid = (suml + sumr) >> 1;
        if(suml > sumr){
            cost += (suml - mid);
        }
        cost += mid;
        cout<<cost<<'\n';
    }

}
int main(){
        //ios::sync_with_stdio(0);
        //cin.tie(0);
        //cout.tie(0);
#ifdef ACM
        freopen("in.txt", "r", stdin);
        freopen("out.txt", "w", stdout);
#endif
        t = 1;
        //srand((unsigned)time(NULL));
        scanf("%lld",&t);
        while (t--)

            solve();

        fclose(stdin);
        fclose(stdout);
}

由于本人是个菜鸡，写的题解也是菜的一批，请多多谅解QAQ

edini je sam
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces Global Round 7 A. Bad Ugly Numbers
01-03
A. Bad Ugly Numbers 题目链接-A. Bad Ugly Numbers 题目大意 输出一个位数为n的数s，且该数每一位数字都不能被s整除 解题思路 贪心 如果n为1，那么无论s是哪个数字都必定能整除自身 如果n不为n，那么577…77和233...
Codeforces Global Round 7 A. Bad Ugly Numbers（思维）
01-03
传送门 题意： 给一个n，输出一个长度为n的数，这个数不能整数每一位 思路： 2333333333即可 是奇数，所以不能整除2，所有数的和等于3*(n-1)+2，不是3的倍数，所以不能整除3 代码： #include #include ...
Codeforces Global Round 14(A-D)
RIPKEY的博客
05-03 398
求求你了，不要不带脑子提交好不好啊 过三个题wa了十二发:) 希望睡醒来能过系统测试样例⑧ A. Phoenix and Gold 题意：给你一个长度为n的数组，且每个数都不相等，再给你一个数，求排列之后从起点开始到任何一个点的前缀和是否为x，如果是则输出YES和该数组否则输出NO. #include<bits/stdc++.h> using namespace std; const int maxn=105; int a[maxn]; bool cmp(int a,int b){ re
Codeforces Global Round 14（A~D）
好好好，这么写博客是吧
05-08 224
Codeforces Global Round 14 A. Phoenix and Gold time limit per test2 seconds memory limit per test256 megabytes inputstandard input outputstandard output Phoenix has collected n pieces of gold, and he wants to weigh them together so he can feel rich. The i-
Codeforces Global Round 14
CUCUC1的博客
05-03 227
Codeforces Global Round 14 A.Phoenix and Gold 题意:  给定n个数, 问按照什么顺序从左到右将这n个数加起来, 期间不会出现和为x的状态 思路:  首先求一遍数组的和, 如果等于x那么加和过程中一定会出现x这个状态,否则就将原数组从小到大排序, 然后从左到右依次加和,若中间和第一次出现了x, 那么就将当前的数先减去, 加上数组的最后一个,之后再将剩下的依次加起来即可, 如果加和过程中没有出现和为x的情况, 那么就皆大欢喜直接按照这个顺序输出即可 代码 #incl
Codeforces global round 10_Codeforces_
10-01
Codeforces全球第十轮比赛是编程竞赛平台Codeforces举办的一场线上编程比赛，旨在挑战参赛者的算法设计、逻辑思维和编程技巧。在这个比赛中，参赛者通常需要解决一系列算法问题，涵盖数据结构、图论、动态规划、数学...
Codeforces Global Round 7 C. Permutation Partitions
01-03
C. Permutation Partitions 题目链接-C. Permutation Partitions 题目大意 给定一个 1−n 上的全排列，将这个全排列分成不相交的 k 段，定义该划分的value为各段最大值的和，求该全排列所有可能划分中 value的...
Codeforces 1925D Good Trip 题解
最新发布
02-03
Codeforces 1925D Good Trip 题解
【Codeforces Global Round 14】Codeforces-1515 ABCD
JophieQu的博客
05-03 807
A. Phoenix and Gold A题简直绝了。写错几个细节居然过了样例，wa了几发才发现，最后一步忘记输出“YES”，又wa了几发才发现，我菜死了，QAQ 先将数组降序排序，显然的，如果a[0]>x，那么直接输出排序后的数组即可。 降序排序的时候，假若有前k（k<n)个数字的和恰好等于x，那么就向右交换(显然不可能向左交换)的那个数。 举个栗子： n=5,x=9 5 4 3 2 1 当k=2时，恰好5+4=9 == x，交换后有5 3 4 2 1，此时当k=2时sum<x,k=3时
Codeforces Global Round 14 ABCDE题解
quinn18的博客
05-03 815
目录A - Phoenix and GoldB - Phoenix and PuzzleC - Phoenix and TowersD - Phoenix and SocksE - Phoenix and Computers总结 A - Phoenix and Gold 构造？ B - Phoenix and Puzzle 想法 C - Phoenix and Towers 贪心 D - Phoenix and Socks 模拟 E - Phoenix and Computers 区间dp 总结
Codeforces Global Round 14 A B C D E 题解
weixin_45474586的博客
05-03 411
游记： 开始没有理解A的题意，之后发现没有重复元素，20分钟才过...... B的规律一开始想的过于简单，WA了一发，后来才过 C的规律大概想到了，但是每次结束开始没有把答案清零WA了一次，一个半小时过了 DE两道题感觉都有思路，都尝试打一打，最后一个小时十分钟过了D，E放了 题解： A. Phoenix and Gold 题意： 已知n个互不相同的数字，求一种排列方式，使得任意位置的前缀和都不是x 分析： 从互不相同入手，如果当前排列使得某位置前缀和是x，只需将该位置...
Codeforces Global Round 14补题
shall_zhao的博客
05-06 330
Codeforces Global Round 14 A. Phoenix and Gold题意解读代码展示 比赛link-》戳我看题 A. Phoenix and Gold 题意解读 题目的大概意思就是说给你n个不重复数字，然后给你一个k，让你求是否存在一个排列，使得这个排列的前缀和中不出现k 当时自己竟然没做出来，我当时在想先从最小开始输出还是从最大开始输出，然后交了两发wa了之后我还试了一下随机打乱数组，后来自己的思路就困在了如果遇到前缀和为k的数，先保留，所有数字输出完，在输出这个数，但不知道交上去
Codeforces Beta Round #14 D - Two Paths
Shirley
01-15 1053
D - Two Paths Crawling in process...Crawling failedTime Limit:2000MS    Memory Limit:65536KB    64bit IO Format:%I64d & %I64u SubmitStatusPracticeCodeForces 14D Description As you know,
codeforces global round 16
03-16
好的，Codeforces 全球赛第 16 场已于 2022 年 7 月 31 日举行。这是一场由 Codeforces 组织的在线编程比赛，涉及算法和数据结构等方面的知识，吸引了来自全球各地的编程爱好者参加。 比赛包括 6 个问题，难度从 A ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值