//7968286 vrs 1182 Accepted 548K 219MS C 1078B 2010-12-04 21:33:24
//1182 食物链 利用向量偏移的并查集
//
//每个集合都有三类动物，用rank表示，0——同类；1——食物；2——天敌，初始时都以自己为根节点，且rank为0
//只需对每一句话，判断x，y是否同一集合内，如果是就判断语句真假，否则就合并集合
//根据公式知道x-y=d-1，主要想出几个推导公式：
//1: rank[x]=(rank[x]+rank[temp])%3
// 这个最好设一两个例子验证一下，由于每次都是两集合的根合并，且只有根更改rank，所以每个x的rank值只会与
// 它的father有关（只有一次father更改，就是跟合并时），然后结合向量偏移得到。
//2: rank[rooty]=(rank[x]-rank[y]-excusion+3)%3;
//3: (rank[x]-rank[y]+3)%3!=d-1;
//三个公式都与向量偏移计算得来，看下面的详解
#include<stdio.h>
unsigned int setFather[50005];
unsigned int rank[50005];
unsigned int Find(unsigned int x)
{
unsigned int temp;
if(x==setFather[x])
return x;
temp=setFather[x];
setFather[x]=Find(setFather[x]);
//这里注意，在路径压缩过程中，由于递归时是先算根然后一直往叶子算过来，所以seFather[x]并不是原来x的父亲
rank[x]=(rank[x]+rank[temp])%3; //第一个
return setFather[x];
}
void Union(unsigned int x,unsigned int y,int excusion)
{
unsigned int rootx,rooty;
rootx=Find(x);
rooty=Find(y);
setFather[rooty]=rootx;
rank[rooty]=(rank[x]-rank[y]-excusion+3)%3; //第二个
}
int main()
{
unsigned int n,k,i;
unsigned int d,x,y;
unsigned int wrongNum;
unsigned int rootx,rooty;
scanf("%d%d",&n,&k);
wrongNum=0;
for(i=1;i<=n;i++)
{
setFather[i]=i;
rank[i]=0;
}
while(k--)
{
scanf("%d%d%d",&d,&x,&y);
if(x>n || y>n || (d==2 && x==y))
{
wrongNum++;
continue;
}
rootx=Find(x);
rooty=Find(y);
if(rootx!=rooty)
Union(x,y,d-1);
else
{
if((rank[x]-rank[y]+3)%3!=d-1) //第三个
wrongNum++;
}
}
printf("%d\n",wrongNum);
return 0;
}
//附1:
//向量偏移解说
/*
> 什么叫做向量的思维模式？
> Orz Orz
我的理解是，对于集合里的任意两个元素a,b而言，它们之间必定存在着某种联系，
因为并查集中的元素均是有联系的，否则也不会被合并到当前集合中。那么我们
就把这2个元素之间的关系量转化为一个偏移量，以食物链的关系而言，不妨假设
a->b 偏移量0时 a和b同类
a->b 偏移量1时 a吃b
a->b 偏移量2时 a被b吃，也就是b吃a
有了这些基础，我们就可以在并查集中完成任意两个元素之间的关系转换了。
不妨继续假设，a的当前集合根节点aa，b的当前集合根节点bb，a->b的偏移值为d-1（题中给出的询问已知条件）
(1)如果aa和bb不相同，那么我们把bb合并到aa上，并且更新delta[bb]值（delta[i]表示i的当前集合根节点到i的偏移量）
此时 aa->bb = aa->a + a->b + b->bb，可能这一步就是所谓向量思维模式吧
上式进一步转化为：aa->bb = (delta[a]+d-1+3-delta[b])%3 = delta[bb]，（模3是保证偏移量取值始终在[0,2]间）
(2)如果aa和bb相同，那么我们就验证a->b之间的偏移量是否与题中给出的d-1一致
此时 a->b = a->aa + aa->b = a->aa + bb->b，
上式进一步转化为：a->b = (3-delta[a]+delta[b])%3，
若一致则为真，否则为假。
*/
//附2：
/*
//这是自己原来想的方法，很麻烦。。。
//用了两重并查集，结果是300个测试数据过了，3000个就WA，郁闷得要死。。。
//我的思路是每个森林都有3类ABC，假如第一次碰到动物k，就新建森林容纳他们，一旦发现他们分别属于森林且有1，或2
//的关系，就合并森林，同时把三类分别合并一起。。。
#include<stdio.h>
#include<string.h>
#define bool int
#define NONESTATES 50004
typedef struct _RELATIVE
{
unsigned int father;
unsigned int next;
unsigned int last;
int typeABC;
}RELATIVE;
RELATIVE setRelative[50005];
unsigned int setFather[50005];
bool setState[50005];
//查找在哪个森林
unsigned int Find(unsigned int x)
{
unsigned int temp,root;
root=x;
while(setFather[root]!=root)
root=setFather[root];
temp=x;
while(setFather[x]!=x)
{
temp=setFather[x];
setFather[x]=root;
x=temp;
}
return root;
}
//查找在哪个类中
unsigned int FindType(unsigned int x)
{
unsigned int temp,root;
root=x;
while(setRelative[root].father!=root)
root=setRelative[root].father;
temp=x;
while(setRelative[x].father!=x)
{
temp=setRelative[x].father;
setRelative[x].father=root;
x=temp;
}
return root;
}
//合并两个森林中的三类
//这里的操作非常复杂，我自己都看晕了，跳过吧
void UnionType(unsigned int x,unsigned int y,int type)
{
unsigned int subRootX,subRootY;
subRootX=FindType(x);
subRootY=FindType(y);
if(type==1)
{
//处理A类关系
setRelative[subRootY].father=subRootX;
//处理B类关系
if(setRelative[subRootY].next!=NONESTATES && setRelative[subRootX].next!=NONESTATES)
setRelative[ setRelative[subRootY].next ].father=setRelative[subRootX].next;
else if(setRelative[subRootY].next!=NONESTATES)
{
setRelative[ setRelative[subRootY].next ].typeABC=(setRelative[subRootX].typeABC+1)%3;
setRelative[ setRelative[subRootY].next ].last=subRootX;
setRelative[subRootX].next=setRelative[subRootY].next;
if(setRelative[subRootX].last!=NONESTATES)
setRelative[ setRelative[subRootY].next ].next=setRelative[subRootX].last;
}
//处理C类关系
if(setRelative[subRootY].last!=NONESTATES && setRelative[subRootX].last!=NONESTATES)
setRelative[ setRelative[subRootY].last ].father=setRelative[subRootX].last;
else if(setRelative[subRootY].last!=NONESTATES)
{
setRelative[ setRelative[subRootY].last ].typeABC=(setRelative[subRootX].typeABC+2)%3;
setRelative[ setRelative[subRootY].last ].next=subRootX;
setRelative[subRootX].last=setRelative[subRootY].last;
if(setRelative[subRootX].next!=NONESTATES)
setRelative[ setRelative[subRootY].last ].last=setRelative[subRootX].next;
}
}
else
{
//处理Y所在的A类关系
if(setRelative[subRootX].next!=NONESTATES)
setRelative[subRootY].father=setRelative[subRootX].next;
else
{
setRelative[subRootX].next=subRootY;
setRelative[subRootY].typeABC=(setRelative[subRootX].typeABC+1)%3;
setRelative[subRootY].last=subRootX;
if(setRelative[subRootX].last!=NONESTATES)
setRelative[subRootY].next=setRelative[subRootX].last;
}
//处理Y所在的B类关系
if(setRelative[subRootY].last!=NONESTATES)
setRelative[ setRelative[subRootY].last ].father=subRootX;
//处理Y所在的C类关系
if(setRelative[subRootX].last!=NONESTATES && setRelative[subRootY].next!=NONESTATES)
setRelative[ setRelative[subRootY].next ].father=setRelative[subRootX].last;
else if(setRelative[subRootY].next!=-1)
{
setRelative[subRootX].last=setRelative[subRootY].next;
setRelative[ setRelative[subRootY].next ].typeABC=(setRelative[subRootX].typeABC+2)%3;
setRelative[ setRelative[subRootY].next ].next=subRootX;
if(setRelative[subRootX].next!=NONESTATES)
setRelative[ setRelative[subRootY].next ].last=setRelative[subRootX].next;
}
}
}
//合并两个森林
void Union(unsigned int x,unsigned int y,int type)
{
unsigned int rootX,rootY,temp;
rootX=Find(x);
rootY=Find(y);
if(rootX>rootY)
{
temp=rootX;
rootX=rootY;
rootY=temp;
}
setFather[rootY]=rootX;
if(type==NONESTATES)
return;
UnionType(x,y,type);
}
//如果是存在第一次遇到的动物，就合并或新建一个森林
void NewSet(unsigned int x,unsigned int y,int statementType)
{
unsigned int tempRoot;
Union(x,y,NONESTATES);
if(statementType==1)
{
if(setState[y]==1)
setRelative[x].father=y;
else if(setState[x]==1)
setRelative[y].father=x;
else
{
setRelative[y].father=x;
setRelative[x].typeABC=0;
}
}
else
{
if(setState[y]==1)
{
tempRoot=FindType(y);
if(setRelative[tempRoot].last==NONESTATES)
{
setRelative[tempRoot].last=x;
setRelative[ setRelative[tempRoot].next ].next=x;
setRelative[x].typeABC=(setRelative[tempRoot].typeABC+2)%3;
setRelative[x].next=tempRoot;
setRelative[x].last=setRelative[tempRoot].next;
}
else
setRelative[x].father=setRelative[tempRoot].last;
}
else if(setState[x]==1)
{
tempRoot=FindType(x);
if(setRelative[tempRoot].next==NONESTATES)
{
setRelative[tempRoot].next=y;
setRelative[ setRelative[tempRoot].last ].last=y;
setRelative[y].typeABC=(setRelative[tempRoot].typeABC+1)%3;
setRelative[y].next=setRelative[tempRoot].last;
setRelative[y].last=tempRoot;
}
else
setRelative[y].father=setRelative[tempRoot].next;
}
else
{
setRelative[x].typeABC=0;
setRelative[x].next=y;
setRelative[y].typeABC=1;
setRelative[y].last=x;
}
}
}
//两个动物都出现过的，可以判断是真是假
bool Judge(unsigned int x,unsigned int y,int statementType)
{
if(statementType==1 && setRelative[ FindType(x) ].typeABC==setRelative[ FindType(y) ].typeABC)
return 1;
else if(statementType==2 && (setRelative[ FindType(x) ].typeABC+1)%3==setRelative[ FindType(y) ].typeABC)
return 1;
return 0;
}
int main()
{
unsigned int n,k;
unsigned int D,X,Y;
unsigned int i;
long wrongStatementNum;
scanf("%d %d",&n,&k);
memset(setState,0,sizeof(setState));
for(i=1;i<=n;i++)
{
setFather[i]=i;
setRelative[i].father=i;
setRelative[i].next=NONESTATES;
setRelative[i].last=NONESTATES;
}
wrongStatementNum=0;
while(k--)
{
scanf("%d %d %d",&D,&X,&Y);
if((X>n || Y>n) || (D==2 && X==Y))
{
wrongStatementNum++;
continue;
}
if(setState[X]==1 && setState[Y]==1)
{
if(Find(X)==Find(Y))
{
if(Judge(X,Y,D)==0)
wrongStatementNum++;
}
else
Union(X,Y,D);
}
else
{
NewSet(X,Y,D);
}
setState[X]=setState[Y]=1;
}
printf("%ld\n",wrongStatementNum);
return 0;
}
*/
