Codeforces Round #671 (Div. 2)A~F个人题解

Rh_hipper

已于 2022-07-05 10:57:51 修改

阅读量558

点赞数

分类专栏：数论文章标签：大数据

于 2022-07-04 20:56:01 首次发布

本文链接：https://blog.csdn.net/qq_53446104/article/details/125607185

版权

数论专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Dashboard - Codeforces Round #671 (Div. 2) - Codeforces

A. Digit Game

题意：有两个人和一个长度为n的数字，

人A先操作，每次操作取出数字中，位数为奇数的数字，

人B后操作，每次操作取出数字中，位数为偶数的数字，

最后剩的一位数字，如果是奇数，A胜利，如果是偶数，B胜利，问最后谁赢？

知识点：博弈，思维

思路：

因为一共n位数字，

如果n是奇数，那么最后一定是剩的人A的数字

如果n是偶数，那么最后一定是剩的人B的数字

可以预想到，如果人A能取出奇数一定最后取，人B能取出偶数一定最后取，

所以，只要看n的奇偶性和人A有没有奇数，人B有没有偶数就可以了

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int N=2e6+5;
void solve(){
    int n;cin>>n;
    bool f[2]={false,false};//0是人A能不能取奇数，1是人B能不能取偶数
    for(int i=1;i<=n;++i){
        char s;cin>>s;
        int now=s-'0';
        if((i&1)==(now&1))f[(i&1)]=true;//判断
    }
    //如果n是奇数，f[0]=true,那A一定赢了，反之B赢
    //如果n是偶数，f[1]=true,那B一定赢了，反之A赢
    if(f[n&1]){
        if(n&1)cout<<1<<'\n';
        else cout<<2<<'\n';
    }
    else {
        if(n&1)cout<<2<<'\n';
        else cout<<1<<'\n';
    }
}
int main(){
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
    int _=1;cin>>_;
    while(_--){
        solve();
    }
    return 0 ;
}

B. Stairs

题意：有n个小正方形，问最多能同时组成几种不同的阶梯？阶梯形状如下

，，

依次类推。

知识点：递推

思路：看图的话容易建立一个递推 $f[i]$

f[1]=1,

$f[i]=2\times f[i-1] + 2^{i-1} \times 2^{i-1}$

然后从小的到大的依次减去，就是最大的个数了。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int N=2e6+5;
ll f[33];
void solve(){
    ll n;cin>>n;
    for(int i=1;i<33;++i){
        if(n>=f[i])n-=f[i];//从小往大依次减去，这样答案最大
        else {
            cout<<i-1<<'\n';
            return ;
        }
    }
}
int main(){
    f[1]=1;
    for(ll i=2;i<33;++i){
        f[i]=(f[i-1]<<1)+(1ll<<(2*i-2));//递推式
    }
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
    int _=1;cin>>_;
    while(_--){
        solve();
    }
    return 0 ;
}

C. Killjoy

题意：有n个人，每个人有一个分数 a_i ，现在有一个x，问最少经过几场比赛能让每个人的分数 a_i 变成过x,定义每场比赛每个人的分数都会改变，但是参加比赛的人在比赛完后的总分数等于比赛前的总分数，没场比赛可以随机让n人中的几人或者全部参加。

知识点：思维

思路：

如果一开始每个人都分数都是x,那么就不需要比赛就可以满足条件了。

如果一开始有其中一部分人的分数为x,那么只需要一场比赛就可以了，我们让x分数以外的人的分数都变成x,而之前分数已经是x的人直接一直减分或者加分就行了。

如果没人开始分数为x,

如果n个人的平均分是x,那么也是只需要一场比赛就可以了，一场比赛n个人一起参加

如果n个人的平均分不是x,那么要两场比赛，一场比赛选n个人参加，让其中n-1个人的分数都为x,剩下一个大怨种随便加减，然后再来一场，让那个大怨种分数为x,其他人加减。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int N=2e6+5;
void solve(){
    int n,res=0,x,w;cin>>n>>x;
    bool flag=false,p=false;
    for(int i=1;i<=n;++i){
        cin>>w;
        res+=w;
        if(w!=x)flag=true;//如果存在w!=x,证明不是全是x
        if(w==x)p=true;
    }
    if(!flag){//如果全是x
        cout<<0<<'\n';
        return ;
    }
    if(p)cout<<1<<'\n';//如果有w=x
    else {
        if(res%n==0){
            res/=n;
            if(res==x)cout<<1<<'\n';//如果平均值=x
            else cout<<2<<'\n';//其他情况
        }
        else cout<<2<<'\n';//其他情况
    }
}
int main(){
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
    int _=1;cin>>_;
    while(_--){
        solve();
    }
    return 0 ;
}

D1&D2. Sage's Birthday

题意：有一个长度为n的序列a,问怎么排序能让 $a_i<a_{i-1} \ and \ a_i<a_{i+1}$ 的的个数最多(D2解决就解决了D1,所以讲讲D2怎么写)？

知识点：思维，排序

思路：

我们直接把a数组从小到大排序，如果先不考虑元素，我们要让这样i的个数最多，那么这个i一定放在偶数下标位置，比如这样

绿色位置就是我们的i,这样我们就知道了红色位置放最大的那一部分数，绿色部分放小的那一部分数，最后再统计一遍，就完成了

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int N=2e6+5;
void solve(){
    int n,now=0,res=0;cin>>n;
    vector<int>a(n),ans(n);
    for(auto &w:a)cin>>w;//输入a数组
    sort(a.begin(),a.end());//排序
    for(int i=1;i<n;i+=2)ans[i]=a[now++];//偶数位置依次放小的数
    for(int i=0;i<n;i+=2)ans[i]=a[now++];//奇数位置依次放大的数
    for(int i=1;i<n-1;++i){
        if(ans[i]<ans[i-1]&&ans[i]<ans[i+1])res++;//统计答案
    }//输出
    cout<<res<<'\n';
    for(auto w:ans)cout<<w<<' ';
    cout<<'\n';
}
int main(){
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
    int _=1;//cin>>_;
    while(_--){
        solve();
    }
    return 0 ;
}

E. Decryption

题意：给你一个合数n,你要把他的所有约数取出来，然后放到一个环上，

现在你有一种操作是取环上相邻的俩个数，取他们的最小公倍数，放在这俩个数之间。

问你怎么放能用最少的操作数，让环上相邻的俩个数不互质。

知识点：思维，数论，构造

思路：

我们先把n质因子分解，

按照从小到大的顺序，

先放一个最小的质数，然后接下来看的质数如果和上一个质数不相同，那么我们先把 $p \times q$ 放下去，再放下去质数，然后跳过质数往前看，然后依次把前面的数字和质数的乘积放下来。

如果质数和质数相等，那么我们把 $p \times q$ 放下来，然后依次往前看，然后依次把前面的数字和质数的乘积放下来，直到出现前面的数字和质数的乘积已经出现过了就停下（这个不放），就构造完成了。

举个小李子：

$n=2\times3\times 3$

$2)6\ 3)9\ 18)$

$n=2\times2\times2\times3\times3\times5$

$2)4\ 8)24\ 3\ 12 \6)18\ 36 \ 9 \ 72)360\ 5 \ 45 \180 \ 90 \30 \60 \15 \120 \40 \20 \10)$

每个括号代表某一个质数来的时候往换上加的数

然后就是要操作的次数，在这样构造的过程中，只有 $n=p\times q,p\neq q$ 的时候，要进行一次操作，其他情况都不需要操作。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int N=2e6+5;
void solve(){
    unordered_map<int,bool>mp;
    int n;cin >> n ;
    vector< int > v ;
    int x = n ;
    for( int i = 2 ; i*i <= x ; i ++ ){
        if( x%i == 0 ){
            while( x%i == 0 ){
                v.push_back(i) ;//取质因子
                x /= i ;
            }
        }
    }
    if( x > 1 ) v.push_back( x ) ;//取质因子
    vector< int > ans ;
    ans.push_back(v[0]) ;//先放一个质数
    int pre = v[0] ;
    for( int i = 1 ; i < v.size() ; i ++  ){
        if( v[i] == pre ){//如果当前质数和前一个相等
            ans.push_back(ans.back()*v[i]);//依照上面的构造方式
            mp[ans.back()]=true;
            for( int j = (int)ans.size()-3 ; j >= 0 ; j -- ){
                if(mp.find(ans[j]*v[i])!=mp.end())break;//如果存在，就不放了
                ans.push_back(ans[j]*v[i]) ;
            }
        }
        else {
            ans.push_back(ans.back()*v[i]);//依照上面的构造方式
            mp[ans.back()]=true;
            ans.push_back( v[i] ) ;
            for( int j = (int)ans.size()-4 ; j >= 0 ; j -- ){
                ans.push_back(ans[j]*v[i]) ;
            }
            pre=v[i];
        }
    }
    for(auto w:ans)cout<<w<<' ';//输出
    cout<<'\n';
    if(v.size()==2){//如果质因子个数是2
        if(v[0]!=v[1])cout<<1<<'\n';//并且俩质数不相等
        else cout<<0<<'\n';
    }
    else cout<<0<<'\n';
}
int main(){
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
    int _=1;//cin>>_;
    while(_--){
        solve();
    }
    return 0 ;
}

F. Rain of Fire

题意：有n个点，每个点有一个坐标 (x,y) ,现在有一个人可以从任意位置出发，

但是他只能上下左右一直走，直到碰到n个点中的某一个才能再改变是上下左右那个方向走，

现在问你，选择从哪里出发，并且怎么走能吧n个点都走到，并且走的相邻两个点的距离的最大值最小。

知识点：二分，并查集，思维

思路：

最大值最小可以直接想二分，我们二分答案x，check里只有俩个点能互达时并且距离小于x时，把他们归到一个联通块里，

当联通块的个数是1时，我们可以在这个联通块里的任意两点之间开始，这时都是可以的。

当联通块的个数是2时，我们从每个联通块里取一个点，我们里面的点会有俩种情况，如下

一个是第一种的俩个点之间的直线平行x轴或者y轴，另一个是不平行x轴和y轴

第一种情况，如果直线长度是奇数，那么只要长度的一半+1<=x，就是成立的

如果是直线长度是偶数，那么只要长度的一半<=x，就是成立的

第二种情况，只有俩个点在横轴上的距离和点在纵轴上的距离<=x，是成立的。

当联通块个数是3时，我们从每个联通块里取一个点，这时候，一定会有俩个点在一个平行x轴和y轴的直线上时，他才能连接成立，所以我们枚举哪个联通块里的点不在直线上，通过这枚举的点和另外两个其一找到一个成立的点，然后让入hash函数中，再通过这个枚举的点和另外一个找一个成立的点，再在hash里在开始是不是有，有就成立了。如下

先看棕色和红色中成立的点，然后找粉丝和红色中成立的点是不是在刚刚棕色和红色成立的点中出现过。

当联通块个数是4时，我们从每个联通块里取一个点，这时候，他们一定是有俩俩之间是一条平行x轴和y轴的之线。我们固定联通块1如果他和联通块2是一条平行x的直线，那么联通块3和联通块4一定是一条平行y的直线，所以我们看联通块1和联通3，再看联通块2和联通4就可以了，这时这俩一定是折线型的，具体步骤和联通块个数是3的情况差不多，比如第一种情况这里是看1，2联通块能确定的点，放入hash里，然后再看3，4联通块能确定的点，看hash里有没有，有就成立

黑色和红色先找成立的点放到hash里，然后看蓝色和粉色中成立的点是不是在hash里出现过。

当联通块个数>4时，那么除了有上下左右互相能连接的点，一定会有一个联通的点走不到，所以一定不会成立。

大致思路是这样，有一些肯定（第一次知道unordered_map<pair<ll,ll>,bool>是不能用的qwq）,所以hash里要把二维坐标一维化，把他们先全搞成正数，然后乘个值域搞搞就行了，还有注意有很多东西要清空。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int N=1e3+5;
struct dd{
    int x,y,id;//n个点的坐标(x,y)
}op[N];
int n;
struct dsu{//并查集板子
    const int n;
    vector<ll>f;
    inline dsu(int n) : n(n), f(n+1){
        for(int i=1;i<=n;++i)f[i]=i;
    }
    inline ll Find(ll x){return x==f[x]?x:(f[x]=Find(f[x]));}
    inline void Merge(ll u,ll v){
        ll tx=Find(u),ty=Find(v);
        if(tx!=ty)f[ty]=tx;
    }
};
vector<pair<ll,ll> >mp[N];//统计每个联通块中的点
int hs[N],cnt;//离散下标
int dis(int x1,int x2,int y1,int y2){//在一个平行x或者y的直线上的距离
    if(x1==x2)return abs(y1-y2);
    return abs(x1-x2);
}
bool Search(int w1,int w2,int x){//联通块个数为2的判断
    for(int i=0;i<mp[w1].size();++i){
        for(int j=0;j<mp[w2].size();++j){
            auto [x1,y1]=mp[w1][i];
            auto [x2,y2]=mp[w2][j];
            ll Dis1=abs(x1-x2),Dis2=abs(y1-y2);
            if(x1==x2&&Dis2/2+(Dis2&1)<=x)return true;//在一个平行x的直线上
            else if(y1==y2&&Dis1/2+(Dis1&1)<=x)return true;//在一个平行y的直线上
            else if(Dis1<=x&&Dis2<=x)return true;//都不在，是个勾型那种
        }
    }
    return false;
}
unordered_map<ll,bool>has;//hash
ll limit=1e9;
ll getid(ll x,ll y){//二维下标转换成一维
    x+=limit;y+=limit;
    return x*limit+y;
}
bool Search(int w1, int w2, int x, int k){//联通块个数3，4时的判断
    for(int i=0;i<mp[w1].size();++i){
        for(int j=0;j<mp[w2].size();++j){
            auto [x1,y1]=mp[w1][i];
            auto [x2,y2]=mp[w2][j];
            if(k==1){
                if(x1!=x2&&y1!=y2){//k=1表示先往hash里扔成立的点
                    if(abs(x1-x2)<=x&&abs(y1-y2)<=x){
                        has[getid(x1,y2)]=true;
                        has[getid(x2,y1)]=true;
                    }
                }
            }
            else {//k=2表示现在要找成立的点是不是在hash里出现过
                if(x1!=x2&&y1!=y2){
                    if(abs(x1-x2)<=x&&abs(y1-y2)<=x){
                        if(has.find(getid(x1,y2))!=has.end())return true;
                        if(has.find(getid(x2,y1))!=has.end())return true;
                    }
                }
            }
        }
    }
    return false;
}
bool check(ll x){//二分x
    dsu f(n);
    for(int i=1;i<=n;++i){
        for(int j=i+1;j<=n;++j){
            auto [x1,y1,id1]=op[i];
            auto [x2,y2,id2]=op[j];
            if(x1==x2||y1==y2){
                ll Dis=dis(x1,x2,y1,y2);
                if(Dis<=x)f.Merge(id1,id2);//距离小于x时才能走
            }
        }
    }
    for(int i=1;i<=n;++i){
        int fa=f.Find(i);
        if(!hs[fa])hs[fa]=++cnt;//统计联通块个数
        mp[hs[fa]].push_back({op[i].x,op[i].y});//放进去
    }
    if(cnt==1)return true;//一个联通块直接成立
    else if(cnt==2)return Search(1,2,x);//二个联通块判断
    else if(cnt==3){//三个联通块判断
        bool flag=false;
        Search(1,2,x,1);      //可能2，3在一个平行x或者y的直线上
        flag|=Search(1,3,x,2);
        has.clear();
        Search(2,1,x,1);      //可能1，3在一个平行x或者y的直线上
        flag|=Search(2,3,x,2);
        has.clear();
        Search(3,2,x,1);      //可能1，2在一个平行x或者y的直线上
        flag|=Search(3,1,x,2);
        has.clear();
        return flag;
    }
    else if(cnt==4){
        bool flag=false;
        Search(1,3,x,1);      //可能1，3不在一个平行x或者y的直线上
        flag|=Search(2,4,x,2);//2，4不在一个平行x或者y的直线上
        has.clear();
        Search(1,2,x,1);      //可能1，2不在一个平行x或者y的直线上
        flag|=Search(3,4,x,2);//3，4不在一个平行x或者y的直线上
        has.clear();
        return flag;
    }
    return false;
}
void solve(){
    cin>>n;
    for(int i=1;i<=n;++i){
        auto &[x,y,id]=op[i];
        cin>>x>>y;id=i;
    }
    ll l=0,r=2e9,ans=-1,mid;//二分
    while(l<=r){
        mid=l+r>>1;
        if(check(mid)){
            r=mid-1;
            ans=mid;
        }
        else l=mid+1;
        //每判一次就要清空一次
        for(int i=1;i<=cnt;++i)mp[i].clear();
        for(int i=1;i<=n;++i)hs[i]=0;
        cnt=0;
    }
    cout<<ans<<'\n';//输出答案
}
int main(){
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);
    int _=1;//cin>>_;
    while(_--){
        solve();
    }
    return 0 ;
}