E. AND-MEX Walk（思维 + 并查集）

题目链接

真难…
思维构造 + 并查集；

参考题解

分析：

首先直觉上讲(经验)，答案只有三种情况，0 1 2；

证明：
我们用w[]表示路径上边的权值，pre[]表示w[]的前缀&和；
众所周知&运算是的结果是递减的，也就是&越多数，结果越小；
很显然在pre[]中的结果是0 1，0 2是可以共存的；
而1 2 是不可能共存的：
由上面可知，如果1 2共存，则一定先出现2再出现1；
如果先出现2，则说明pre[]中由一段的前缀是010(二进制表示)；
而如果变成1时所需要的条件是前缀的最后一位都是1，即001；
显然如果前缀的有2的话肯定不满足1的条件，所以pre[]中1 2不共存；

所以如果pre[]没出现0则mex是0；
如果pre[]出现了1，则2必然没出现，所以mex是2；
如果pre[]出现了2，则1必然没出现，所以mex是1；

那么问题就转换成了怎么判断这3中情况？

1. mex = 0，说明31位中至少存在一位p，使w[]中的所有数在二进制表示下第p位都是1；
    具体的讲：
        对于每一位p，我们都可以开一个并查集，连通边权的二进制表示下第p位是1的边的点；
        这样对于每个询问，我们只需要查询是否存在一位p，u v在p位属于同一连通块就行；

2. 排除了上面的情况，我们看mex = 1的情况：
    也就是说在w[]中的某个前缀(可以是0)，存在一位p（不是最低位），这个前缀的第p位都是1；
    然后突然出现一条边权最后一位是0，也就是权值为偶数的边，使得前缀&和 不经过1骤降为0；
    
    对于除了第0位的其他位上的子图，若从起点开始，可以到达一条偶数边；
    则说明第0位上的1已经被完全消除，随后可以在连通图上随意移动，都不可能会再出现1

    怎么判断这种情况呢？
    我们换一种思维，假设当前我们在第p位(不是最低位)的并查集中；
    如果与点i的相连的边有偶数边，那么和i在同一个连通块的点；
    一定可以通过构造走第p位为1的边（前缀第p位都是1），然后再走这条偶数边；
    这样的话无论我们后面怎么走mex都是1了，后面怎么走都不影响；
    也就是说如果一个i存在偶数边，则和i在同一个连通块中的点都一定能满足答案是1的条件；
    
      所以对于每一位p的并查集，我们预处理一下就行.

都不是的话答案就是2，具体看代码！  

代码

#include<iostream>
#include<queue>
#include<cstring>
#include<vector>
#include<stdio.h>
#include<map>
#include<algorithm>
#include<deque>
#include<stack>
#include<set>
// #include <unordered_map>
#include<math.h>
#include<string.h>
#define IOS ios::sync_with_stdio(false),cin.tie(0);
using namespace std;
 
#define pb push_back
#define coutl cout<<"------------"<<endl;
#define fi first
#define se second

#define ire(x) scanf("%d",&x)
#define iire(a,b) scanf("%d %d",&a,&b)
#define lre(x) scanf("%lld",&x)
#define llre(a,b) scanf("%lld %lld",&a,&b)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define endl "\n"
#define PI acos(-1.0)
//#define int long long
typedef long long ll;
typedef unsigned long long ull;
      
typedef pair<int, int> PII;
typedef pair<double, int> PDI;
typedef pair<ll, ll> PLL;
typedef pair<double, double> PDD;
typedef pair<double, pair<int, double> > PDID;
typedef pair<char, char> PCC;
typedef pair<char, pair<int, int> > PCII;
typedef pair<int, pair<int, int> > PIII;
typedef pair<int, pair<int, pair<int, int> > > PIIII;
typedef pair<ll, pair<int, int> > PLII;

const int maxn = 2e5 + 7;
const int N = 1e6 + 7;
const int M = 1e6 + 7;
const int mod = 3*5*7*11*13*17*19*23;
const int inv = mod - mod/2;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const double pi = acos(-1);
const double eps = 1e-8;
  
ll gcd(ll a,ll b) {return b==0 ? a : gcd(b,a%b);}
ll lcm(ll a,ll b) {return a*b / gcd(a,b);}
ll qmi(ll a,ll b,ll p) {ll ans = 1; while(b) { if(b & 1) ans = ans * a % p; a = a * a % p; b >>= 1; } return ans;}
int lowbit(int x) {return x & (-x);}

int n,m;
int f[33][maxn];
int vis[maxn];	//标记这个点是否有偶数权值的边
int ok[33][maxn];	//预处理

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

void unions(int p,int a,int b)
{
	int fa = find(p,a);
	int fb = find(p,b);
	f[p][fa] = fb;	
}

int main()
{
	iire(n,m);
	
	//初始化并查集
	for(int i=0;i<31;i++) 
		for(int j=1;j<=n;j++) f[i][j] = j;
		
	while(m--)
	{
		int a,b,c;
		iire(a,b); ire(c);
		
		if(c % 2 == 0) vis[a] = vis[b] = 1;
		
		for(int i=0;i<31;i++)
			if(c >> i & 1) unions(i,a,b);
	}
	
	//预处理
	for(int i=1;i<=n;i++)
		if(vis[i])	//这个点的边中存在偶数权值的边
		{   
			for(int j=1;j<31;j++)  //j这个并查集中和i同一个连通块的点都满足1的条件
				ok[j][find(j,i)] = 1;
		}
	
	int q;
	ire(q);
	while(q--)
	{
		int a,b;
		iire(a,b);
		
		int flag = 0;
		for(int i=0;i<31;i++)
			if(find(i,a) == find(i,b))
			{
				flag = 1;
				break;
			}
		
		if(flag)
		{
			cout<<"0\n";
			continue;
		}
		
		for(int i=1;i<31;i++)
			if(ok[i][find(i,a)]) flag = 1;
		
		if(flag) cout<<1<<'\n';
		else cout<<2<<'\n';		
	}
	
	return 0;
}