「带权并查集」奇偶游戏

Posted nicoppa

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了「带权并查集」奇偶游戏相关的知识,希望对你有一定的参考价值。

奇偶游戏

原题链接:奇偶游戏

题目大意

给你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,y~q,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\\n", 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", 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\\n", 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\\n", i - 1);
                return 0;
            
            
            Union::unite(x_odd, y_even);
            Union::unite(x_even, y_odd);
        
     printf("%d\\n", n);
    return 0;

以上是关于「带权并查集」奇偶游戏的主要内容,如果未能解决你的问题,请参考以下文章

BZOJ 3376[Usaco2004 Open]Cube Stacking 方块游戏 带权并查集

bzoj3376-方块游戏带权并查集

Codeforces Round #396 (Div. 2)D. Mahmoud and a Dictionary(带权并查集)

Codeforces Round #396 (Div. 2)D. Mahmoud and a Dictionary(带权并查集)

总结一下我理解的带权并查集

poj 2912 Rochambeau(枚举+带权并查集)