[noip2013]货车运输

题目

描述 Description
A 国有 n 座城市，编号从 1 到 n，城市之间有 m 条双向道路。每一条道路对车辆都有重量限制，简称限重。现在有 q 辆货车在运输货物，司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。
输入格式 Input Format
第一行有两个用一个空格隔开的整数 n，m，表示 A 国有 n 座城市和 m 条道路。
接下来 m 行每行 3 个整数 x、y、z，每两个整数之间用一个空格隔开，表示从 x 号城市到 y 号城市有一条限重为 z 的道路。
注意：x 不等于 y，两座城市之间可能有多条道路。
接下来一行有一个整数 q，表示有 q 辆货车需要运货。
接下来 q 行，每行两个整数 x、y，之间用一个空格隔开，表示一辆货车需要从 x 城市运输货物到 y 城市，注意：x 不等于 y。
输出格式 Output Format
输出共有 q 行，每行一个整数，表示对于每一辆货车，它的最大载重是多少。如果货车不能到达目的地，输出-1。
样例输入 Sample Input
4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3
样例输出 Sample Output
3
-1
3
时间限制 Time Limitation
1s
注释 Hint
对于 30%的数据，0 < n < 1,000，0 < m < 10,000，0 < q < 1,000；
对于 60%的数据，0 < n < 1,000，0 < m < 50,000，0 < q < 1,000；
对于 100%的数据，0 < n < 10,000，0 < m < 50,000，0 < q < 30,000，0 ≤ z ≤ 100,000。

题解

----题解----

可以发现有一些权值较小的边是不会被走过的。正如样例中的第三条边，就算有其他的很多条边，这条边无论如何也是不会被走过的。于是我们想到了可以将图中这样的边去掉，按照这个思路我们便想到了构造最大生成树，将其余的边去除。
得到了这样一个树之后，我们便考虑如何求出两个节点之间最小边权的最大值（即为题中的最大载重），因为这两点之间的路径是唯一的，我们只需要找出这条路径便可以得到答案。我们可以通过LCA来做到这一点，我求LCA的方法是先从每一个根节点进行搜索，求出节点深度等信息，然后利用这些信息进行树上倍增。

code

#include <algorithm>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <list>
#include <map>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>

#define fup(i, a, b) for (i = a; i <= b; ++i)
#define fdown(i, a, b) for (i = a; i >= b; --i)
typedef long long ull;
const int maxm = 1e5 + 100;
const int maxn = 5e5 + 100;
const int inf = 0x3f3f3f3f;

namespace millope {
    inline void kswap(int &a, int &b) { a ^= b; b ^= a; a^= b; }
    inline int kmax(int a, int b) { return a > b ? a : b; }
    inline int kmin(int a, int b) { return a > b ? b : a; }
    inline int read() {
        int s = 0, w = 1;
        char ch = getchar();
        while (!isdigit(ch)) { if (ch == '-') w = -1; ch = getchar(); }
        while (isdigit(ch)) { s = (s << 1) + (s << 3) + (ch - '0'); ch = getchar(); }
        return s * w;
    }
}
using namespace millope;
using namespace std;

int n;
int m;
int q;
int tot = 0;
int f[maxm];
int fa[maxm][30];
int w[maxm][30];
int link[maxn << 1];
int deep[maxm];
struct Tree {
    int from, to, dis;
    bool operator <(const Tree &tree) const {
        return dis > tree.dis;
    }
} t[maxn];
struct Edge {
    int next, to, dis;
    Edge() {
    	next = 0, to = 0, dis = 0;
	}
} e[maxn << 1];
bool vis[maxm];

inline int find(int k) {
    return f[k] == k ? k : f[k] = find(f[k]);
}

inline void add(int from ,int to, int dis) {
    e[++tot].to = to;
    e[tot].dis = dis;
    e[tot].next = link[from];
    link[from] = tot;
}

void dfs(int u) {
    vis[u] = true;
    for (int i = link[u]; i; i = e[i].next) {
        int v = e[i].to;
        if (!vis[v]) {
//        	vis[v] = true;
        	deep[v] = deep[u] + 1;
        	fa[v][0] = u;
        	w[v][0] = e[i].dis;
        	dfs(v);
		}
    }
    return ;
}

int lca(int x, int y) {
    if (find(x) != find(y)) return -1;
    int ans = inf;
    if (deep[x] > deep[y]) kswap(x, y);
    for (int i = 20; i >= 0; i--) {
        if (deep[fa[y][i]] >= deep[x]) {
            ans = kmin(w[y][i], ans);
            y = fa[y][i];
        }
    }
    if (x == y) return ans;
    for (int i = 20; i >= 0; i--) {
        if (fa[x][i] != fa[y][i]) {
			ans = kmin(ans, kmin(w[x][i], w[y][i]));
            x = fa[x][i];
            y = fa[y][i];   
        }
    }
    ans = kmin(ans, kmin(w[x][0], w[y][0]));
    return ans;
}

int main() {
//	freopen("1.txt","r",stdin);
    memset(vis, false, sizeof(vis));
    n = read(), m = read();
    for (int i = 1; i <= m; ++i) {
        int x, y, z;
		x = read(), y = read(), z = read();
        t[i].from = x;
        t[i].to = y;
        t[i].dis = z;
    }
    std::sort(t + 1, t + m + 1);
    for (int i = 1; i <= n; ++i) f[i] = i;
    for (int i = 1; i <= m; ++i) {
        int u = find(t[i].from), v = find(t[i].to);
        if (u != v) {
            f[u] = v;
            add(t[i].from, t[i].to, t[i].dis);
            add(t[i].to, t[i].from, t[i].dis);
        }
    }
    for (int i = 1; i <= n; ++i) {
        if (!vis[i]) {
            deep[i] = 1;
            fa[i][0] = i;
            w[i][0] = inf;
			dfs(i);
        }
    }
    for (int i = 1; i <= 20; ++i) {
        for (int j = 1; j <= n; ++j) {
            fa[j][i] = fa[fa[j][i - 1]][i - 1];
            w[j][i] = kmin(w[j][i - 1], w[fa[j][i - 1]][i - 1]);
        }
    }
    q = read();
    for (int i = 1; i <= q; ++i) {
        int x, y;
		x = read(), y = read();
        printf("%d\n", lca(x, y));
    }
    return 0;
}