过路费（最小生成树+lca）

Posted 2022-09-09 背着代码的蜗牛

过路费

题目描述：
在某个遥远的国家里，有 n个城市。编号为 1,2,3,…,n。这个国家的政府修建了m 条双向道路，每条道路连接着两个城市。政府规定从城市 S 到城市T需要收取的过路费为所经过城市之间道路长度的最大值。如：A到B长度为 2，B到C 长度为3，那么开车从 A经过 B到C 需要上交的过路费为 3。
佳佳是个做生意的人，需要经常开车从任意一个城市到另外一个城市，因此他需要频繁地上交过路费，由于忙于做生意，所以他无时间来寻找交过路费最低的行驶路线。然而， 当他交的过路费越多他的心情就变得越糟糕。 作为秘书的你，需要每次根据老板的起止城市，提供给他从开始城市到达目的城市，最少需要上交多少过路费。
输入描述：
第一行是两个整数 n 和m，分别表示城市的个数以及道路的条数。
接下来 m 行，每行包含三个整数 a，b，w（1≤a，b≤n，0≤w≤10^9），表示a与b之间有一条长度为 w的道路。
接着有一行为一个整数 q，表示佳佳发出的询问个数。
再接下来 q行，每一行包含两个整数 S，T（1≤S,T≤n，S≠T）, 表示开始城市S 和目的城市T。
输出描述：
输出共q行，每行一个整数，分别表示每个询问需要上交的最少过路费用。输入数据保证所有的城市都是连通的。
样例输入：
4 5
1 2 10
1 3 20
1 4 100
2 4 30
3 4 10
2
1 4
4 1
样例输出：
20
20
数据范围及提示：
对于 30%的数据，满足 1≤ n≤1000，1≤m≤10000，1≤q≤100；
对于 50%的数据，满足 1≤ n≤10000，1≤m≤10000，1≤q≤10000；
对于 100%的数据，满足 1≤ n≤10000，1≤m≤100000，1≤q≤10000；
思路：
在最小中求最大，
先跑一边最小生成树，找出最小。
在树上跑lca找最大。
这道题和“火车运输”为同一类题

#include<iostream>
#include<algorithm>
#include<cstdio>
using namespace std;
const int maxn=100010;
int n,m,tot,head[maxn];
int father[maxn],deep[maxn],f[maxn][20],dis[maxn][20];
struct node

    int to;
    int w;
    int next;
e[maxn*2];
struct edge

    int u;
    int v;
    int w;
    bool operator < (edge tmp)const
    
        return tmp.w>w;
    
a[maxn];
void add_edge(int u,int v,int w)

    e[++tot].to=v;
    e[tot].w=w;
    e[tot].next=head[u];
    head[u]=tot;

int lca(int a,int b)

    int ans=0;
    if(deep[a]<deep[b])
    swap(a,b);
    if(deep[a]!=deep[b])
    
        int d=deep[a]-deep[b];
        for(int i=0;d;i++)
        
            if(d&1)
            
                ans=max(ans,dis[a][i]);
                a=f[a][i];
            
            d>>=1;
        
    
    if(a==b)
    return ans;
    for(int i=19;i>=0;i--)
    if(f[a][i]!=f[b][i])
    
        ans=max(ans,dis[a][i]);
        ans=max(ans,dis[b][i]);
        a=f[a][i];b=f[b][i];
    
    ans=max(ans,max(dis[a][0],dis[b][0]));
    return ans;

void init()

    f[1][0]=1;
    for(int j=1;j<=19;j++)
      for(int i=1;i<=n;i++)
      
        f[i][j]=f[f[i][j-1]][j-1];
        dis[i][j]=max(dis[i][j-1],dis[f[i][j-1]][j-1]);
      

void build(int u)

    for(int i=head[u];i;i=e[i].next)
    if(!f[e[i].to][0])
    
        f[e[i].to][0]=u;
        dis[e[i].to][0]=e[i].w;
        deep[e[i].to]=deep[u]+1;
        build(e[i].to);
    

int find(int x)

    if(x!=father[x])
    father[x]=find(father[x]);
    return father[x];

void kruskal()

    for(int i=1;i<=n;i++)
    father[i]=i;
    sort(a+1,a+m+1);
    int tot=0;
    for(int i=1;i<=m;i++)
    
        int f1=find(a[i].u);
        int f2=find(a[i].v);
        if(f1!=f2)
        
            father[f1]=f2;
            add_edge(a[i].u,a[i].v,a[i].w);
            add_edge(a[i].v,a[i].u,a[i].w);
            tot++;
        
        if(tot==m-1) break;
    

int main()

    int x,y,z;
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    cin>>a[i].u>>a[i].v>>a[i].w;
    kruskal();
    build(1);
    init();
    cin>>m;
    for(int i=1;i<=m;i++)
    
        cin>>x>>y;
        printf("%d\\n",lca(x,y));
    
    return 0;