UVa 11354 Bond 最小生成树+LCA倍增

题目大意： n 个点 m 条边的图 q 次询问，每条边都有一个危险系数，每次询问要求一条从 s 到 t 的路径使所有边的最大危险系数最小

思路：

先求出最小生成树，这样能保证图中所有路径的值最小。

接着dfs建有根树，记录 fa[i] 和 val[i] 分别表示节点 i 的父亲节点编号和 i 与父亲的边的权值，同时处理出深度deep[i]

利用倍增思想预处理出LCA和两点之间路径的最大权值记为 STfa[i][j] , STcost[i][j]

接着就是每次 logn 的询问了

细节看代码：

/*************************************************************************
	 > Author: wzw-cnyali
	 > Created Time: 2017/9/11 12:41:53
 ************************************************************************/

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>

#prag\
ma GCC optimize("O3")

using namespace std;

#define REP(i, a, b) for(register int i = (a), i##_end_ = (b); i <= i##_end_; ++ i)
#define DREP(i, a, b) for(register int i = (a), i##_end_ = (b); i >= i##_end_; -- i)
#define EREP(i, a) for(register int i = (be[a]); i != -1; i = nxt[i])
#define mem(a, b) memset((a), b, sizeof(a))

template<typename T> inline bool chkmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; }
template<typename T> inline bool chkmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }

template <class T>
T read(T sum = 0, T fg = 0)
{
	char c = getchar();
	while(c < '0' || c > '9') { fg |= c == '-'; c = getchar(); }
	while(c >= '0' && c <= '9') { sum = sum * 10 + c - '0'; c = getchar(); }
	return fg ? -sum : sum;
}

const int Size = 100010;

struct Edge
{
	int x, y, w;
	void input()
	{
		x = read<int>();
		y = read<int>();
		w = read<int>();
	}
	friend bool operator < (Edge a, Edge b)
	{
		return a.w < b.w;
	}
}edge[Size];

int to[Size], nxt[Size], be[Size], w[Size], e;

void add(int x, int y, int z) { to[e] = y; nxt[e] = be[x]; be[x] = e; w[e] = z; e++; }

void add_edge(int x, int y, int z) { add(x, y, z); add(y, x, z); }

void init() { mem(be, -1); e = 0; }

int n, m;

int fa[Size];

int father(int x)
{
	return fa[x] = x == fa[x] ? x : father(fa[x]);
}

bool merge(int x, int y)
{
	int fx = father(x), fy = father(y);
	if(fx != fy) { fa[fx] = fy; return 1; }
	else return 0;
}

void Kruskal()
{
	init();
	REP(i, 1, n) fa[i] = i;
	sort(edge + 1, edge + m + 1);
	int count = 0;
	REP(i, 1, m)
	{
		int x = edge[i].x, y = edge[i].y, w = edge[i].w;
		if(merge(x, y))
		{
			add_edge(x, y, w);
			if(++count == n - 1) break;
		}
	}
}

int deep[Size], Fa[Size], val[Size];

void dfs_init(int x, int f, int depth)
{
	Fa[x] = f; deep[x] = depth;
	EREP(i, x)
	{
		int y = to[i];
		if(y != f)
		{
			val[y] = w[i];
			dfs_init(y, x, depth + 1);
		}
	}
}

int STfa[Size][20];
int STcost[Size][20];

void ST_init()
{
	mem(STfa, -1);
	REP(i, 1, n)
	{
		STcost[i][0] = val[i];
		STfa[i][0] = Fa[i];
	}
	for(int j = 1; (1 << j) <= n; ++j)
	{
		REP(i, 1, n)
		{
			int a = STfa[i][j - 1];
			if(a != -1)
			{
				STfa[i][j] = STfa[a][j - 1];
				STcost[i][j] = max(STcost[i][j - 1], STcost[a][j - 1]);
			}
		}
	}
}

int query(int L, int R)
{
	if(deep[L] < deep[R]) swap(L, R);
	int lg = log2(deep[L]);
	int ans = -1;
	DREP(i, lg, 0)
	{
		if(deep[L] - (1 << i) >= deep[R])
		{
			chkmax(ans, STcost[L][i]);
			L = STfa[L][i];
		}
	}
	if(L == R) return ans;
	DREP(i, lg, 0)
	{
		if(STfa[L][i] != -1 && STfa[L][i] != STfa[R][i])
		{
			chkmax(ans, STcost[L][i]);
			chkmax(ans, STcost[R][i]);
			L = STfa[L][i]; R = STfa[R][i];
		}
	}
	chkmax(ans, val[L]); chkmax(ans, val[R]);
	return ans;
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("input.in", "r", stdin);
	freopen("output.out", "w", stdout);
#endif
	int Case;
	while(scanf("%d%d", &n, &m) != EOF)
	{
		if(Case++) puts("");
		REP(i, 1, m) edge[i].input();
		Kruskal();
		dfs_init(1, -1, 0);
		ST_init();
		int q = read<int>();
		while(q--)
		{
			int x = read<int>(), y = read<int>();
			int ans = query(x, y);
			printf("%d\n", ans);
		}
	}
	return 0;
}