BZOJ3732 Network

Description

给你N个点的无向图 (1 <= N <= 15,000)，记为：1…N。
图中有M条边 (1 <= M <= 30,000) ，第j条边的长度为： d_j ( 1 < = d_j < = 1,000,000,000).

现在有 K个询问 (1 < = K < = 15,000)。
每个询问的格式是：A B，表示询问从A点走到B点的所有路径中，最长的边最小值是多少？

Input

第一行： N, M, K。
第2..M+1行: 三个正整数：X, Y, and D (1 <= X <=N; 1 <= Y <= N). 表示X与Y之间有一条长度为D的边。
第M+2..M+K+1行: 每行两个整数A B,表示询问从A点走到B点的所有路径中，最长的边最小值是多少？

Output

对每个询问，输出最长的边最小值是多少。

Sample Input

6 6 8
1 2 5
2 3 4
3 4 3
1 4 8
2 5 7
4 6 2
1 2
1 3
1 4
2 3
2 4
5 1
6 2
6 1

Sample Output

5
5
5
4
4
7
4
5

HINT

1 <= N <= 15,000

1 <= M <= 30,000

1 <= d_j <= 1,000,000,000

1 <= K <= 15,000

正解：倍增+最小生成树

解题报告：

　　今天考了，那就再发一遍吧。

　　又重新写了一遍，刚开始觉得是码农，结果20分钟不到就打完了...

　　显然最小生成树可以满足性质：任意两点之间最大边权最小，然后得到一棵最小生成树树之后就可以在上面跑倍增了。

 //It is made by jump~
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <cstdio>
 #include <cmath>
 #include <algorithm>
 #include <ctime>
 #include <vector>
 #include <queue>
 #include <map>
 #include <set>
 using namespace std;
 typedef long long LL;
 const int MAXN = ;
 const int MAXM = ;
 int n,m,ans,ecnt,father[MAXN];
 int first[MAXN],to[MAXM],next[MAXM],w[MAXM];
 int deep[MAXN];
 int f[MAXN][],g[MAXN][];
 struct edge{
     int x,y,z;
 }e[MAXM];

 inline int getint()
 {
        int w=,q=; char c=getchar();
        while((c<'' || c>'') && c!='-') c=getchar(); if(c=='-') q=,c=getchar();
        while (c>='' && c<='') w=w*+c-'', c=getchar(); return q ? -w : w;
 }
 inline bool cmp(edge q,edge qq){ return q.z<qq.z; }
 inline int find(int x){ if(father[x]!=x) father[x]=find(father[x]); return father[x]; }
 inline void dfs(int x,int fa){
     for(int i=first[x];i;i=next[i]) {
     int v=to[i]; if(v==fa) continue;
     f[v][]=x; g[v][]=w[i]; deep[v]=deep[x]+; dfs(v,x);
     }
 }

 inline void lca(int x,int y){
     if(deep[x]<deep[y]) swap(x,y);
     int t=; while((<<t)<=deep[x]) t++; t--;
     for(int i=t;i>=;i--) if(deep[x]-(<<i)>=deep[y]) ans=max(ans,g[x][i]),x=f[x][i];
     if(x==y) return ;
     for(int i=t;i>=;i--) {
     if(f[x][i]!=f[y][i]) {
         ans=max(g[x][i],ans); ans=max(ans,g[y][i]);
         x=f[x][i]; y=f[y][i];
     }
     }
     ans=max(ans,g[x][]); ans=max(ans,g[y][]);
     return ;
 }

 inline void work(){
     n=getint(); m=getint(); int p=getint();
     for(int i=;i<=m;i++) e[i].x=getint(),e[i].y=getint(),e[i].z=getint();
     sort(e+,e+m+,cmp); for(int i=;i<=n;i++) father[i]=i;
     int r1,r2; int x,y;
     for(int i=;i<=m;i++) {
     r1=find(e[i].x); r2=find(e[i].y);
     if(r1!=r2) {
         father[r1]=r2; x=e[i].x; y=e[i].y;
         next[++ecnt]=first[x]; first[x]=ecnt; to[ecnt]=y; w[ecnt]=e[i].z;
         next[++ecnt]=first[y]; first[y]=ecnt; to[ecnt]=x; w[ecnt]=e[i].z;
     }
     }
     for(int i=;i<=n;i++) if(father[i]==i) { deep[i]=; dfs(i,); }
     for(int j=;j<=;j++) for(int i=;i<=n;i++) f[i][j]=f[f[i][j-]][j-],g[i][j]=max(g[i][j-],g[f[i][j-]][j-]);
     while(p--) {
     x=getint(); y=getint();
     ans=; lca(x,y);
     printf("%d\n",ans);
     }
 }

 int main()
 {
   work();
   return ;
 }