【JZOJ5466】玩游戏

problem

Description

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

Input

第一行三个数N和M和K，表示这张无向图初始的点数与边数，以及每次询问的点对的个数；
接下来M行，每行三个数u,v,q，表示点u和点v之间存在一条权值为q的
边；
接下来一行一个数Q，表示操作总数；
接下来Q行，表示操作，每行格式为下面两条中的一条：
1.add u v q：表示在u与v之间加上一条边权为q的边；
2.game m1_1 m1_2 … mk_1 mk_2：表示一次游戏中选择的k对点。
数据保证1≤u,v,mi_1,mi_2≤n，1≤q，mi_1≠mi_2

Output

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

Sample Input

5 6 2
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

Data Constraint

Hint

样例解释：

对于第一轮，1至3的最短路径为5，4至3的最短路径为5
对于第二轮，1至5的最短路径为5，2至4的最短路径为4
再看加边之后：
对于第三轮，1至5的最短路径为4，3至4的最短路径为5

---

analysis

• 有点难的LCT

• 当然由于add操作很少暴力重构也能AC

• 考虑必胜策略的问题考场上我愚蠢地用了SG做
  我不会证……

  k 堆石子，每堆石子数量为 ai,A 和 B 玩游戏，轮流从其中某一堆石子中取
  出若干个石子，最后取完石子的人获胜。
  结论：如 a1 xor a2 xor …xor ak=0，则先手输，否则先手赢，xor 表示异或
  证明：若 a1 xor a2 xor …xor an!=0,则一定可以从其中某堆石子中取出一些石
  子使得剩下的石子数异或结果为 0，若 a1 xor a2 xor …xor an=0，则进行一次取石
  子操作后 a1 xor a2 xor …xor an 一定不等于 0，按照这样的操作下去，最后一定会
  出现 a1=a2=…=an=0 的情况。
  如 n=3,a1=2,a2=3,a3=4,2 xor 3 xor 4=5(101),第三位为 1，三堆石子中只有 4
  的二进制第三位为 1，所以我们可以通过从第三堆石子中取出石子，使得异或结
  果为 0，只要让 101 对应的第 1 和第 3 位取反就可以，4 的二进制位 100，第一
  位第三位取反后为 001，从 100 变成 001，所以从第三堆石子 4 中取出 3 个石子
  即可。用这样的策略可以确保先手必胜

• 要求最大边权最小，还是先求一次最小生成树

• 接下来就像【NOI2014】魔法森林一样动态维护最小生成树即可

• 若新加入的边的权比LCT中权值最大的边要小，那么这条边肯定较劣

• 就把LCT中这条边cut掉，再link上新边，询问就非常简单了

注意long long！！

---

code

#include<bits/stdc++.h>
#define MAXN 20001
#define MAXM 200001

using namespace std;

int t[MAXN][2];
int fat[MAXN],fa[MAXN],pf[MAXN],st[MAXN];
int n,m,k,q,tot;
long long ans;
char s[10];

struct node 
{
    int mx,size;
    long long val;
    bool rev;
}a[MAXN];

struct edge
{
    int u,v;
    long long q;
}f[MAXM];

int getfa(int x)
{
    return !fat[x]?x:fat[x]=getfa(fat[x]);
}

bool cmp(edge x,edge y)
{
    return x.q<y.q;
}

int read()
{
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0' || '9'<ch)
    {
        if (ch=='-')f=-1;
        ch=getchar();   
    }
    while ('0'<=ch && ch<='9')
    {
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x*f;
}

long long readll()
{
    long long x=0,f=1;
    char ch=getchar();
    while (ch<'0' || '9'<ch)
    {
        if (ch=='-')f=-1;
        ch=getchar();   
    }
    while ('0'<=ch && ch<='9')
    {
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x*f;
}

void reverse(int x) 
{
    if(x)
    {
        a[x].rev^=1;
        swap(t[x][0],t[x][1]);
    }
}

void down(int x) 
{
    if (a[x].rev) 
    {
        reverse(t[x][0]),reverse(t[x][1]);
        a[x].rev=0;
    }
}

void update(int x) 
{
    if (x)
    {
        a[x].size=a[t[x][0]].size+a[t[x][1]].size+1;
        a[x].mx=x;
        if (a[a[t[x][0]].mx].val>a[a[x].mx].val)a[x].mx=a[t[x][0]].mx;
        if (a[a[t[x][1]].mx].val>a[a[x].mx].val)a[x].mx=a[t[x][1]].mx;
    } 
}

void downdata(int x) 
{
    st[0]=0;
    while (x)st[++st[0]]=x,x=fa[x];
    while (st[0])down(st[st[0]--]);
}

int lr(int x)
{
    return t[fa[x]][1]==x;
}

void rotate(int x) 
{
    int y=fa[x],k=lr(x);
    t[y][k]=t[x][!k];

    if (t[x][!k])fa[t[x][!k]]=y;
    fa[x]=fa[y];

    if (fa[y])t[fa[y]][lr(y)]=x;    
    t[x][!k]=y;

    fa[y]=x,pf[x]=pf[y];
    update(y),update(x);
}

void splay(int x, int y) 
{
    downdata(x);
    while (fa[x]!=y)
    {
        if (fa[fa[x]]!=y)
        {
            if (lr(x)==lr(fa[x]))rotate(fa[x]); 
            else rotate(x);
        } 
        rotate(x);
    }
}

void access(int x) 
{
    for (int y=0;x;update(x),y=x,x=pf[x])
    {
        splay(x,0);
        fa[t[x][1]]=0;
        pf[t[x][1]]=x;
        t[x][1]=y;
        fa[y]=x;
        pf[y]=0;
    }
}

void makeroot(int x) 
{
    access(x); 
    splay(x,0); 
    reverse(x);
}

int getroot(int x)
{
    while (fa[x])x=fa[x];
    return x;
}

bool judge(int x,int y)
{
    makeroot(x);
    access(y);
    splay(x,0);
    return getroot(y)==x;
}

void link(int x,int y) 
{
    makeroot(x); 
    pf[x]=y;
}

void cut(int x,int y) 
{
    makeroot(x); 
    access(y);
    splay(x,0);
    t[x][1]=fa[y]=pf[y]=0;
    update(x);
}

int query_max(int x,int y)
{
    makeroot(y);
    access(x);
    splay(x,0);
    return a[x].mx;
}

int main()
{
    freopen("game.in","r",stdin);
    freopen("game.out","w",stdout);
    n=read(),m=read(),k=read();
    for (int i=1;i<=m;i++)f[i].u=read(),f[i].v=read(),f[i].q=readll();
    sort(f+1,f+m+1,cmp);
    for (int i=1;i<=m;i++)
    {
        int x=f[i].u,y=f[i].v;
        if (getfa(x)!=getfa(y))
        {
            fat[getfa(x)]=getfa(y);
            link(x,n+i),link(y,n+i);
            a[n+i].mx=n+i,a[n+i].val=f[i].q;
        }
    }
    q=read();
    while (q--)
    {
        scanf("%s",&s);
        if (s[0]=='a')//add
        {
            int x=read(),y=read();
            long long z=readll();
            int temp=query_max(x,y);
            if (z<a[temp].val)
            {
                cut(temp,f[temp-n].u),cut(temp,f[temp-n].v);
                f[temp-n].u=x,f[temp-n].v=y,f[temp-n].q=z;
                link(x,temp),link(y,temp);
                a[temp].val=z,a[temp].mx=temp;
            }
        }
        else //game
        {
            ans=a[query_max(read(),read())].val;
            for (int i=1;i<k;i++)ans^=a[query_max(read(),read())].val;
            printf(ans?"madoka\n":"Baozika\n");
        }
    }
    return 0;
}