hiho 1638 小Hi的天平 [Offer收割]编程练习赛36 Problem B 并查集+图dfs乱搞

题目2 : 小Hi的天平

时间限制: 1000ms

单点时限: 1000ms

内存限制: 256MB

描述

小Hi给小Ho邮寄了一个天平。收到天平后，小Ho想知道天平在运输过程中是否损坏，为此它准备了A类物品和B类物品共n个（可能只有A类物品，也可能只有B类物品），但无法确定一个物品是哪一类。A类物品的质量都相同，B类物品的质量也相同，但A类物品与B类物品的质量不同。现将n个物品从1到n编号，用天平进行m次测量，每次从n个物品中取i和j两个物品，测量后可以知道物品i和物品j质量是否相同。

现在小Ho想知道能否根据测量结果判定天平是坏的，如果能确定，最早是第几次测量确定的，你能帮帮他吗？

输入

第一行一个数字T，代表数据组数。1<=T<=5。
对于每组数据：
第一行两个整数n，m，分别代表A类、B类物品的总数和测量次数。2<=n<=10000，1<=m<=300000。
接下来m行，每行三个数字x，u，v。x=0代表物品u与物品v质量相等，x=1代表质量不等。

输出

对于每组数据：
若不能确定天平是坏的，则输出一行“great”。
否则，输出两行。
第一行输出“sad”。
第二行输出一个数字p，代表最早第p次测量确定了天平是坏的。

样例输入

1
2 2
0 1 2
1 1 2

样例输出

sad
2

所有的点的状态都用0或者1表示。

来了两个点，先判断是否属于同一个并查集，如果是，就判断一下合法性，如果不合法就保留这个值，就是答案，如果合法，什么也不做，继续。

当这两个点从未被访问过了话，那么就根据他们的关系是相同还是不同，设置为0或者1这两个值，如果相同，设置为俩1或者俩0，都可以，不同就设置为一个1一个0，然后放入并查集。

然后若是有一个点被访问过了，另一个点未被访问过，那么就根据那个被访问过的点的值，更新未被访问过的点的值。然后unite起来放入并查集。

若是俩点都被访问过了，而且还不属于同一个并查集，那么就要放入并查集，同时，如果有必要，要把较小的那个集合里的所有值异或一下1（0变1,1变0），如果恰好之前我们的赋值符合这俩原本不在一个并查集的点之间的逻辑，那么我们就不用修改较小的集合的值了，直接unite起来就好。

在修改集合的值的时候，需要dfs，所以还是要建个图的，但是有一点要注意，建边的时候是在判断完这些东西之后才建的。

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string>
#include <string.h>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <bits/stdc++.h>
using namespace std;
/*
10

3 3
0 1 2
0 2 3
0 1 3

3 3
0 1 2
0 1 3
1 2 3
*/
int N,M;
int val[10009];
int par[10009];
int tall[10009];

vector<int>G[10009];
bool used[10009];
void dfsUpdate(int x){//reverse
    used[x]=1;
    val[x]^=1;
    for(int i=0;i<G[x].size();i++){
        if(!used[G[x][i]])dfsUpdate(G[x][i]);
    }
}

void init(int n){
    for(int i=1;i<=n;i++){
        par[i]=i;
        tall[i]=0;
    }
}

int find_root(int x){
    if(par[x]==x){
        return x;
    }
    else{
        return par[x]=find_root(par[x]);
    }
}

void unite(int x,int y){
    x=find_root(x);
    y=find_root(y);
    if(x==y)return;
    if(tall[x]<tall[y]){
        par[x]=y;
    }
    else{
        par[y]=x;
        if(tall[x]==tall[y])tall[x]++;
    }
}

bool same(int x,int y){
    return find_root(x)==find_root(y);
}

int main(){
    int T;
    cin>>T;
    while(T--){
        cin>>N>>M;
        for(int i=0;i<=N;i++){
            G[i].clear();
        }
        memset(val,-1,sizeof(val));
        init(N);
        int ans=-1;
        for(int i=1;i<=M;i++){
            int x,u,v;
            scanf("%d%d%d",&x,&u,&v);
            if(ans==-1){
                if(same(u,v)){
                    if(x==0){
                        if(val[u]!=val[v])ans=i;
                    }
                    else{
                        if(val[u]==val[v])ans=i;
                    }
                    continue;
                }
                if(val[u]==-1&&val[v]==-1){
                    unite(u,v);
                    if(x==0){
                        val[u]=1;
                        val[v]=1;
                    }
                    else{
                        val[u]=1;
                        val[v]=0;
                    }
                }
                else if(val[u]==-1&&val[v]!=-1){
                    unite(u,v);
                    if(x==0){
                        val[u]=val[v];
                    }
                    else{
                        val[u]=val[v]^1;
                    }
                }
                else if(val[u]!=-1&&val[v]==-1){
                    unite(u,v);
                    if(x==0){
                        val[v]=val[u];
                    }
                    else{
                        val[v]=val[u]^1;
                    }
                }
                else{//val[u]!=-1&&val[v]!=-1
                    if(x==0){
                        if(val[u]==val[v])unite(u,v);
                        else{
                            memset(used,0,sizeof(used));
                            int rootV=find_root(v);
                            int rootU=find_root(u);
                            if(tall[rootV]<tall[rootU]){
                                par[rootV]=rootU;
                                dfsUpdate(rootV);
                            }
                            else{
                                par[rootU]=rootV;
                                if(tall[rootV]==tall[rootU])tall[rootV]++;
                                dfsUpdate(rootU);
                            }
                        }
                    }
                    else{
                        if(val[u]!=val[v])unite(u,v);
                        else{
                            memset(used,0,sizeof(used));
                            int rootV=find_root(v);
                            int rootU=find_root(u);
                            if(tall[rootV]<tall[rootU]){
                                par[rootV]=rootU;
                                dfsUpdate(rootV);
                            }
                            else{
                                par[rootU]=rootV;
                                if(tall[rootV]==tall[rootU])tall[rootV]++;
                                dfsUpdate(rootU);
                            }
                        }
                    }
                }
            }
            G[u].push_back(v);
            G[v].push_back(u);
        }
        if(ans==-1)cout<<"great"<<endl;
        else{
            cout<<"sad"<<endl;
            cout<<ans<<endl;
        }
    }
    return 0;
}

//
//                       _oo0oo_
//                      o8888888o
//                      88" . "88
//                      (| -_- |)
//                      0\  =  /0
//                    ___/`---'\___
//                  .' \\|     |// '.
//                 / \\|||  :  |||// \
//                / _||||| -:- |||||- \
//               |   | \\\  -  /// |   |
//               | \_|  ''\---/''  |_/ |
//               \  .-\__  '-'  ___/-. /
//             ___'. .'  /--.--\  `. .'___
//          ."" '<  `.___\_<|>_/___.' >' "".
//         | | :  `- \`.;`\ _ /`;.`/ - ` : | |
//         \  \ `_.   \_ __\ /__ _/   .-` /  /
//     =====`-.____`.___ \_____/___.-`___.-'=====
//                       `=---='
//
//
//     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//               佛祖保佑         永无BUG
//
//
//