HDU2874并查集+（LCA-RMQ）

 

#include <iostream>
#include <cmath>
using namespace std;

#define MAX 10010

int n,m,q;
int tol;//边的个数
int cnt;//点的个数

/*****************并查集，用于把树木合成树**********************/
int root = 0;//添加的虚结点
int father[MAX];
void Merge(int a, int b);
int Find(int a);
/***************************************************************/

/*********************LCA-RMQ-ST*******************************/
struct Edge
{
	int v;
	int len;		//若仅求结点与公共祖先的单位距离，len=1
	Edge* link;
};
struct Node
{
	int rlen;		//到根结点的距离
	Edge* link;
};
Edge buffer[MAX*2];
void Add_Edge(int a, int b, int c);//建树
int index[MAX*2];//第i个访问的结点的编号
int deep[MAX*2];//第i个访问的结点的深度
int first[MAX];//第i个结点是第几个访问的
bool vis[MAX] = {0};//第i个结点是否被访问过
Node node[MAX];
void DFS(int root, int deepth, int rlen);               
int dp[MAX*2][16];   //存放是deep的区间最小值的下标
void RMQ_PRE(int *deep, int n);//求任意两点间的最小值的下标
int RMQ(int l, int r);//已经两个结点的first,求最近公共祖先的first
int LCA(int a, int b);//已经两个结点，求最近公共祖先
/***************************************************************/

void init();
int main()
{
	while(scanf("%d%d%d", &n, &m, &q) != EOF)
	{
		init();

		int a,b,c,i,tm =  m;
		while(tm--)
		{
			scanf("%d%d%d", &a, &b, &c);
			Add_Edge(a,b,c);
			Add_Edge(b,a,c);
			Merge(a,b);
		}

		for(i = 1; i <= n; i++)
			Find(i);
		bool Hash[MAX] = {0};
		for(i = 1; i <= n; i++)
			Hash[father[i]] = 1;
		for(i = 1; i <=  n; i++)
		{
			if(Hash[i])
			{
				Add_Edge(root, i, 0);
				Add_Edge(i, root, 0);
			}
		}
		DFS(root, 0, 0);
		RMQ_PRE(deep, 2*(n+1)-1);

		while(q--)
		{
			scanf("%d%d", &a, &b);
			if(father[a] != father[b])
				printf("Not connected\n");
			else
			{
				c = LCA(a, b);
				printf("%d\n",node[a].rlen + node[b].rlen - 2*node[c].rlen);
			}
		}
	}
	return 0;
}

void init()
{
	int i;
	memset(node, 0, sizeof(node));
	for(i = 0; i <= n; i++)
		father[i] = i;
	tol = 0;
	cnt = 0;
	memset(vis, 0, sizeof(vis));
	memset(first, 0, sizeof(first));
	memset(dp, 0, sizeof(dp));
}

void Add_Edge(int a, int b, int c)
{
	Edge * temp = &buffer[tol++];
	temp->v = b;
	temp->len = c;
	temp->link = node[a].link;
	node[a].link = temp;
}

void Merge(int a, int b)
{
	int fa = Find(a);
	int fb = Find(b);
	if(fa < fb)
		father[fb] = fa;
	else if(fa > fb)
		father[fa] = fb;
}

int Find(int a)
{
	int x = a,ret;
	while(x != father[x])
		x = father[x];
	ret = x;
	while(a != ret)
	{
		x = a;
		a = father[a];
		father[x] = ret;
	}
	return ret;
}

void DFS(int root, int deepth, int rlen)
{
	vis[root] = 1;
	node[root].rlen = rlen;

	cnt++;
	index[cnt] = root;
	deep[cnt] = deepth;

	if(first[root] == 0)
		first[root] = cnt;

	Edge *temp = node[root].link;
	while(temp)
	{
		if(vis[temp->v] == 0)
		{
			DFS(temp->v, deepth+1, rlen+temp->len);
			cnt++;
			index[cnt] = root;
			deep[cnt] = deepth;
		}
		temp = temp->link;
	}
}

int LCA(int a, int b)
{
	int fa = first[a];
	int fb = first[b];
	if(fa <= fb)
		return index[RMQ(fa,fb)];
	else
		return index[RMQ(fb,fa)];
}
void RMQ_PRE(int *deep, int n)
{
	int i,j;
	for(i = 1; i <= n; i++)
		dp[i][0] = i;
	for(j = 1; 1<<j <= n; j++)
	{
		int k = 1<<(j-1);
		for(i = 1; i+k < n; i++)
		{
			if(deep[dp[i][j-1]] <= deep[dp[i+k][j-1]])
				dp[i][j] = dp[i][j-1];
			else
				dp[i][j] = dp[i+k][j-1];
		}
	}
}

int RMQ(int a, int b)
{
	int dis = abs(b-a)+1;
	int k = log(double(dis)) / log(2.0);
	if(deep[dp[a][k]] <= deep[dp[b-(1<<k)+1][k]])
		return dp[a][k];
	else
		return dp[b-(1<<k)+1][k];
}