[Luogu P1967] [NOIP 2013] 货车运输

洛谷传送门

题目描述

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

输入输出格式

输入格式：

第一行有两个用一个空格隔开的整数 n,m n , m ，表示 A A 国有 n n 座城市和 m m 条道路。

接下来 m m 行每行 3 3 个整数 x,y,z x , y , z ，每两个整数之间用一个空格隔开，表示从 x x 号城市到 y y 号城市有一条限重为 z z 的道路。注意： x 不等于 y，两座城市之间可能有多条道路 。

接下来一行有一个整数 q q ，表示有 q q 辆货车需要运货。

接下来 q q 行，每行两个整数 x x 、 y y ，之间用一个空格隔开，表示一辆货车需要从 x x 城市运输货物到 y y 城市，注意：x 不等于 y 。

输出格式：

共有 q q 行，每行一个整数，表示对于每一辆货车，它的最大载重是多少。如果货车不能到达目的地，输出-1−1。

输入输出样例

输入样例#1：

4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3

输出样例#1：

3
-1
3

说明

对于 30% 30 % 的数据， 0<n<1,000, 0<m<10,000, 0<q<1,000 0 < n < 1 , 000 ,   0 < m < 10 , 000 ,   0 < q < 1 , 000 ；

对于 60% 60 % 的数据， 0<n<1,000, 0<m<50,000, 0<q<1,000 0 < n < 1 , 000 ,   0 < m < 50 , 000 ,   0 < q < 1 , 000 ；

对于 100% 100 % 的数据， 0<n<10,000, 0<m<50,000, 0<q<30,000, 0≤z≤100,000 0 < n < 10 , 000 ,   0 < m < 50 , 000 ,   0 < q < 30 , 000 ,   0 ≤ z ≤ 100 , 000 。

解题分析

这道题可以搞出最大生成树后用树剖、 LCT L C T 、倍增 LCA L C A 解决， 不过还有一种更优雅的方法。

我们在用 Kruskal K r u s k a l 搞最大生成树的时候将边视为一个辅助点， 向两端连边， 将边权化为点权， 这样搞原图上的点全是叶节点， 而整棵树也变成了一个小根堆。这样生成树上两点之间的最小值就在 LCA L C A 处取得。

总复杂度 O(Nlog(N)) O ( N l o g ( N ) ) 。

很坑的是这个图不一定联通， 需要 for f o r 循 DFS D F S 。
代码如下：

#include 
#include 
#include 
#include 
#include 
#include 
#define R register
#define IN inline
#define W while
#define gc getchar()
#define MX 200050
template <class T>
IN void in(T &x)
{
    x = 0; R char c = gc;
    for (; !isdigit(c); c = gc);
    for (;  isdigit(c); c = gc)
    x = (x << 1) + (x << 3) + c - 48;
}
struct INFO {int from, to, val;}e[MX << 1];
struct Edge {int to, nex;} edge[MX << 1];
int cnt, dot, line, cot, bd;
int head[MX], val[MX], bel[MX], siz[MX], fat[MX], son[MX], dep[MX], topf[MX];
bool vis[MX], nroot[MX];
IN bool operator < (const INFO &x, const INFO &y)
{return x.val > y.val;}
IN void add(R int from, R int to)
{edge[++cnt] = {to, head[from]}, head[from] = cnt;}
int find(R int now) {return now == bel[now] ? now : bel[now] = find(bel[now]);}
void build()
{
    int b1, b2;
    for (R int i = 1; i <= bd; ++i) bel[i] = i;
    std::sort(e + 1, e + 1 + line);
    for (R int i = 1; i <= line; ++i)
    {
        b1 = find(e[i].from), b2 = find(e[i].to);
        if(b1 ^ b2)
        {
            ++cot; val[cot + dot] = e[i].val;
            bel[b1] = bel[b2] = cot + dot;
            add(cot + dot, b1), add(cot + dot, b2);
            nroot[b1] = nroot[b2] = true;
            if(cot == dot - 1) break;
        }
    }
}
void DFS(R int now)
{
    vis[now] = siz[now] = 1;
    for (R int i = head[now]; i; i = edge[i].nex)
    {
        if(edge[i].to == fat[now]) continue;
        fat[edge[i].to] = now;
        dep[edge[i].to] = dep[now] + 1;
        DFS(edge[i].to);
        siz[now] += siz[edge[i].to];
        if(siz[edge[i].to] > siz[son[now]])
        son[now] = edge[i].to;
    }
}
void DFS(R int now, R int grand)
{
    topf[now] = grand;
    if(!son[now]) return;
    DFS(son[now], grand);
    for (R int i = head[now]; i; i = edge[i].nex)
    {
        if(edge[i].to == fat[now] || edge[i].to == son[now]) continue;
        DFS(edge[i].to, edge[i].to);
    }
}
IN int query(R int x, R int y)
{
    W (topf[x] ^ topf[y])
    {
        if(dep[topf[x]] < dep[topf[y]]) std::swap(x, y);
        x = fat[topf[x]];
    }
    return dep[x] > dep[y] ? y : x;
}
int main(void)
{
    int a, b, q;
    in(dot), in(line); bd = dot * 2 - 1;
    for (R int i = 1; i <= line; ++i)
    in(e[i].from), in(e[i].to), in(e[i].val);
    build();
    for (R int i = 1; i <= bd; ++i) if(!vis[i] && !nroot[i])
    DFS(i), DFS(i, i);
    in(q);
    W (q--)
    {
        in(a), in(b);
        if(find(a) != find(b)) puts("-1");
        else printf("%d\n", val[query(a, b)]);
    }
}