[BZOJ 3732]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 < = 20,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

题解

裸的$Kruskal$重构树，当模板码着。

//It is made by Awson on 2017.10.8
#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <vector>
#include <cstdio>
#include <string>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define link LINK
#define set SET
#define find FIND
#define LL long long
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) < (b) ? (a) : (b))
using namespace std;
const int N = 15000;
const int M = 30000;

int n, m, k, lim, u, v;
struct ss {
  int u, v, c;
  bool operator < (const ss &b) const{
    return c < b.c; 
  }
}link[M+5];
struct tt {
  int to, next;
}edge[(N<<2)+5];
int path[(N<<1)+5], top;
int set[(N<<1)+5], pos;
int fa[(N<<1)+5][15], c[(N<<1)+5], dep[(N<<1)+5];

void add(int u, int v) {
  edge[++top].to = v;
  edge[top].next = path[u];
  path[u] = top;
}
int find(int x) {
  return set[x] ? set[x] = find(set[x]) : x;
}
void Kruskal() {
  sort(link+1, link+1+m);
  int cnt = 0; pos = n;
  for (int i = 1; i <= m; i++) {
    int q = find(link[i].u);
    int p = find(link[i].v);
    if (p != q) {
      c[++pos] = link[i].c;
      add(p, pos); add(q, pos);
      add(pos, p); add(pos, q);
      cnt++;
      set[p] = set[q] = pos;
      if (cnt == n-1) return;
    }
  }
}
void dfs(int r, int depth) {
  dep[r] = depth;
  for (int i = path[r]; i; i = edge[i].next)
    if (edge[i].to != fa[r][0]){
      fa[edge[i].to][0] = r;
      dfs(edge[i].to, depth+1);
    }
}
int lca(int u, int v) {
  if (dep[u] < dep [v]) swap(u, v);
  for (int i = lim; i >= 0; i--)
    if (dep[fa[u][i]] >= dep[v]) u = fa[u][i];
  if (u != v) {
    for (int i = lim; i >= 0; i--)
      if (fa[u][i] != fa[v][i]) {
    u = fa[u][i], v = fa[v][i];
      }
    u = fa[u][0], v = fa[v][0];
  }
  return u;
}
void work() {
  scanf("%d%d%d", &n, &m, &k); lim = log(n)/log(2);
  for (int i = 1; i <= m; i++) scanf("%d%d%d", &link[i].u, &link[i].v, &link[i].c);
  Kruskal();
  dfs(pos, 1);
  for (int t = 1; t <= lim; t++)
    for (int i = 1; i <= pos; i++)
      fa[i][t] = fa[fa[i][t-1]][t-1];
  while (k--) {
    scanf("%d%d", &u, &v);
    printf("%d
", c[lca(u, v)]);
  }
}
int main() {
  work();
  return 0;
}