POJ: Percolation

题目链接：http://algorithm.openjudge.cn/2020hw2/C/

题目描述：定义一个N行N列的矩阵，矩阵中的每个元素是个方格，每个方格有两种可能的状态：开通的或关闭的。初始时，所有方格都是关闭的。输入数据的每一步会指定矩阵中某个原来关闭的方格变成开通的。要求编写程序判断当前是否存在从矩阵中最上面一行的任何一个开着的方格走到最下面一行的任何一个开着的方格的路径。如果存在的话，输出当前的步数。比如走到第14步时，矩阵变成上下通透的，那么就输出14。注意：输入数据中只会把矩阵中的一部分方格打开。如果所有步骤都执行完了，矩阵仍然不是上下通透的，那么输出-1。显然，矩阵变成上下通透的一个必要条件是：最上面一行和最下面一行都至少要有一个方格是打开的。

在矩阵中行走时，只能横着走或竖着走，不能斜着走，也不能走出矩阵的边界。

题目的大致意思是判断一个二维矩阵上下是否相通

本题的思路是设定两个虚拟的点一个在最上面，一个在最下面，然后将第一行的点与最上面的虚拟点连接，最后一行的点与最下面的虚拟点连接，然后对每个访问到的点的上下左右四个点依次访问加入到关系网中，最后判断这两个虚拟点所在的两个网什么时候相通。

代码在poj里是AC的，但是由于box数组开的太大，所以在本地跑会溢出。

#include<iostream>
using namespace std;


typedef struct member
{
	int pos;
	bool sign;
}member;

void init(member box[], int n) //初始化,矩阵每个元素自己做自己的根节点，且都尚未激活
{                              //访问过的元素是激活的元素，没有访问过的元素是沉默的
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++)
		{
			box[(i - 1)*n + j].pos = (i - 1)*n + j;//自己做自己的节点,指向自己
			box[(i - 1)*n + j].sign = false;
		}
}

member Find(member box[], int a)
{
	if (box[a].pos == a)
		return box[a];
	else
		return box[a]=Find(box, box[a].pos);//路径压缩
}

void Union(member box[], int a, int b)
{
	member aroot = Find(box, a);
	member broot = Find(box, b);
	if (aroot.pos == broot.pos)//在同一个关系网内
		return;
	else
	{
		box[broot.pos] = aroot;
		return;
	}
}

int main() {
	int T;
	cin >> T;
	while (T--)
	{
		int n, m;
		cin >> n >> m;
		member box[1000005] = { 0 };
		init(box, n);
		//创建两个虚拟点0，n*n+1;且这两个点是被激活的,一个在最上面，一个在最下面。
		box[0].pos = 0;
		box[0].sign = true;
		box[n*n + 1].pos = n*n + 1;
		box[n*n + 1].sign = true;
		int result = 0;
		for (int i = 1; i <= m; i++)
		{
			int x, y;
			cin >> x >> y;
			if (result != 0)
				continue;
			int loc = (x - 1)*n + y;
			box[loc].sign = true;//激活这个元素
			if (loc >= 1 && loc <= n)//如果这个元素在二维矩阵中的第一行，让他与最上面的虚拟点相连
			{
				member a = Find(box, 0);
				member b = Find(box, loc);
				if (a.pos != b.pos)
					Union(box, a.pos, b.pos);
			}
			if (loc >= n*(n - 1) && loc <= n*n)//如果这个元素在二维矩阵中的最后一行，让他与最下面的虚拟点相连
			{
				member a = Find(box, n*n + 1);
				member b = Find(box, loc);
				if (a.pos != b.pos)
					Union(box, a.pos, b.pos);
			}
			//loc不在最左边，且loc左边的元素是激活的
			if (loc%n != 1 && box[loc - 1].sign == true)//left
			{
				member a = Find(box, loc - 1);
				member b = Find(box, loc);
				if (a.pos != b.pos)
				{
					Union(box, a.pos, b.pos);//将这两个点聚合，使其在一个关系网内
				}
			}
			//loc不在第一行，且loc上面的元素是激活的
			if (loc > n && box[loc - n].sign == true)//up
			{
				member a = Find(box, loc - n);
				member b = Find(box, loc);
				if (a.pos != b.pos)
				{
					Union(box, a.pos, b.pos);//将这两个点聚合，使其在一个关系网内
				}
			}
			//loc不在最右行，且loc右面的元素是激活的
			if ((loc%n != 0 && box[loc + 1].sign == true))//right
			{
				member a = Find(box, loc + 1);
				member b = Find(box, loc);
				if (a.pos != b.pos)
				{
					Union(box, a.pos, b.pos);//将这两个点聚合，使其在一个关系网内
				}
			}
			//loc不在最后行，且loc下面的元素是激活的
			if (loc < n*n - n + 1 && box[loc + n].sign == true)//down
			{
				member a = Find(box, loc + n);
				member b = Find(box, loc);
				if (a.pos != b.pos)
				{
					Union(box, a.pos, b.pos);//将这两个点聚合，使其在一个关系网内
				}
			}
			//路径压缩在find里，只有查一下find，box[]中存储的才是指向的根节点
			member root0=Find(box, 0);
			member root2n_1 = Find(box, n*n+1);
			Find(box, n*n + 1);
			if (root0.pos == root2n_1.pos)
			{
				result = i;
			}
		}
		cout << result << endl;
	}
	system("pause");
	return 0;
}