「带权并查集」奇偶游戏

奇偶游戏

题目大意

给你N个区间，每个区间给你它含1的奇偶性，问你哪些询问逻辑上冲突

题目题解

一道带权并查集的题，让我对带权并查集有了更深入的理解，带权并查集可以分为两种（在这道题中）

“边带权”并查集
“扩展域”并查集

两种方法都是思维上的不同所造成的，其中第一种解法是最常见的，第二种解法在代码实现上是最简单的，我们先来对第一种进行探究

边带权，很明显，我们要在并查集的边上进行一个储存边权的操作，我们这里用d来表示当前节点到根节点的Xor值，什么意思，又如何维护呢？意思就是我们对于每条边储存的是连接的两点是否属于同一奇偶性，边权为0则相同，为1则不同，那么我们从x节点到根节点的唯一路径上所有的边权全部Xor起来，就能判断x节点和根节点是否为同一奇偶性了，这样的话我们就能够判断对于任意两点而言，x节点到根节点的Xor值和y节点到根节点的Xor值Xor起来得到的值，就是我们所需要的对于任意两点的Xor值，再和我们当前询问的奇偶性进行Xor，如果为1则说明冲突，如果为0则说明不冲突

那既然我们的查询解决完了，我们就要解决合并的问题了，接着上一段的最后继续说，我们当前有x, y两个点，和他们的根p, q，令连接后p为q的子节点，那么我们现在要求的就是d[p]了，d[p]怎么求？我们现在已知的信息是d[x] 和 d[y] 也就是 x~p 和 y_{q，我们现在要求的是p}q，我们已知x~y是由 x_p，yq，p~q 来组成的，那么 x y 的奇偶性 (我们这里用(cnt_{x, y})来表示任意两点的奇偶性，这个奇偶性怎么来了？输入就给了) (cnt_{x,y} = d[x]Xord[y]Xord[p]) 那么我们就可以得到(d[p] = d[x] Xord[y]Xorans_{x, y}) 了，于是合并操作也就完成了。

进行完这两个之后，我们就对题本身进行分析一下，因为本题中给的是一个区间，而并非一个点，所以我们还得将区间转化为点，区间转化为点？感觉很熟悉？对，的确很熟悉我们在防线这道题中用过类似的方法，就是用前缀和保存奇偶性，什么意思？详细可以看上面那道题，我这里就不再赘述，转化到本题上来，我们既然要转化到点，这个数据范围肯定是不行的，我们考虑离散化。

那么离散化之后，我们就得到了一个序列，这个序列的点是紧紧挨着的，我们这里就能够通过上面的区间转点来搞定了，比如我们现在要合并一个区间 (l, r)，那实际上 (l,r) 的奇偶性已经是已知的了，（很多人卡在这里，不知道这里要怎么进行操作，也有很多人没想到用并查集来维护..，卡在套路上了），那么(l - 1) 到前面的某一个值的奇偶性一定也是已知的，那么我们就将 (r) 和 (l - 1) 用并查集维护（想想为什么？答案很显然），这样我们就维护了两个区间的奇偶性并且将两个区间合并。

根据上面的信息，我们就完成了这道题，代码如下

//#define fre yes

#include <cstdio>
#include <algorithm>

const int N = 20005;
int ele[N << 1];
struct message {
    int l, r, ans;
} arr[N];

bool flag;
namespace Union {
    int par[N], d[N];
    inline void init(int n) {
        for (int i = 1; i <= n; i++) {
            par[i] = i;
        }
    }
    
    int find(int x) {
        if(par[x] == x) return par[x];
        int rt = find(par[x]);
        d[x] ^= d[par[x]];
        return par[x] = rt;
    }
    
    inline void unite(int x, int y, int a, int b, int i) {
        par[a] = b;
        d[a] = d[x] ^ d[y] ^ arr[i].ans;
    }
    
    inline void solve(int x, int y, int i) {
        if((d[x] ^ d[y]) != arr[i].ans) {
            printf("%d
", i - 1);
            flag = 1;
        } 
    }
}

int m;
inline void discrete(int n) {
    std::sort(ele + 1, ele + 1 + n * 2);
    m = std::unique(ele + 1, ele + 1 + n * 2) - ele - 1;
}

int ask(int x) {
    return std::lower_bound(ele + 1, ele + 1 + m, x) - ele;
}

int main() {
    static int n, T;
    scanf("%d %d", &T, &n);
    for (int i = 1; i <= n; i++) {
        int x, y; char c[6];
        scanf("%d %d %s", &x, &y, c + 1);
        arr[i].l = x; arr[i].r = y;
        arr[i].ans = (c[1] == 'e' ? 0 : 1);
        ele[i] = x - 1; ele[i + n] = y;
    } 
    
    discrete(2 * n);
    Union::init(m);
    
    for (int i = 1; i <= n; i++) {
        int x = ask(arr[i].l - 1);
        int y = ask(arr[i].r);
        int p = Union::find(x), q = Union::find(y);
        if(p == q) {
            Union::solve(x, y, i);
            if(flag) return 0;
        } else Union::unite(x, y, p, q, i);
    } printf("%d
", n);
    return 0;
}

然后我们再来讨论第二种方法，扩展域并查集，第二种方法思维上更简单，代码上更容易实现，因为不会涉及到位运算等知识，怎么来运作的呢？

将每个节点(x)拆成两个节点，(x_{odd}) 与 (x_{even}) 分别表示sum[x]为奇数和sum[x]为偶数，我们经常也把这两个节点成为x的“奇数域”和“偶数域”。

那么就会有以下情况，设离散化后的(l - 1) 与 (r) 的值分别是 (x) 和 (y) ，设 (cnt) 为两点的奇偶性（这里只是读入的）

若 cnt = 0 则合并 (x_{odd}) 与 (y_{odd}) ，(x_{even}) 与 (y_{even}) 。这表示"x为奇数"与"y为奇数"可以互相推出，"x为偶数" 与 "y为偶数"也可以互相推出，它们是等价的信息 .
若 cnt = 0 则合并 (x_{odd}) 与 (y_{even})，(x_{even}) 与 (y_{odd}) 。这表示"x为奇数"与"y为偶数"可以互相推出，"x为偶数" 与 "y为奇数" 也可以互相推出，它们是等价的信息。（为何能够相互推出？可以自己想想）

上述合并也维护了关系的传递性，在处理完(x, y, 0)与(y, z, 1)两个关系之后，很显然 x, z的关系也就明显了，这种做法就相当于在无向图上维护节点之间的连通情况，只是拓展了多个域来应对多种传递关系

若 x, y 对应 (x_{odd}) 与 (y_{odd}) 在同一集合内，就说明二者奇偶性相同，若 x, y 对应 (x_{odd}) 与 (y_{even}) 在同一集合内，则已知二者奇偶性不同

那么以上信息，我们就可得代码，代码如下

//#define fre yes

#include <cstdio>
#include <algorithm>

const int N = 20005;
int ele[N << 1];
struct message {
    int l, r, ans;
} arr[N];

bool flag;
namespace Union {
    int par[N], d[N];
    inline void init(int n) {
        for (int i = 1; i <= n; i++) {
            par[i] = i;
        }
    }
    
    int find(int x) {
        if(par[x] == x) return par[x];
        return par[x] = find(par[x]);
    }
    
    inline void unite(int x, int y) {
        int a = find(x);
        int b = find(y);
        if(a == b) return ;
        
        par[a] = b;
    }
}

int m;
inline void discrete(int n) {
    std::sort(ele + 1, ele + 1 + n * 2);
    m = std::unique(ele + 1, ele + 1 + n * 2) - ele - 1;
}

int ask(int x) {
    return std::lower_bound(ele + 1, ele + 1 + m, x) - ele;
}

int main() {
    static int n, T;
    scanf("%d %d", &T, &n);
    for (int i = 1; i <= n; i++) {
        int x, y; char c[6];
        scanf("%d %d %s", &x, &y, c + 1);
        arr[i].l = x; arr[i].r = y;
        arr[i].ans = (c[1] == 'e' ? 0 : 1);
        ele[i] = x - 1; ele[i + n] = y;
    } 
    
    discrete(2 * n);
    Union::init(m * 2);
    
    for (int i = 1; i <= n; i++) {
        int x = ask(arr[i].l - 1);
        int y = ask(arr[i].r);
        int x_odd = x, x_even = x + m;
        int y_odd = y, y_even = y + m;
        if(arr[i].ans == 0) {
            if(Union::find(x_odd) == Union::find(y_even)) {
                printf("%d
", i - 1);
                return 0;
            }
            
            Union::unite(x_odd, y_odd);
            Union::unite(x_even, y_even);
        } else {
            if(Union::find(x_odd) == Union::find(y_odd)) {
                printf("%d
", i - 1);
                return 0;
            }
            
            Union::unite(x_odd, y_even);
            Union::unite(x_even, y_odd);
        }
    } printf("%d
", n);
    return 0;
}