10.28T6 动态维护最小生成树

5163 -- 【11.04题目】玩游戏

Description

　　小A得了忧郁综合症，小B正在想办法开导她。
　　机智的小B决定陪着小A玩游戏，他从魔法的世界里变出一张无向联通图，每条边上都有边权。小B定义一条路径的权值为所有经过边中的最大权值，小A则定义两点的最短路径为所有路径中权值最小的路径权。
　　每次小A先选出两个点m1,m2，然后小B选出两个点b1,b2，计算出它们的最短路径m,b，然后小B会拿出两堆灵魂宝石，一堆有m个，另一堆有b个。然后小A先从一堆中选出若干个灵魂宝石拿走，接下来小B重复同样的操作，如此反复，直到取走最后一颗灵魂宝石，然后取走最后一颗宝石的人获胜。
　　小B认为这样游戏太简单，于是他会不定期向这张图上加上一些边，以增大游戏难度。
　　小A具有预知未来的能力，她看到了自己和小B在未来游戏中的选择，以及小B增加的边。现在对于每次游戏，小A想知道自己是否存在必胜的方法。但是预知未来已经消耗了她太多精力，出于疲惫她只好找到了你。

Input

　　第一行两个数N和M，表示这张无向图初始的点数与边数；
　　接下来M行，每行三个数u,v,q，表示点u和点v之间存在一条权值为q的边；
　　接下来一行一个数Q，表示操作总数；
　　接下来Q行，表示操作，每行格式为下面两条中的一条：
　　1.add u v q：表示在u与v之间加上一条边权为q的边；
　　2.game m1 m2 b1 b2：表示一次游戏，其中小A的选择点m1,m2，小B的选择点b1,b2。
　　数据保证1≤u,v,m1,m2,b1,b2≤n，1≤q，m1≠m2 且 b1≠b2

Output

　　对于每个game输出一行，若小A存在必胜策略，则输出“madoka”，否则输出“Baozika”，以回车结尾

Sample Input

5 6 1 2 3 2 3 6 4 2 4 5 3 5 3 4 5 5 1 5 4 game 1 3 4 3 game 1 5 2 4 add 2 5 4 game 1 5 3 4

Sample Output

Baozika madoka madoka

Hint

 

 

 

我们先求出一个最小生成树，然后每加上一条边我们就重新dfs一遍维护

至于那个博弈实际上就是一个nim博弈，直接异或起来判断是否是0就可以了

code：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#define N 500005
using namespace std;
long long n,m;
struct node {
    long long u,v,w,used;
} e[N],t[N];
int first[N],nxt[N],cnt;
inline void add(long long u,long long v,long long w,long long d) {
    e[++cnt].u=u;
    e[cnt].v=v;
    e[cnt].w=w;
    e[cnt].used=d;
    nxt[cnt]=first[u];
    first[u]=cnt;
}
inline bool cmp(const node&a,const node&b) {
    return a.w<b.w;
}
long long fa[N];
inline long long find(long long x) {
    if(x!=fa[x])return fa[x]=find(fa[x]);
    return fa[x];
}
inline void merge(long long x,long long y) {
    long long f1=find(x),f2=find(y);
    if(f1!=f2) {
        fa[f1]=f2;
    }
}
inline void kruskal() {
    long long cnt_=0;
    for(long long i=1; i<=m; ++i) {
        long long u=t[i].u,v=t[i].v,w=t[i].w;
        if(find(u)!=find(v)) {
            merge(u,v);
            add(u,v,w,1);
            add(v,u,w,1);
            cnt_++;
            if(cnt_==n-1)return;
        }
    }
}
struct T {
    long long id,max;
};
long long dep[N],mx[N][30],f[N][30],bianhao[N][30];
T lca(long long x,long long y) {
    if(dep[x]<dep[y])swap(x,y);
    long long id,max0=0;
    for(long long i=15; i>=0; i--) {
        if(dep[f[x][i]]>=dep[y]) {
            if(max0<mx[x][i]) {
                max0=mx[x][i];
                id=bianhao[x][i];
            }
            x=f[x][i];
        }
        if(x==y)return (T) {
            id,max0
        };
    }
    for(long long i=15; i>=0; i--) {
        if(f[x][i]==f[y][i])continue;
        if(max0<mx[x][i]) {
            max0=mx[x][i];
            id=bianhao[x][i];
        }
        if(max0<mx[y][i]) {
            max0=mx[y][i];
            id=bianhao[y][i];
        }
        x=f[x][i];
        y=f[y][i];
    }
    T temp;
    if(max0<mx[y][0]) {
        max0=mx[y][0];
        id=bianhao[y][0];
    }
    if(max0<mx[x][0]) {
        max0=mx[x][0];
        id=bianhao[x][0];
    }
    temp.id=id,temp.max=max0;
    return temp;
}
long long dis[N];
inline void dfs(long long x) {
    for(long long i=first[x]; i; i=nxt[i]) {
        if(!e[i].used)continue;
        long long v=e[i].v;
        if(v==f[x][0])continue;
        f[v][0]=x;
        bianhao[v][0]=i;
        dep[v]=dep[x]+1;
        mx[v][0]=e[i].w;
        dfs(v);
    }
}
inline void build() {
    f[1][0]=1;
    dep[1]=0;
    dfs(1);
    for(long long i=1; i<=15; ++i) {
        for(long long j=1; j<=n; ++j) {
            f[j][i]=f[f[j][i-1]][i-1];
            mx[j][i]=max(mx[j][i-1],mx[f[j][i-1]][i-1]);
            if(mx[j][i]==mx[j][i-1])bianhao[j][i]=bianhao[j][i-1];
            else bianhao[j][i]=bianhao[f[j][i-1]][i-1];
        }
    }
}
inline long long read(){
    long long x=0,f=1;
    char c=getchar();
    while(!isdigit(c)){
        if(c=='-')f=-1;
        c=getchar();
    }
    while(isdigit(c)){
        x=(x<<3)+(x<<1)+c-'0';
        c=getchar();
    }
    return x*f;
}
int main() {
//    freopen("game1.in","r",stdin);
    n=read(),m=read();
    for(long long i=1; i<=n; ++i)fa[i]=i;
    for(long long i=1; i<=m; ++i) {
        t[i].u=read(),t[i].v=read(),t[i].w=read();
    }
    sort(t+1,t+m+1,cmp);
    kruskal();
    build();
    //cout<<e[lca(2,5).id].u<<" "<<e[lca(2,5).id].v<<"!!!!!";
    long long Q;
    Q=read();
    while(Q--) {
        string k;
        cin>>k;
        if(k=="add") {
            long long u,v,w;
            u=read(),v=read(),w=read();
            T temp=lca(u,v);
            if(temp.max>w) {
                e[temp.id].used=0;
//                cout<<u<<" "<<v<<" u->"<<e[temp.id].u<<" v->"<<e[temp.id].v<<" max->"<<temp.max<<'\n';
                if(e[temp.id+1].u==e[temp.id].v&&e[temp.id+1].v==e[temp.id].u) {
                    e[temp.id+1].used=0;
                } else e[temp.id-1].used=0;
                add(u,v,w,1);
                add(v,u,w,1);
                build();
            }
        } else {
            long long a,b,c,d;
            a=read(),b=read(),c=read(),d=read();
            long long max1=lca(a,b).max,max2=lca(c,d).max;
//            cout<<"max1->"<<max1<<" max2->"<<max2<<" "<<'\n';
            if(max1^max2) {
                cout<<"madoka"<<'\n';
            } else {
                cout<<"Baozika"<<'\n';
            }
        }
    }
    return 0;
}

over