【题解】NOIP 2013 货车运输（最小生成树+LCA）

题目描述

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

输入输出格式

输入格式：

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

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

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

输出格式：

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

题解

分析

由于每条路无权值，所以我们可以把限重记为权值。
这道题可以先用Kruskal 求最大生成树，然后再在生成树上求两点的最小权值。

可以用Kruskal中用到的并查集来判断两点是否连通。

求两点间的最小权值可以用LCA，用一种朴素算法来实现，先对生成树进行一次DFS并记录下每个点的深度，当要找a,b两点的最小权值时，可以先让深度高的点爬到与深度低的点，然后再一起往上爬，直到两点位同一点时，这时a，b两点的最小权值只能在经过的路上。

大神勿喷，本人蒟蒻。

AC代码附上

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

int parent[10005],ran[10005],father[10005],value[10005],n,m;
bool vis[10005];

struct Edge
{
    int a;
    int b;
    int value;
};

struct G
{
    int num;
    int to;
    int value;
};

Edge edge[50005];
vector<G> graph[10005];

inline int min(int a,int b)
{
    return a < b ? a : b;
}

int find(int index)
{
    if(index == parent[index])
        return index;
    else
        return parent[index] = find(parent[index]);
}

void join(int a,int b)
{
    int fa = find(a),fb = find(b);
    if(fa != fb)
        parent[fa] = fb;
}

bool same(int a,int b)
{
    int fa = find(a),fb = find(b);
    return fa == fb;
}

bool cmp(const Edge &x,const Edge &y)
{
    return x.value > y.value;
}

void Kruskal()
{
    int e=0;
    G g;
    for(int i=1;i<=m;i++)
    {
        if(!same(edge[i].a,edge[i].b))
        {
            join(edge[i].a,edge[i].b);
            g.num = i;
            g.value = edge[i].value;
            g.to = edge[i].b;
            graph[edge[i].a].push_back(g);
            g.to = edge[i].a;
            graph[edge[i].b].push_back(g);
            e++;
        }
        if(e == n-1)
        {
            break;
        }
    }
}

void dfs(int step,int r,int start)
{
    if(step > m)
    {
        return;
    }
    ran[start] = r;
    int len = graph[start].size(),to;
    for(int i = 0;i<len;i++)
    {
        to = graph[start][i].to;
        if(!vis[to])
        {
            father[to] = start;
            value[to]=graph[start][i].value;
            vis[to] = true;
            dfs(++step,r+1,to);
        }
    }
}

int lca(int a,int b)
{
    int minn = min(ran[a],ran[b]);
    int ans = 0x7fffffff;
    if(!same(a,b))
    {
        return -1;
    }
    while(ran[a]>minn)
    {
        ans = min(ans,value[a]);
        a = father[a];
    }
    while(ran[b]>minn)
    {
        ans = min(ans,value[b]);
        b = father[b];
    }
    while(a != b)
    {
        ans = min(ans,value[a]);
        a = father[a];
        ans = min(ans,value[b]);
        b = father[b];
    }
    return ans;
}

int main()
{
    int a,b,q;
    cin >> n >> m ;
    for(int i=1;i<=n;i++)
        parent[i] = i;
    for(int i=1;i<=m;i++)
    {
        cin >> edge[i].a >> edge[i].b >> edge[i].value;
    }
    sort(edge+1,edge+m+1,cmp);
    Kruskal();
    father[1] = 1;
    vis[1]=true;
    dfs(1,1,1);
    cin>>q;
    while(q--)
    {
        cin >> a >> b;
        cout << lca(a,b) <<endl;
    }
    return 0;
}