Maze Designer （最大生成树 + LCA + 思维）

题目链接

题意：给你一个n*m的网格，格子与格子的边界（除了外边界）有一个边权值，代表造迷宫的代价，现在问造一个迷宫，网格任意两点之间都联通，且造迷宫的代价最小，显然这样的方案是唯一的，有q次查询，每次查询有两个坐标，代表情侣的两个位置，问这两个情侣，最短的路的是多少，输出最短路。

思路：把这m*n个格子看成点，把格子与格子之间的墙看成边（有边代表没墙），那么只需要n*m-1条边就可以把这n*m个点连接，并且这些边不能成环，显然这是一棵树。题目要求造迷宫的代价最小，那么没墙的边的权值应该尽可能的大。那么要求的就是一棵最大生成树。那么情侣之间的距离就可以转化成一棵树上两个点的距离了，两点之间的距离就是lca的经典问题了。这n*m个点用1-n*m个值表示。注意并查集合并的时候的细节就okk啦。

#include<bits/stdc++.h>

using namespace std;

const int maxn = 500*500+5;
vector<int>G[maxn];
struct node{
	int u,v,w;
	bool operator < (const node & t)const
	{
		return w > t.w;
	}
}a[maxn * 2];

int fa[maxn],dep[maxn],f[maxn][20];
int n,m,cnt;

int find(int x) {
	return x == fa[x]?x : fa[x] = find(fa[x]);
}
void init()
{
	for(int i=1;i<=n*m;i++)G[i].clear(),fa[i] = i;
	cnt = 0;
}
void kruskal()
{
	sort(a+1,a+1+cnt);
	int sum = 0;
	for(int i=1;i<=cnt;i++)
	{
		int u = find(a[i].u);
		int v = find(a[i].v);
		if(u != v)
		{
			fa[u] = v;
			G[a[i].u].push_back(a[i].v);
			G[a[i].v].push_back(a[i].u);
			sum++;
		}
		if(sum == n*m-1)break;
	}
}
void dfs(int u,int fa,int d)
{
	dep[u] = d;
	f[u][0] = fa;
	for(int i=1;i<=19;i++)
	f[u][i] = f[f[u][i-1]][i-1];
	for(int i=0;i<G[u].size();i++)
	{
		int v = G[u][i];
		if(v == fa)continue;
		dfs(v,u,d+1);
	}
}
int lca(int u,int v)
{
	if(dep[u] < dep[v])swap(u,v);
	for(int i = 19;i>=0;i--)
	{
		if(dep[f[u][i]] >= dep[v])u = f[u][i];
	}
	assert(dep[u] == dep[v]);
	if(u == v)return u;
	for(int i=19;~i;i--)
	{
		if(f[u][i] != f[v][i])u = f[u][i],v = f[v][i];
	}
	return f[u][0];
}
int main()
{
	scanf("%d%d",&n,&m);
	init();
	for(int i=1;i<=n*m;i++)
	{
		char op[3];
		int x;
		for(int j=0;j<2;j++)
		{
			scanf("%s%d",op,&x);
			if(op[0] == 'X')continue;
			else if(op[0] == 'D')a[++cnt] = node{i,i+m,x};
			else a[++cnt] = node{i,i+1,x};
		}
	}
	kruskal();
	dfs(1,0,0);
	int q;
	cin>>q;
	while(q--)
	{
		int x1,y1,x2,y2;
		scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
		int u = (x1-1)*m + y1;
		int v = (x2-1)*m + y2;
		int ans = dep[u] + dep[v] - 2*dep[lca(u,v)];
		printf("%d\n",ans);
	}
	return 0;
}