最小花费路径 MST+LCA_花费矩阵最小花费和第一行到第m行-优快云博客

本文链接：https://blog.youkuaiyun.com/EOD_realize/article/details/38823065

本文介绍了一种解决无向图中两点间路径最小花费问题的方法——LCA算法，并提供了完整的实现代码。该算法通过预处理得到每个节点到其祖先节点的最大边权，进而快速求解任意两点间的最大边权。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

裸的LCA是无敌的!!!!!!!!!!!!!!!!!!!!!

[问题描述]
对于一个无向图G 中的两点S，T 路径的花费定义为：
路径中最大的一条边的边权
现在给定一个N 个点M 条边无向图（保证连通，可能有重边及自环），求图中K 个点对
的最小花费
[输入格式]
第一行两个整数，N，M
接下来N 行，每行3 个整数Xi，Yi，Vi，表示Xi 与Yi 间有一条边权为Vi 的无向边
接下来一个整数K
接下来K 行，每行2 个整数Si，Ti，求Si 到Ti 路径的最小花费
[输出格式]
输出K 行，每行输出对应Si 到Ti 路径的最小花费
[输入样例]
4 10
1 2 10
1 3 3
1 4 5
3 3 2
1 1 8
1 3 2
3 2 3
1 1 4
4 3 2
3 4 1
5
2 3
4 1
1 2
3 4
2 1
[输出样例]
3
2
3

1
3
[样例解释]
无
[数据范围]
对于30%的数据， N <= 300
对于另外20%的数据， Si = 1
对于100%的数据， N <= 10^5， M，K <= 2*10^5

#include <algorithm>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <iostream>
#include <queue>
using namespace std;
#define maxn 210000
int ceng[maxn],p[maxn],next[maxn],val[maxn],b[maxn],len[maxn];
int first[maxn],father[maxn];
struct node
{
    int u,v,val;
}tree[maxn];
int n,m,q;
bool cmp(node aa,node bb)
{
    return aa.val<bb.val;
}
int getfa(int x)
{
    if(x==father[x]) return x;
    return father[x]=getfa(father[x]);
}
int num;
void build(int aa,int bb,int cc)
{
    num++;
    b[num]=bb;
    val[num]=cc;
    next[num]=first[aa];
    first[aa]=num;
}
void dfs(int u)
{
    int v;
    for(int e=first[u];e;e=next[e])
    {
        v=b[e];
        if(!ceng[v])
        {
            father[v]=u;
            ceng[v]=ceng[u]+1;
            len[v]=val[e];
            dfs(v);
        }
    }
}
int main()
{
    freopen("c2.in","r",stdin);
    //freopen("c1.out","w",stdout);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        father[i]=i;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&tree[i].u,&tree[i].v,&tree[i].val);
    }
    sort(tree+1,tree+1+m,cmp);
    for(int i=1;i<=m;i++)
    {
        int r1=getfa(tree[i].u);
        int r2=getfa(tree[i].v);
        if(r1!=r2)
        {
            father[r1]=r2;
            build(tree[i].u,tree[i].v,tree[i].val);
            build(tree[i].v,tree[i].u,tree[i].val);
        }
    }
    ceng[1]=1;
    dfs(1);
    scanf("%d",&q);
    for(int i=1;i<=q;i++)
    {
        int x,y,ans=0,tx,ty;//x有可能等于y 所以ans初始值为0
        scanf("%d%d",&x,&y);
        tx=ceng[x];
        ty=ceng[y];
        while(tx>ty)
        {
            ans=max(ans,len[x]);
            x=father[x];
            tx--;
        }
        while(ty>tx)
        {
            ans=max(ans,len[y]);
            y=father[y];
            ty--;
        }
        while(x!=y)
        {
            ans=max(ans,len[x]);
            x=father[x];
            ans=max(ans,len[y]);
            y=father[y];
        }
        printf("%d\n",ans);
    }
    return 0;
}