加权并查集—— uva12232 Exclusive-OR

题目链接：uva12232 Exclusive-OR

分析（by 1879570236）：加权并查集，对于每一个节点，记录w[i]等于他与当前father[i]的异或值。

对于Xp^Xq=k合并m和n所在的并查集。合并的话呢：很简单。因为之前做过uva的一道cooprative network，getfather极其类似，getfather的时候更新w[i]。

加一个虚拟节点Xn==0，所以直接告诉Xp=k的话，即Xp^Xn=k。注意一个问题：在合并时，如果一个节点的father是Xn的话无条件把Xn当做合并后的父节点。

对于Q操作的话，把每个w[i]先异或起来，记录他们根节点的访问次数，如果有一个根节点的访问次数为奇数，“不知道”。因为异或不掉这个根节点的值。

另需注意：位运算优先级，打括号！！！

废话不多说，看代码。





分析（by spark）：

加权并查集的一般思路 戳这里：并查集【NOI2001 Day1 T3】食物链

考虑与父节点的关系rela[p]表示 x[p]^x[father[p]]

与爷爷节点的关系 显然为 rela[p]^rela[father[p]]

于是操作1很好维护，直接合并集合就可以了。

操作2（x[p]=v）怎么办呢?

维护一个虚拟节点n+1，将操作2视为p与n+1合并，问题就解决了。

对于询问操作：

容易发现： ans= rela[x[p1]]^rela[x[p2]]^......^rela[x[pk]]  ^(所有涉及到的出现了奇数次根节点的值)

注意到只有n+1这个集合中的点的值是已知的，所以其他根节点出现了奇数次，直接输出"I don't konw"

否则输出所有 ans= rela[x[p1]]^rela[x[p2]]^......^rela[x[pk]] 

在代码里是用了一个map来记录出现的集合以及其出现次数的。

有很多细节要注意，所以一开始就想对了，还是wa了6次。

输入的问题是用字符串流解决的，也没有想出更好更快的方法。

代码如下：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstdlib>
#include<cstring>
using namespace std;
int n,q;
struct node{
char type;
int k;
int a,b,v;
int l[30];
};
node work[50005];
int father[50005];
int w[50005];
int getfather(int x){
if(x!=father[x]){
int root=getfather(father[x]);
w[x]^=w[father[x]];
return father[x]=root;
}
else return x;
}
void solve(){
int i,j,k;
int cnt=0,ans=0;
int vis[50005];
memset(vis,0,sizeof(vis));
bool flag=true;
for(i=1;i<=q;i++){
if(work[i].type=='I'){
cnt++;
int fx=getfather(work[i].a);
int fy=getfather(work[i].b);
if(fx==n)swap(fx,fy);
if(fx==fy){
if((w[work[i].a]^w[work[i].b])!=work[i].v){
printf("The first %d facts are conflicting.\n",cnt);
return;
}
}
else{
father[fx]=fy;
w[fx]=(w[work[i].a]^w[work[i].b]^work[i].v);
}
}
else{
memset(vis,0,sizeof(vis));
ans=0;
flag=true;
for(j=1;j<=work[i].k;j++){
int fx=getfather(work[i].l[j]);
if(fx!=n)vis[fx]^=1;
ans^=w[work[i].l[j]];
}
for(j=1;j<=work[i].k;j++){
if(vis[father[work[i].l[j]]]){
flag=false;
}
}
if(flag)printf("%d\n",ans);
else printf("I don't know.\n");
}
}
}
int main(){
int Case=0;
while(cin>>n>>q&&n!=0&&q!=0){
printf("Case %d:\n",++Case);
memset(work,0,sizeof(work));
memset(father,0,sizeof(father));
memset(w,0,sizeof(w));
int i,j,k;
char s[1005];
for(i=0;i<=n;i++)father[i]=i;
for(i=1;i<=q;i++){
int a,b,v;
scanf("%s",s);
work[i].type=s[0];
if(s[0]=='I'){
gets(s);
if(sscanf(s,"%d%d%d",&a,&b,&v)==2){
v=b;
b=n;
}
work[i].a=a;work[i].b=b;work[i].v=v;
}
else if(s[0]=='Q'){
scanf("%d",&work[i].k);
for(j=1;j<=work[i].k;j++){
scanf("%d",&work[i].l[j]);
}
}
}
solve();
puts("");
}
}

#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<sstream>
#include<queue>
#include<map>
#include<algorithm>

#define xx first
#define yy second
#define LL long long
#define CLEAR(xxx) memset(xxx,0,sizeof(xxx))
#define INTpair pair<int,int>

using namespace std;
const int maxn=200000+5,inf=1e9;

int kase,facts,n,m,rela[maxn],fa[maxn];
map<int,int> cnt;
bool conflict;

int getfa(int x){
if(x==fa[x]) return x;
int father=fa[x];
fa[x]=getfa(fa[x]);
rela[x]^=rela[father];
return fa[x];
}

void Unoin(int p,int q,int v){   //x[p]^x[q] = v
int fp=getfa(p),fq=getfa(q);
if(fq==n+1) swap(fq,fp);  //注意N+1号节点只能做根节点
if(fp==fq&&((rela[p]^rela[q])!=v)) {
conflict=true ; return ;
}
if(fp==fq) return ;
//Union set p and set q with value v
fa[fq]=fp;
rela[fq]=rela[q]^v^rela[p];
}

int main(){
//freopen("ans.out","w",stdout);
int i,j,k,p,q,v;
string line;
char op;
while(cin>>n>>m&&n&&m){
for(i=0;i<=n+1;i++)fa[i]=i;
CLEAR(rela);
facts=0;conflict=false;
printf("Case %d:\n",++kase);
getline(cin,line);
for(i=1;i<=m;i++){
getline(cin,line);
if(conflict) continue;
stringstream ss(line);
ss>>op;
if(op=='I'){
facts++;
ss>>p>>v;
if(ss>>q) Unoin(p,v,q);
else Unoin(n+1,p,v);
}
else {
cnt.clear();
int ans=0,ok=1;
ss>>k;
for(j=1;j<=k;j++){
ss>>v;
cnt[getfa(v)]++;
ans^=rela[v];
}
map<int,int>:: iterator it;
for(it=cnt.begin();it!=cnt.end();it++)
if(it->xx!=n+1&&it->yy%2==1){
ok=0; break;
}
if(ok)cout<<ans<<endl;
else puts("I don't know.");
}
if(conflict)
printf("The first %d facts are conflicting.\n",facts);
}
puts("");
}
return 0;
}