2016 UESTC Training for Data Structures H - 郭大侠与英雄学院 CDOJ 1338 并查集

H - 郭大侠与英雄学院

就是给你一个n*m的矩阵，然后叫你缩小这个矩阵，而且每行每列的数之间的大小关系不变，而且全为正数。

开始时想了好久也没想出来

先讨论没有重复点的情况，就是先把所有点按值升序排序，然后依次往新矩阵里放，放时的新的值为max(它所在行的最大值，它所在列的最大值)+1。然后这么放就行

但是有重复点，就比较麻烦了，而且只有同行同列的重复点才会产生影响，就是他们在新矩阵的值必须是一样的，如果不同行不同列，那么就没有影响

然后对于同行同列的相等的数，就必须用并查集把他们放到同一个集合里，

然后就是每行每列的扫过去就行，然后我是用set查的，遇到重复就并查集合并，那并查集用什么来编号呢，我是用的他们的位置，把二维转一维后按位置编号，这样编号就唯一啦，然后后面操作也方便

然后也是按值升序sort，然后从小到大往里面放数

还是考虑重复的情况，对于同一行同一列，相同数必须也要有对应的相同的新值，但是我们是按值的大小放的，所以所有相同的值会连续的放完，然后再放下一批相同的数，这样的话，我们就需要保存每行每列上的最大值，和这个最大值对应的之前的值的所在集合的根节点的那个编号，为什么要保存这个呢，首先要保存最大值是肯定的，然后因为考虑到相同的值是同一个集合嘛，所以要保存最大值所在集合的编号

然后后面更新的时候，如果发现当前值所在集合的编号和目前所在行/列的最大值的编号一样，就说明已经出现过了，不要再处理了，然后如果不一样的话，就是max(当前值所在集合的对应值，行最大值+1)，然后再max(当前值所在集合的对应值，列最大值+1)。当然，我把所有数的初始对应值都设为0。

然后因为我们所有同一集合里的数必须有相同的新值，所以我们更新时更新的是这个数的根节点的对应值，

这样操作完之后，就该输出啦，输出时我们也是输出这个点的根节点的新值就好啦

end

代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <set>
using namespace std;
#define ll long long
#define maxn 1000005
int n, m;
struct Node
{
	int num, idx;
	void make(int n, int i)
	{
		num=n,idx=i;
	}
	bool operator <(Node x)const
	{
		return num < x.num;
	}
	bool operator ==(Node x)const
	{
		return num == x.num;
	}
	bool operator <=(Node x)const
	{
		return num <= x.num;
	}
}grid[maxn], row[maxn], column[maxn];
int aim[maxn];
int parent[maxn];
int size[maxn];//结点数
void init_parent()
{
	for (int i = 0; i<maxn; ++i)
	{
		parent[i] = i;
		size[i] = 1;
	}
}
int findparent(int x)//路径压缩
{
	if (x == parent[x])
		return x;
	else
		return parent[x] = findparent(parent[x]);
}
void unionparent(int x, int y)//启发式合并
{
	int fx = findparent(x);
	int fy = findparent(y);
	if (fy == fx)
		return;
	if (size[fx] >= size[fy])
	{
		size[fx] += size[fy];
		parent[fy] = fx;
	}
	else
	{
		size[fy] += size[fx];
		parent[fx] = fy;
	}
}
int main()
{
	//freopen("input.txt", "r", stdin);
	scanf("%d%d", &n, &m);
	init_parent();
	for (int i = 0; i < n; ++i)
		for (int j = 0; j < m; ++j)
		{
			scanf("%d", &grid[i*m + j].num);
			grid[i*m + j].idx = i*m + j;
		}
	set<Node> tmp;
	set<Node>::iterator itor;
	for (int i = 0; i < n; ++i)
	{
		tmp.clear();
		for (int j = 0; j < m; ++j)
		{
			itor = tmp.find(grid[i*m + j]);
			if (itor == tmp.end() || itor->num != grid[i*m + j].num)
				tmp.insert(grid[i*m + j]);
			else
				unionparent(itor->idx, grid[i*m + j].idx);
		}
	}
	for (int i = 0; i < m; ++i)
	{
		tmp.clear();
		for (int j = 0; j < n; ++j)
		{
			itor = tmp.find(grid[j*m + i]);
			if (itor == tmp.end() || itor->num != grid[j* m + i].num)
				tmp.insert(grid[j*m + i]);
			else
				unionparent(itor->idx, grid[j*m + i].idx);
		}
	}
	/*for (int i = 0; i < n*m; ++i)
		printf("%d ", findparent(i));
	printf("\n");*/
	sort(grid, grid + n*m);
	/*for (int i = 0; i < n; ++i)
	{
		for (int j = 0; j < m; ++j)
			printf("%d %d\n", grid[i*m + j].num, grid[i*m + j].idx);
	}
	printf("\n");*/
	for (int i = 0; i < n*m; ++i)
		row[i].idx = -1, column[i].idx = -1;
	for (int i = 0; i < n*m; ++i)
	{
		int idx = grid[i].idx;
		int pa = findparent(idx);
		if (row[idx/m].idx!=pa)
			aim[pa] = max(aim[pa], row[idx / m].num + 1);
		if (column[idx%m].idx != pa)
			aim[pa] = max(aim[pa], column[idx%m].num + 1);
		//row[idx / m] = max(row[idx / m], aim[pa]);
		row[idx / m].make(aim[pa], pa);
		column[idx%m].make(aim[pa], pa);
		//column[idx%m] = max(column[idx%m], aim[pa]);
		//printf("%d %d %d %d\n", pa, aim[pa], row[idx / m], column[idx%m]);
	}
	//printf("ans:\n");
	for (int i = 0; i < n; ++i)
	{
		//printf("%d", aim[findparent(i*n)]);
		for (int j = 0; j < m; ++j)
			printf("%d ", aim[findparent(i*m + j)]);
		printf("\n");
	}
	//system("pause");
	//while (1);
	return 0;
}