NOIP 2013 CODE[VS] 3287 货车运输 倍增LCA + 最大生成树

题目描述 Description

A 国有 n 座城市，编号从 1 到 n，城市之间有 m 条双向道路。每一条道路对车辆都有重量限制，简称限重。现在有 q
辆货车在运输货物，司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。

输入描述 Input Description

第一行有两个用一个空格隔开的整数 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 Description

输出共有 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

数据范围及提示 Data Size & 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。

如果在一条链上而且两者相距较远 如果暴力一步一步向上走的话 效率会十分低下
这时候我么就应该采用倍增来处理向上跳的过程
首先将两个节点默认有一个深度更深，处理深度差，在不会过界的情况下令深度更大的点向上跳2^k步 定义t[i][j]表示节点i的第2^j个祖先的标号。
有t[i][0]就是节点i的父亲节点标号,那么t[i][j]=t[f[i][j-1]][j-1],即i节点的第2^j个祖先的标号等于i节点的第2^(j-1)个祖先的第2^（j-1）个祖先，因为2^j=2^(j-1)+2^(j-1)。
再用一个二维数组 表示两点间最小权值 记录答案
之后初始化并查集 建最大生成树 用dfs处理点之间的关系 求lca
如果两个点没有lca 也就是说不连通 那么就不能到达 输出-1
最后再找一下两点距离lca更小的那个路径 即为答案

上代码

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int SZ = 200010;
const int INF = 2147483647;
struct Edge
{
    int f, t, d;
}es[SZ], tr[SZ];
int first[SZ], nxt[SZ], tot = 0, fa[SZ];
int t[SZ][20], depth[SZ], dis[SZ][20];
bool vis[SZ];
void build(int f, int t, int d)
{
    tr[++tot] = (Edge){f, t, d};
    nxt[tot] = first[f];
    first[f] = tot;
}
bool cmp(Edge a, Edge b)
{
    return a.d > b.d;
}
int find(int x)
{
    return fa[x] == x ? x : fa[x] = find(fa[x]);
}
void dfs(int u)
{
    vis[u] = 1;
    for(int i = 1; i <= 16; i++)
    {
        t[u][i] = t[t[u][i - 1]][i - 1];//处理祖先
        dis[u][i] = min(dis[t[u][i - 1]][i - 1], dis[u][i - 1]);//处理距离
    }
    for(int i = first[u]; i; i = nxt[i])
    {
        int v = tr[i].t;
        if(!vis[v])
        {
            depth[v] = depth[u] + 1;//v是u的子节点  深度+1 
            t[v][0] = u;//v的第2^0个祖先是他的父节点u 
            dis[v][0] = tr[i].d;//两点距离为边权 
            dfs(v);//从子节点继续向下扩展 
        }
    }
}
int lca(int x, int y)
{
    if(depth[x] < depth[y]) //默认x深度更深 
        swap(x, y);
    int tt = depth[x] - depth[y];
    for(int i = 0; i <= 16; i++)
        if(tt & (1 << i)) //x先与y同高 
            x = t[x][i];
    for(int i = 16; i >= 0; i--)
        if(t[x][i] != t[y][i])//一起上升 保证不会跳过
        {
            x = t[x][i];
            y = t[y][i];
        }
    if(x == y) return x;//找到lca 
    return t[x][0];//如果 x != y 则需要在找一层 
}
int ask(int x, int y)
{
    int tt = depth[x] - depth[y];
    int ans = INF;
    for(int i = 0; i <= 16; i++)
        if(tt & (1 << i))
        {
            ans = min(ans, dis[x][i]);//某个节点到lca的最小承重
            x = t[x][i];
        }
    return ans;
}
int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m; i++)
        scanf("%d%d%d", &es[i].f, &es[i].t, &es[i].d);
    for(int i = 1; i <= n; i++)//初始化并查集
        fa[i] = i;
    sort(es + 1, es + 1 + m, cmp);
    for(int i = 1; i <= m; i++)//最大生成树
    {
        int x = find(es[i].f), y = find(es[i].t);
        if(x != y)
        {
            fa[x] = y;
            build(es[i].f, es[i].t, es[i].d);
            build(es[i].t, es[i].f, es[i].d);
        }
    }
    for(int i = 1; i <= n; i++)
        if(fa[i] == i)
            depth[i] = 1, dfs(i);
    int q;
    scanf("%d", &q);
    int u, v;
    for(int i = 1; i <= q; i++)
    {
        scanf("%d%d", &u, &v);
        if(find(u) != find(v)) puts("-1");//如果两个点没有lca 也就是说不连通 那么就不能到达 输出-1 
        else
        {
            int t = lca(u, v);
            int ans = min(ask(u, t), ask(v, t));
            printf("%d\n", ans);
        }
    }
    return 0;
}