Codeforces AIM Tech Round (Div. 1) ABD

A Graph and String

注意’b’的特殊性，它和其他所有点一定有边，然后去构造/搜索，以及检查答案与给定图是否矛盾。
（比赛时的代码比较挫）

#include <bits/stdc++.h>      
using namespace std;   

#define ll long long  

int g[510][510];
int g2[510][510];
int ac[510];

int b[510];
int a[510];

char ans[510];

int main(){
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=m;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        g[u][v] = g[v][u] = 1;
    }

    for(int i=1;i<=n;i++){
        for(int j=i+1;j<=n;j++){
            for(int k=j+1;k<=n;k++){
                if(g[i][j] + g[j][k] + g[i][k] == 2){
                    if(g[i][j]==0){
                        b[k]=1;
                        ac[i]=ac[j]=1;
                        g2[i][j]=g2[j][i]=1;
                    }else if(g[i][k]==0){
                        b[j]=1;
                        ac[i]=ac[k]=1;
                        g2[i][k]=g2[k][i]=1;
                    }else if(g[j][k]==0){
                        b[i]=1;
                        ac[j]=ac[k]=1;
                        g2[j][k]=g2[k][j]=1;
                    }

                }
            }
        }
    }

    bool ok=1;
    for(int i=1;i<=n;i++){
        if(ac[i]+b[i]<2){
            if(!b[i]){
                for(int j=1;j<i;j++){
                    if(g2[i][j]==1){
                        if(ans[i]==ans[j]){
                            ok=0;
                        }
                        if(ans[j]=='a'){
                            ans[i]='c';
                        }
                        if(ans[j]=='c'){
                            ans[i]='a';
                        }
                    }
                }
                for(int j=1;j<i;j++){
                    if(!g[i][j]){
                        if(ans[i]==ans[j]){
                            ok=0;
                        }
                        if(ans[j]=='a'){
                            ans[i]='c';
                        }
                        if(ans[j]=='c'){
                            ans[i]='a';
                        }
                    }
                }
                if(ans[i]==0){
                    ans[i]='a';
                }
            }else{
                ans[i]='b';
            }
        }else{
            ok=0;
        }
    }

    //
    for(int i=1;i<=n;i++){
        if(!b[i])continue;
        for(int j=1;j<=n;j++){
            if(i==j)continue;
            if(!g[i][j]){
                ok=0;
            }
        }
    }

    if(ok){
        printf("Yes\n");
        printf("%s\n",ans+1);
    }else{
        printf("No\n");
    }
    return 0;
}

B Array GCD

比赛时一直想着利用前后缀gcd搞，其实想歪了，整道题不需要求gcd。关键是弄清楚一个事实：操作后的串的公约数（注意不是gcd）一定可以是$a_1$、$a_1-1$、$a_1+1$、$a_n$、$a_n-1$、$a_n+1$中的某个素约数。所以分别拿这6个数的素因子来检查即可。求解的时候用dp。$dp(i,j)$，$i$表示当前考察到哪个数，$j$表示操作1的状态（共三种），$dp()$则是相应状态下的最小花费。

#include <bits/stdc++.h>

using namespace std;

#define ll long long

const int maxn = 1000010;
const ll INF = 1e18;

int n,a,b;

int num[maxn];
int primes[100];
ll dp[maxn][3];

int gcd(int a,int b){
    return b==0?a:gcd(b,a%b);
}

void initArr(){
    for(int i=0;i<=n;i++){
        for(int j=0;j<3;j++){
            dp[i][j] = INF; 
        }
    }
    dp[0][0] = 0;
}

int tot = 0;

void get_primes(int x){
    for(int i=2;i*i<=x;i++){
        if(x%i==0){
            primes[tot++]=i;
            while(x%i==0){
                x/=i;
            }
        }
    }
    if(x>1)primes[tot++]=x;
}

void Min(ll &a,const ll &b){
    if(b<a){
        a=b;
    }
}

int main(){
    cin>>n>>a>>b;

    for(int i=1;i<=n;i++){
        scanf("%d",&num[i]);
    }

    get_primes(num[1]-1);
    get_primes(num[1]);
    get_primes(num[1]+1);
    get_primes(num[n]-1);
    get_primes(num[n]);
    get_primes(num[n]+1);
    sort(primes,primes+tot);
    tot = unique(primes,primes+tot)-primes;

    ll ans = INF;
    for(int t=0;t<tot;t++){
        initArr();
        for(int i=1;i<=n;i++){
            if( num[i] % primes[t] == 0){
                for(int j=0;j<3;j++){
                    if(j==1)continue;
                    Min(dp[i][j],dp[i-1][j]);
                }
                Min(dp[i][1],dp[i-1][1]+a);
                Min(dp[i][2],dp[i-1][1]);
            }else{
                if( (num[i]+1)%primes[t]==0 || (num[i]-1)%primes[t]==0 ){
                    Min(dp[i][0],dp[i-1][0]+b);
                    Min(dp[i][2],dp[i-1][2]+b);
                    Min(dp[i][2],dp[i-1][1]+b);
                }
                Min(dp[i][1],dp[i-1][1]+a);
                Min(dp[i][1],dp[i-1][0]+a);
                Min(dp[i][2],dp[i-1][1]+a);
            }

            //
            for(int j=0;j<3;j++){
                Min(ans,dp[n][j]);
            }
        }
        for(int j=0;j<3;j++){
            Min(ans,dp[n][j]);
        }
    }
    cout<<ans<<endl;
    return 0;
}

D Birthday

这题放在div1D，其实挺简单。。游戏的前 n <script type="math/tex" id="MathJax-Element-665">n</script>次最优策略肯定是每个人猜一次（毕竟只有这样有赢的可能）。之后的最优策略就不是循环猜了，而是贪心看猜谁结束的概率大就猜谁，可以暴力，也可以用优先队列维护。迭代若干次，答案就能满足精确度要求了（这种时候，肯定是在不TLE的前提下搞越多次越好）。。计算用到的都是基本概率公式，就不多说了。

#include <bits/stdc++.h>

using namespace std;

long double p[111];

struct node{
    long double curp;
    long double nextp;
    long double _p;
    int id;
    bool operator<(const node &other)const{
        return nextp/curp < other.nextp/other.curp;
    }
};

int main(){
    int n;
    cin>>n;
    priority_queue<node> que;
    for(int i=1;i<=n;i++){
        int pp; scanf("%d",&pp);
        p[i]=pp/100.0;
        node nd;
        nd._p=1-p[i];
        nd.curp = p[i];
        nd.nextp = 1-(1-p[i])*nd._p;
        nd.id=i;
        que.push(nd);
    }

    long double ans = 0.0;

    sort(p+1,p+n+1);
    reverse(p+1,p+n+1);

    long double pend=1.0;
    for(int i=1;i<=n;i++){
        pend*=p[i];
    }

    ans+=pend*n;

    for(int k=n+1;k<=1000000;k++){
        node tp = que.top();    que.pop();
        long double tmp = pend;
        pend *= tp.nextp/tp.curp;
        tp.curp = tp.nextp;
        tp.nextp = 1-(1-tp.curp)*tp._p;
        que.push(tp);

        ans += k*(pend-tmp);
    }

    double re = ans;
    printf("%.10f\n",re);
    return 0;
}