洛谷T1967 货车运输 Kruskal最大生成树&&倍增LCA

这题的题意是：对于每组x、y,求x到y路径上最小边权的最大值。

于是可以使用最大生成树，因为最大生成树满足性质：生成树中最小边权最大，且任意两点间路径上最小边权最大。

有了树之后，要求路径，那就要考虑LCA。

首先，这题可以树剖，但是我太懒了，于是写了倍增233

具体搞法：

Kruskal跑出最大生成树，然后在树上倍增LCA，处理出2个数组：fa[][]和minv[][]；fa[][]表示第2^k个父亲是谁，minv[][]表示当前节点到其第2^k个父亲的路径上的最小边权。对于每次查询，在求LCA的同时，沿路将各段的minv取并即可，每次时间与LCA查询相同，为logn。

现在还有一个问题：图不一定是连通的。。。不能无脑LCA。。。

解决这个问题的方法是：在Kruskal结束后，对并查集中的每个集合各进行一次LCA预处理。对于每次查询，先判断两节点是否属于同一集合，若属于同一集合则进行LCA查询，否则直接输出-1。

代码如下：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cstdlib>

#include<string>
#include<stack>
#include<queue>
#include<vector>
#include<algorithm>
#include<map>
#include<set>

#define inf 2147483647
#define ri register int
#define ll long long

using namespace std;

inline void read(int &x){
    x=0;
    char t=getchar();
    bool f=0;
    
    while(t<'0' || t>'9'){
        if(t=='-')f=1;
        t=getchar();
    }
    
    while(t>='0' && t<='9'){
        x=(x<<3)+(x<<1)+t-'0';
        t=getchar();
    }
    
    if(f)x=-x;
}

inline void addedge(int,int,int);
int u[100010];
int v[100010];
int w[100010];
int first[10005];
int next[100010];
int pe=0;  //邻接表(无向)

inline bool cmp(const int a,const int b);
int ha_e[50005];  //边排序辅助数组 

inline void Kruskal();
int find(int);
int bcj[10005];  //并查集 
bool use[50005];  //记录边是否使用 

void dfs(int,int);  //LCA预处理,直接父亲及最小边权在上层处理 
bool vis[10005];  //防止重复访问 
int dep[10005];  //节点深度 
int fa[10005][15];  //LCA表 
int minv[10005][15];  //节点到其第2^k个父亲路径间的最小边权 

inline int query(int,int);  //查询路径最小边权 

int n,m,q;
int rest;
int x,y,z;

int main(){
    read(n);read(m);
    rest=n;
    
    for(ri i=1;i<=m;i++){
        read(x);read(y);read(z);
        
        addedge(x,y,z);
        addedge(y,x,z);
        
        ha_e[i]=i<<1;
    }  //建初始图 
    
    sort(ha_e+1,ha_e+1+m,cmp);  //边权从大到小排序 
    Kruskal();  //生成最大生成树，记录需要使用的边 
    
    memset(vis,0,sizeof(vis));
    
    for(ri i=1;i<=n;i++)  //生成2个倍增表 
        if(!vis[find(i)]){
            fa[i][0]=0;  //根节点无父亲 
            minv[i][0]=inf;
            dfs(i,1);  //以i号节点为根进行遍历 
        }
    
    read(q);
    
    for(ri i=1;i<=q;i++){
        read(x);read(y);
        
        if(find(x)!=find(y)){
            printf("-1
");
            continue;
        }
        
        if(dep[x]>dep[y])swap(x,y);  //使y更深 
        
        printf("%d
",query(x,y));
    }
    
    return 0;
}

inline void addedge(int x,int y,int z){
    pe++;
    u[pe]=x;
    v[pe]=y;
    w[pe]=z;
    next[pe]=first[x];
    first[x]=pe;
}

inline bool cmp(const int a,const int b){
    return w[a]>w[b];
}

int find(int x){
    if(bcj[x]==x)return x;
    else return bcj[x]=find(bcj[x]);
}

inline void Kruskal(){
    int x,y,fx,fy;
    
    for(ri i=1;i<=n;i++)bcj[i]=i;
    memset(use,0,sizeof(use));
    
    for(ri i=1;i<=m && rest>1;i++){
        x=u[ha_e[i]];
        y=v[ha_e[i]];
        fx=find(x);
        fy=find(y);
        
        if(fx!=fy){
            bcj[fx]=fy;
            rest--;
            use[ha_e[i]>>1]=1;
        }
    }
}

void dfs(int s,int h){
    int e,t;
    
    dep[s]=h;
    vis[s]=1;
    
    for(ri i=1;(1<<i)<h;i++){  //i=0已在上层处理；若1<<i==h则恰有一个节点越界 
        fa[s][i]=fa[fa[s][i-1]][i-1];
        minv[s][i]=min(minv[s][i-1],minv[fa[s][i-1]][i-1]);
    }
    
    e=first[s];
    t=v[e];
    
    while(e){
        if(!vis[t] && use[(e+1)>>1]){
            fa[t][0]=s;
            minv[t][0]=w[e];
            dfs(t,h+1);
        }
        
        e=next[e];
        t=v[e];
    }
}

inline int query(int x,int y){
    int dt=dep[y]-dep[x];
    int ans=inf;
    
    for(ri i=0;(1<<i)<=dt;i++)
        if((1<<i)&dt){
            ans=min(ans,minv[y][i]);
            y=fa[y][i];
        }
    
    if(x==y)return ans;
    
    for(ri i=13;i>=0;i--)
        if(fa[x][i]!=fa[y][i]){
            ans=min(ans,minv[x][i]);
            ans=min(ans,minv[y][i]);
            
            x=fa[x][i];
            y=fa[y][i];
        }
    
    ans=min(ans,minv[x][0]);
    ans=min(ans,minv[y][0]);
    
    return ans;
}