洛谷P1967 货车运输（倍增+LCA+生成树）

题意：有n座城市，m条道路，每条路有个限流w，有q次询问，询问x,y城市之间的一次性允许通过的最大流量是多少。
题意不难理解，看起来也不难，可以用倍增+LCA解决，但是此题有个难点：x,y城市之间可能有多条道路，非但如此，题意给的图可能会有环。我们知道，要用LCA算法前提是图中不能有环，如果只是有多条路而无环，我们还可对m条路排一次序，剔除掉那些多余的路径，这样就可以用LCA，但如果有环的话就行不通了。因此，我们必须想方设法去剔除图中所形成的环。
怎么剔除掉这些环？emmmmm…本人是看算法标签才知道怎么解决这个问题的…算法标签中有个生成树，于是当时就想到最小生成树Kruskal算法。Kruskal是基于贪心的思想，每次选取权值最小的边，判断两点是否已经连通，不连通就建边。那么我们稍微改动一下就好，把原本是每此选取权值最小的边的贪心方案，改成每此选取权值最大的边。可以证明这种贪心方案时正确的（文章最后会证明）。因此，我们采用Kruskal算法来将图化成相应的生成树，剔除掉图中多余的环。
代码如下：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<string>
#include<cmath>
using namespace std;
const int maxn=1e5+5;
const int inf=0x3f3f3f3f;
int head[maxn],cnt;	//这一行用于建邻接矩阵，head[i]是指起点为i的边的第一个下标
int depth[maxn];
bool vis[maxn];
int f[maxn];
struct Edge	//原始边
{
	int u,v,w;
}E[5*maxn];
struct edge	//用于建邻接矩阵
{
	int v,w,next;
}e[maxn<<1];
struct node	
{
	int fa,mi;	//这里用倍增算法解决LCA问题，要引入一个结构体，记录fa[i][j]往上跳2^j步的达到的结点，以及该路径中的最小权值
	node()
	{
		fa=0;
		mi=inf;
	}
}fa[maxn][20];

bool cmp(Edge x,Edge y)
{
	return x.w>y.w;
}

int find(int x)
{
	int son=x,temp;
	while(x!=f[x])
		x=f[x];
	while(son!=x)
	{
		temp=f[son];
		f[son]=x;
		son=temp;
	}
	return x;
}

void addedge(int u,int v,int w)
{
	e[cnt].v=v; e[cnt].w=w;	e[cnt].next=head[u]; head[u]=cnt++;
	e[cnt].v=u; e[cnt].w=w;	e[cnt].next=head[v]; head[v]=cnt++;
}

void Kruskal(int n,int m)
{
	for(int i=1;i<=n;++i)	f[i]=i;
	cnt=2;
	for(int i=1;i<=m;++i)
	{
		int a=find(E[i].u), b=find(E[i].v);
		if(a!=b)
		{
			addedge(E[i].u,E[i].v,E[i].w);
			f[a]=b;
		}
	}
}

void DFS(int u,int pre,int d)
{
	fa[u][0].fa=pre;
	depth[u]=d;	vis[u]=1;
	for(int i=head[u]; i ;i=e[i].next)
	{
		if(!vis[e[i].v])
			DFS(e[i].v,u,d+1);
		else if(e[i].v==pre) 
			fa[u][0].mi=e[i].w;
	}
}

void init(int n)
{
	for(int j=1;(1<<j)<n;++j)
		for(int i=1;i<=n;++i)
		{
			if(fa[i][j-1].fa==0)	fa[i][j]=fa[i][j-1];
			else 
			{
				fa[i][j].fa=fa[fa[i][j-1].fa][j-1].fa;
				fa[i][j].mi=min(fa[i][j-1].mi,fa[fa[i][j-1].fa][j-1].mi);
			}
		}
}

int LCA(int u,int v,int n)
{
	if(depth[v]>depth[u])	swap(u,v);
	int temp=depth[u]-depth[v];
	int mi_=inf;
	for(int i=0;(1<<i)<=temp;++i)
		if((1<<i)&temp)
		{
			mi_=min(mi_,fa[u][i].mi);
			u=fa[u][i].fa;
		}
	if(u==v)	return mi_;
	int k=0;
	while((1<<k+1)<=n)	++k;
	for(int i=k;i>=0;--i)
	{
		if(fa[u][i].fa!=fa[v][i].fa)
		{
			mi_=min(mi_,fa[u][i].mi);
			mi_=min(mi_,fa[v][i].mi);
			u=fa[u][i].fa;
			v=fa[v][i].fa;
		}
	}
	if(fa[u][0].fa==0)	//两个结点不存在路径
		return -1;
	mi_=min(mi_,fa[u][0].mi);
	mi_=min(mi_,fa[v][0].mi);
	return mi_;
}

int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i=0;i<=n;++i)	vis[i]=0;
	for(int i=1;i<=m;++i)
	{
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		if(u>v)	swap(u,v);
		E[i].u=u; E[i].v=v; E[i].w=w;
	}
	sort(E+1,E+1+m,cmp);
	Kruskal(n,m);
	for(int i=1;i<=n;++i)
		if(!vis[i])
			DFS(i,0,1);
	init(n);
	int q;
	scanf("%d",&q);
	while(q--)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		printf("%d\n",LCA(u,v,n));
	}
	return 0;
}

贪心方案的证明：
反证法：假设我们已经用Kruskal对图处理一遍了，现在u->v处理出一条路径e，假设路径e并不是运货量最多的，那么此时图中还应存在着另一条路径e’，它的最大运货量量比e还大。那么此时mi(e)<mi(e’)（mi(e)表示路径e中最小的边权），但是我们用Kruskal算法时是优先挑选出边权大的边的，如果这条e’路径存在，那么它将与我们的处理方案相矛盾，因此e’不可能存在，e为最大流量的路径。