CF-Round597比赛总结

Codeforces Round #597 (Div. 2)

A：Good ol’ Numbers Coloring
题意：
给出给出n和m，然后你要对无限大长度的区域染色，当第i个位置大于等于n或者大于等于m时若i-n或者i-m为白色也要染成白色，否则为黑色，起始0位置也要染成白色，问染成黑色的块数是否为无穷多的。
解题思路：
思路:
根据题目描述，设当前位置之前的所有白色数中任意两个为x和y，只要当前位置的数可以由ax+by表示，那就是白色的（a，b为任意常数）
结论：ax+by=k*gcd（a，b）；k号位置是白色的就是ax+by有整数解k，如果有有限个黑色的，只要gcd（a，b）=1，那从某个位置开始之后的所有位置能满足当前位置编号是整数解，即白色，black就是有限的；否则就是无限的。
代码如下：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=1e5+10;
int n,m,k,ans;
int main(){
    cin>>n;
    while(n--){
        cin>>m>>k;
        if(__gcd(m,k)!=1){
            cout<<"Infinite"<<endl;
        }else cout<<"Finite"<<endl;
    }
    return 0;
}

B：Constanze’s Machine题意：类似于石头剪刀布，给出一个人的出剪刀石头布的顺序，还给出a，b，c三个数，你要严格的出a个石头b个布，c个剪刀，问是否有出的方案使得你可以赢得对手（a+b+c）/2次，输出方案。
解题思路：
先按照击败的规则分配出的顺序，缺少的再拿还剩下的不就行了。
代码如下：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=1e5+10;
int n,m,k,ans,t,x,y,z;
string s;
int main(){
    cin>>t;
    while(t--){
        char ans[110];
        k=0;
        memset(ans,'0',sizeof ans);
        cin>>m>>x>>y>>z;
        cin>>s;
        for(int i=0;i<m;i++){//模拟克制规则，选择出的方式
            if(s[i]=='R'){
                if(y>0){
                    k++;
                    y--;
                    ans[i]='P';
                }
            }else if(s[i]=='P'){
                if(z>0){
                    z--;
                    k++;
                    ans[i]='S';
                }
            }else {
                if(x>0){
                    x--;
                    k++;
                    ans[i]='R';
                }
            }
        }
        if(k<(int)ceil((double)m/2))cout<<"No"<<endl;
        else{
            cout<<"Yes"<<endl;
            for(int i=0;i<m&&x>0;i++){//对前面空缺的补齐
                if(ans[i]=='0')ans[i]='R',x--;
            }
            for(int i=0;i<m&&y>0;i++){
                if(ans[i]=='0')ans[i]='P',y--;
            }
            for(int i=0;i<m&&z>0;i++){
                if(ans[i]=='0')ans[i]='S',z--;
            }
            for(int i=0;i<m;i++)cout<<ans[i];
            cout<<endl;
        }
    }
    return 0;
}

C：Constanze’s Machine
题意：
打字机会将M打成nn，W打成uu，然后给你一段字符串，问你最多有多少种可能打成这种字符串，需要注意的是若给出的字符串中出现了m和w直接输出0即可。
解题思路：
分析对一段长度为n的只含m或者w的字符串来说，它可以由两种方式转换过来，若前一个字母等于u或者n那么就可以于u其结合变成相应的字母，若前一个不等则方案数等于上一个，所以递推式等于：dp[i]=dp[i-1]+dp[i-2]。
然后对区间进行扫描找到相同的只含n和u的区间累乘即可。
代码如下：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const ll mod=1e9+7;
const int N=1e5+10;
int n,m,k,t;
string s;
ll solve(){
    cin>>s;
    int len=s.size();
    ll dp[N],ans=1;
    dp[1]=1,dp[2]=2;
    for(int i=3;i<=len;i++){//预处理dp式
        dp[i]=(dp[i-1]+dp[i-2])%mod;
    }
    int now=1;
    for(int i=0;i<len;i++){
        if(s[i]=='w'||s[i]=='m')return 0;
        else if(s[i]=='n'){
            now=1;
            for(int j=i+1;j<len;j++){
                if(s[j]=='n')now++;
                else break;
            }
            ans=ans*dp[now]%mod;
            i=now+i-1;
        }else if(s[i]=='u'){
            now=1;
            for(int j=i+1;j<len;j++){
                if(s[j]=='u')now++;
                else break;
            }
            ans=ans*dp[now]%mod;
            i=now+i-1;
        }
    }
    return ans;
}
int main(){
    cout<<solve();
    return 0;
}

D：Shichikuji and Power Grid
题意：
给出n个城市，在n个城市中你可以修电站或者通过连电线来使得n个城市通上电，修电站或者修电站都有相应的代价，问通完电之后最小代价是什么，需要修多少个电站，需要连多少条线，输出对应的方案。
解题思路：
先建立一个原点来连接每一个电站，代价就是修电站的代价，再预处理出电站之间连电线需要的代价，然后就转换为最小生成树的题了。
代码如下：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const ll N=2010;
ll n,m,k,ans,x,y,T,t;
ll a[N],b[N],f[N];
vector<ll>v1,v2;//v1存修电站的数量，v2存连电线的边
struct node{
    ll x,y,v;
}q[N*N];
struct bian{
    ll x,y;
}p[N];
ll fi(ll x){
    return f[x]==x?x:f[x]=fi(f[x]);
}
bool cmp(node u,node vv){
    return u.v<vv.v;
}
void solve(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>p[i].x>>p[i].y;
    }
    for(int i=0;i<=n;i++)f[i]=i;
    for(int i=1;i<=n;i++)cin>>a[i];
    for(int j=1;j<=n;j++)cin>>b[j];
    for(int i=1;i<=n;i++){//建立原点连接每一个电站
        q[T].x=0;
        q[T].y=i;
        q[T].v=a[i];
        T++;
    }
    for(int i=1;i<=n;i++){//预处理每两个电站之间连电线的代价
        for(int j=i+1;j<=n;j++){
            q[T].x=i;
            q[T].y=j;
            q[T].v=(abs(p[i].x-p[j].x)+abs(p[i].y-p[j].y))*(b[i]+b[j]);
            T++;
        }
    }
    sort(q,q+T,cmp);
    for(int i=0;i<=T;i++){//最小生成树
        ll xx=fi(q[i].x);
        ll yy=fi(q[i].y);
        if(xx!=yy){
            f[yy]=xx;
            if(!q[i].x)v1.push_back(q[i].y);
            else {
                v2.push_back(q[i].x);
                v2.push_back(q[i].y);
            }
            t++;
            ans+=q[i].v;
            if(t==n)break;
        }
    }
    cout<<ans<<endl;
    cout<<v1.size()<<endl;
    for(int i=0;i<v1.size();i++)cout<<v1[i]<<" ";cout<<endl;
    cout<<v2.size()/2<<endl;
    for(int i=0;i<v2.size();i+=2){
        cout<<v2[i]<<" "<<v2[i+1]<<endl;
    }
}
int main(){
    solve();
    return 0;
}

E：Hyakugoku and Ladders
题意：
给出一个10*10的矩阵，起始位置是在左下角，终点位置是在左上角，你可以通过摇骰子来决定走的步数，在矩阵中有一些地方有梯子，你可以通过梯子向上爬该位置数字的高度，此外摇骰子摇过终点时，要重新摇，问最终到达终点的期望是什么。
解题思路：
首先我们从终点开始按照路径给整个图编号，左上角的点为1，左下角的点为100。
dp[i]表示从i位置到达终点需要投多少次骰子。如果没有终点和梯子的限制，dp[i]=(dp[i-1]+dp[i-2]+…+dp[i-6])/6+1即可。
现在有了梯子，那么我们可以从梯子转移过来，我们取一个min即可。
由于摇过终点的限制，分析可以计算出1到5的期望都是6.。
代码如下：

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const ll N=110;
int n,m,k,ans,x,y,T,t;
int maze[N][N],to[N*N];
double dp[N];
void solve(){
    for(int i=0;i<10;i++){//预处理行走的方向
        for(int j=0;j<10;j++){
            if(i%2==0){
                maze[i][j]=i*10+j;
            }else {
                maze[i][j]=i*10+9-j;
            }
        }
    }
    for(int i=0;i<10;i++){
        for(int j=0;j<10;j++){
            scanf("%d",&k);
            to[maze[i][j]]=maze[i-k][j];//通过梯子可以跳到的位置
        }
    }
    dp[0]=0;
    for(int i=1;i<6;i++)dp[i]=6;//处理1到5
    for(int i=6;i<100;i++){
        double now=0;
        for(int j=1;j<=6;j++){//计算在i位置的期望
            now=now+(double)min(dp[i-j],dp[to[i-j]]);
        }
        dp[i]=now/6+1;
    }
    printf("%.10f\n",dp[99]);//这个地方用lf输出不了
}
int main(){
    solve();
    return 0;
}