51nod 1515 明辨是非 && 2017百度之星初赛第一场第二题（并查集+启发式合并）

题目：

原题链接
给n组操作，每组操作形式为x y p。
当p为1时，如果第x变量和第y个变量可以相等，则输出YES，并限制他们相等；否则输出NO，并忽略此次操作。
当p为0时，如果第x变量和第y个变量可以不相等，则输出YES，并限制他们不相等 ；否则输出NO，并忽略此次操作。
n<=1*10^5

题解：

暑假打百度之星时还傻傻地以为这题就是奇偶游戏（奇偶游戏中变量的值只能是0，1）。

等于有传递性，我们可以用并查集把相同的元素搞在一个集合里。
并查集中，每个联通块的根节点上有一个set，维护的是与这个联通块不同的变量是哪些。

假设现在要求x=y，则x所在联通块的根节点的set中不能含有y所在连通块的根节点，反过来也满足则x可以等于y。
之后就要合并，我们可以把set的size小的合并到set的size大的，注意合并时双向都要改。

假设现在x≠y，则x，y不在一个连通块里即可。注意给set加东西。

最坏情况就是每一次都是两个大小几乎相同的set合并成一个set，这样会转移O(n log n)次，算上set的复杂度，就是O(n log n log n).

本来应该很快的，因为怎么可能轻易达到极限呢。
可是常数有点大，我交了好几次，压线过的。
发现纪中一干大佬都是压线的，于是我很想知道跑300-ms的大佬是怎么卡的.

Code:

#include
#include
#include
#define fo(i, x, y) for(int i = x; i <= y; i ++)
using namespace std;

const int N = 1e5 + 5;

int n, x, y, p, tot;
int f[N * 2]; set<int> s[N * 2];

struct node {
    int x, y, p;
}a[N];

struct node2 {
    int x, l, r;
}b[N * 2];

bool rank_b(node2 a, node2 b) {
    return a.x < b.x;
}

int find(int x) {
    return f[x] == x ? x : (f[x] = find(f[x]));
}

set<int> :: iterator it;

void bin(int x, int y) {
    if(s[x].size() > s[y].size()) swap(x, y);
    while(!s[x].empty()) {
        int z = *s[x].begin();
        s[y].insert(z);
        s[z].erase(s[z].find(x)); s[z].insert(y);
        s[x].erase(s[x].begin());
    }
    f[x] = y;
}

int main() {
    scanf("%d", &n);
    fo(i, 1, n) {
        scanf("%d %d %d", &a[i].x, &a[i].y, &a[i].p);
        b[++ tot].x = a[i].x; b[tot].l = i; b[tot].r = 0;
        b[++ tot].x = a[i].y; b[tot].l = i; b[tot].r = 1;
    }
    sort(b + 1, b + tot + 1, rank_b);
    int la = 1; tot = 0; b[n * 2 + 1].x = -1e9;
    fo(i, 2, n * 2 + 1) if(b[i].x != b[i - 1].x) {
        ++ tot;
        fo(j, la, i - 1) if(b[j].r) a[b[j].l].y = tot; else a[b[j].l].x = tot;
        la = i;
    }
    fo(i, 1, tot) f[i] = i;
    fo(i, 1, n) {
        x = a[i].x; y = a[i].y; p = a[i].p;
        if(!p) {
            if(find(x) == find(y)) {
                printf("NO\n");
            } else {
                printf("YES\n");
                s[f[x]].insert(f[y]); s[f[y]].insert(f[x]);
            }
        } else {
            if(find(x) != find(y)) {
                if((s[f[x]].count(f[y]) == 0) && (s[f[y]].count(f[x]) == 0)) {
                    printf("YES\n"); bin(f[x], f[y]);
                } else printf("NO\n");
            } else printf("YES\n");
        }
    }
}