P1967 货车运输 （kruskal重构树模板题 或 最大生成树+LCA）

题目描述

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

输入格式

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

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

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

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

输出格式

共有 qq 行，每行一个整数，表示对于每一辆货车，它的最大载重是多少。如果货车不能到达目的地，输出-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

说明/提示

0<n<10,000,0<m<50,000,0<q<30,000,0≤z≤100,000。

思路：

一种思路是构建最大生成树+LCA查询路径中最小值
这里就不挂了

记录一下kruskal重构树做法

kruskal重构树模板题
kruskal重构树的基本操作就是求x到y路径上最小距离的最大值(或者最大距离的最小值)

这题可能不是树是森林，开了mark数组记录节点是否访问过
查询之前要先判断一下是否在同一棵树(并查集)

–
构建过程：

!!!这题用的是边权从大到小排序，实际操作也可以从小到大!!!

在kruskal求最小(最大)生成树中，如果一条边连接了在2个不同集合中的点的话，就合并这2个点所在集合。

在建立kruskal重构树的过程中中，如果一条边连接了在2个不同集合中的点的话，就建立一个新的一个节点出来，并用这个新节点作为一个中转点连接这2个集合，新节点的点权即为边权

例如题目案例1：
4 3
1 2 4
2 3 3
3 1 1

先按边权从大到小排序

如图就是一棵kruskal重构树，方点为新建出的节点，圆点是原图中的点，方点的点权即为边权。

原图中每个节点都是这棵树的叶子节点
这棵树向上走是递减的(如果从小到大排序就是递增的)
x与y点的lca代表的就是x到y路径上最小距离的最大值(如果从小到大排序就反一下)

如果要在最小生成树上求一些东西，这些新建除的点可以提供查找方向

例如从叶子向上走，找到某个节点使得这个节点即以下的点都满足点权大于k，这样就可以找到所有可以互相到达且路径上每条边不小于点对。

code:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
const int maxm=1e5+5;
int head[maxm],nt[maxm],to[maxm],cnt;
int sz[maxm],son[maxm],top[maxm],d[maxm],fa[maxm];
int val[maxm];//节点点权
int mark[maxm];
int pre[maxm];
struct Node{
    int a,b,c;
}e[maxm];
bool cmp(Node a,Node b){//边权从大到小排序
    return a.c>b.c;
}
int n,m,q;
void init(){
    memset(head,-1,sizeof head);
    memset(mark,0,sizeof mark);
    for(int i=1;i<maxm;i++){
        pre[i]=i;
    }
    cnt=1;
}
void add(int x,int y){
    cnt++;nt[cnt]=head[x];head[x]=cnt;to[cnt]=y;
}
void dfs1(int x){
    sz[x]=1;
    mark[x]=1;
    d[x]=d[fa[x]]+1;
    for(int i=head[x];i!=-1;i=nt[i]){
        int v=to[i];
        if(v==fa[x])continue;
        fa[v]=x;
        dfs1(v);
        sz[x]+=sz[v];
        if(sz[son[x]]<sz[v]){
            son[x]=v;
        }
    }
}
void dfs2(int x,int tp){//
    top[x]=tp;
    if(son[x]){
        dfs2(son[x],tp);
    }
    for(int i=head[x];i!=-1;i=nt[i]){
        int v=to[i];
        if(v==fa[x]||v==son[x])continue;
        dfs2(v,v);
    }
}
int ffind(int x){
    return pre[x]==x?x:pre[x]=ffind(pre[x]);
}
void kruskal(){
    init();
    sort(e+1,e+1+m,cmp);
    for(int i=1;i<=m;i++){
        int x=ffind(e[i].a);
        int y=ffind(e[i].b);
        if(x!=y){
            val[++n]=e[i].c;
            pre[n]=pre[x]=pre[y]=n;//cnt为根
            add(x,n);
            add(n,x);
            add(y,n);
            add(n,y);
        }
    }
    for(int i=1;i<=n;i++){//原图可能是森林
        if(!mark[i]){
            int x=ffind(i);//并查集的根就是森林中每棵树的根
            fa[x]=0;
            sz[0]=0;
            dfs1(x);//树链剖分
            dfs2(x,x);
        }
    }
}
int lca(int x,int y){//lca
    while(top[x]!=top[y]){
        if(d[top[x]]<d[top[y]])swap(x,y);
        x=fa[top[x]];
    }
    if(d[x]>d[y])swap(x,y);
    return x;
}
signed main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        scanf("%d%d%d",&e[i].a,&e[i].b,&e[i].c);
    }
    kruskal();
    scanf("%d",&q);
    while(q--){
        int x,y;
        scanf("%d%d",&x,&y);
        if(ffind(x)!=ffind(y)){//如果不在同一棵树
            puts("-1");
        }else{
            printf("%d\n",val[lca(x,y)]);
        }
    }
    return 0;
}