【HDU1272】小希的迷宫解题报告，数据+思路+代码

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#define INPUT
using namespace std;
/*
Problem : HDU1272 - 小希的迷宫
State   ：
5421320	2012-02-26 23:40:14	Accepted	1272	62MS	1636K	3853 B	G++	c0de4fun
Begin Time:26th/2/2012 9:30 p.m;
End Time:26th/2/2012 11:43 p.m
Cost Time: 2 hrs 13 mins;
测试数据：
1 4 1 2 2 12 12 13 12 15 15 11 11 3 3 2 4 5 5 9 5 6 6 7 6 8 9 10
0 0
1 2 1 3 1 4 2 8 8 9 3 5 5 10 10 12 4 6 6 11 4 7
0 0
1 2 3 1 4 1 8 2 8 9 5 3 5 10 10 12 6 4 6 11 4 7
0 0
1 4 2 1 2 12 12 13 15 12 15 11 11 3 2 3 4 5 5 9 5 6 6 7 6 8 9 10
0 0
6 8  5 3  5 2  6 4
5 6  0 0
8 1  7 3  6 2  8 9  7 5
7 4  7 8  7 6  0 0
3 8  6 8  6 4
5 3  5 6  5 2  0 0
1 2 3 4 0 0
1 2 0 0
-1 -1
Output:
No
Yes
Yes
No
Yes
Yes
No
No
Yes
思路：
考察并查集。
每增添一个元素，都要压缩路径，将其parent压缩到顶点。
注意，压缩路径不能采用递归的方式，否则会Exceeded。
压缩路径用while的方式。
每读入一对i,j时有三种情况：
（1）i存在，j不存在
这时候j是新增加的元素
nodes[j].parent = findSet(nodes[i]);
就可以，顺便把nodes[i]的parent更新，并且
counts++，增加统计数据，还要统计Rank.
nodes[nodes[j].parent].rank++;
每个“代表”的Rank就是其集合中的元素数目，会有用的
（2）j存在，i不存在
跟（1）一样，只不过是
nodes[i].parent = findSet(nodes[j]);
counts++;
nodes[nodes[i].parent].rank++;
（3）j存在，i存在
这不太好办
首先判断nodes[j].parent 是否等于 nodes[i].parent
如果是的话，那么fail = true;
如果不是的话
调用Union，Union分别找到j,i的parent
然后Linked双方的Parent，Parent的Rank较大一方成为
新集合的“代表”，较大一方的Rank更新，同时head指向
较大一方
（4）i,j都不存在
这里我们默认j的parent = i，
【但是没有调用findSet!!!!】
所以 head = i！！
——————————————————————————
需要注意的是，每次调用findSet的时候，需要返回
压缩路径之后的“代表”的下标。以便判断两个已有集合代表
是否相同，同时，还要更新head指针，使其指向该代表。
以便通过代表的Rank和总的元素个数count判断是否只存在
一个集合，如果存在两个集合，那么就Fail = true;

注意，i,j都不存在的时候head = i 否则 1 2 0 0会输出No
———————————————————————————
结果的判断
只要判断目前head指向的代表的Rank 是否小于 count就可以判断出来
fail，如果小于，那么fail = true;
还有要注意的是fail在i存在，j存在的每次findSet之后也会判断一次
if(fail) print No
else print Yes

Have fun,c0de4fun.
*/
const int MAX_SIZE = 100010;
struct node
{
int parent;
int val;
int rank;
};
node nodes[MAX_SIZE];
int allRank = 0;
//bool Unioned = false;
bool fail = false;
int head = 0;
void Link(int x,int y)
{
if(nodes[x].rank > nodes[y].rank)
{
nodes[y].parent = x;
nodes[x].rank = nodes[x].rank + nodes[y].rank;
allRank = nodes[x].rank;
head = x;
}
else
{
nodes[x].parent = y;
nodes[y].rank = nodes[y].rank + nodes[x].rank;
allRank = nodes[y].rank;
head = y;
}
}
int findSet(node* n)
{
node tmp;
tmp = *n;
while(tmp.val != tmp.parent)
{
tmp = nodes[tmp.parent];
}
n->parent = tmp.val;
head = tmp.val;
return tmp.val;
}
void Union(node *i,node *j)
{
//   Unioned = true;
Link(findSet(i),findSet(j));
}
int main(int argc,char* argv[])
{
int i,j,count = 0;
#ifdef INPUT
freopen("b:\\acm\\hdu1272\\input.txt","r",stdin);
#endif
while(scanf("%d%d",&i,&j)!= EOF)
{
if( i != - 1 && j != -1)
{
if( i != 0 && j != 0 )
{
//Judge if i already existed.
if(nodes[i].val == 0)
{
//Not Existed.
//makeSet(nodes[i])
nodes[i].parent = i;
nodes[i].val = i;
nodes[i].rank = 1;
count++;
if(nodes[j].val == 0)
{
nodes[j].parent = i;
nodes[j].val = j;
nodes[i].rank++;
head = i;
count++;
}
else
{
//node[i].parents = j!
//  nodes[i].parent = findSet(&node[j]);
nodes[i].parent = findSet(&nodes[j]);
nodes[i].val = i;
nodes[nodes[i].parent].rank++;
}
}
else //Already Existed
{
//   nodes[j].parent = i;
if(nodes[j].val != 0)
{ // To see if nodes[j] existed
//Yes
nodes[j].val = j;
// nodes[j].parent = i;
findSet(&nodes[j]);
if (nodes[j].parent == nodes[i].parent)
fail = true;
else
Union(&nodes[j],&nodes[i]);
}
else
{  //No
nodes[j].parent = i;
nodes[j].val = j;
findSet(&nodes[j]);
nodes[nodes[j].parent].rank++;
count++;
}
}

}
else
{
/*  if(Unioned)
{
if(allRank < count)
fail = true;
} */
//head没判断明白！
if(nodes[head].rank < count)
fail = true;
if(fail)
printf("No\n");
else
printf("Yes\n");
////Judge now¡ü
fail = false;
allRank = 0;
count = 0;
Unioned = false;
head = 0;
memset(nodes,0,sizeof(node)*MAX_SIZE);
}
}
}
return 0;
}