【Luogu】P1967货车运输（最大生成森林+倍增LCA）

　　题目链接

　　倍增LCA是个什么蛇皮原理啊，循环完了还得再往上跳一次才能到最近公共祖先

　　合着我昨天WA两次就是因为这个

　　建最大生成森林，因为图不一定是联通的，所以不一定是一棵树。这个地方用克鲁斯卡尔就好了

　　然后给这个森林跑一遍DFS，顺便倍增

　　然后对于每个询问跑LCA，倍增的时候已经顺便求出了最小边权，所以往上跳的同时更新答案。

　　代码如下

#include<cstdio>
#include<cctype>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<cstring>
inline long long read(){
    long long num=,f=;
    char ch=getchar();
    while(!isdigit(ch)){
        if(ch=='-')    f=-;
        ch=getchar();
    }
    while(isdigit(ch)){
        num=num*+ch-'';
        ch=getchar();
    }
    return num*f;
}

struct EDGE{
    int from,to,dis;
    bool operator <(const EDGE &a)const{
        return dis>a.dis;
    }
}que[];

int father[];
struct Edge{
    int next,to,dis;
}edge[];
int head[],num;
inline void add(int from,int to,int dis){
    edge[++num]=(Edge){head[from],to,dis};
    head[from]=num;
}

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

inline void unionn(int x,int y){
    x=find(x);y=find(y);
    father[y]=x;
}

int deep[];
int d[][];
int s[][];

void dfs(int x,int fa){
    deep[x]=deep[fa]+;
    for(int i=head[x];i;i=edge[i].next){
        int to=edge[i].to;
        if(to==fa)    continue;
        d[to][]=x;
        s[to][]=edge[i].dis;
        dfs(to,x);
    }
}
int cnt;
int main(){
    int n=read(),m=read();
    for(int i=;i<=m;++i){
        int from=read(),to=read(),dis=read();
        que[i]=(EDGE){from,to,dis};
    }
    std::sort(que+,que+m+);
    for(int i=;i<=n;++i)    father[i]=i;
    for(int i=;i<=m;++i){
        int from=que[i].from,to=que[i].to,dis=que[i].dis;
        if(find(from)==find(to))    continue;
        unionn(from,to);
        add(from,to,dis);
        add(to,from,dis);
        if(++cnt==n-)    break;
    }
    for(int i=;i<=n;++i)
        if(!deep[i])    dfs(i,i);
    for(int j=;(<<j)<=n;++j)
        for(int i=;i<=n;++i){
            d[i][j]=d[d[i][j-]][j-];
            s[i][j]=std::min(s[d[i][j-]][j-],s[i][j-]);
        }
    int Q=read();
    for(int i=;i<=Q;++i){
        int from=read(),to=read();
        if(find(from)!=find(to)){
            printf("-1\n");
            continue;
        }
        if(deep[from]<deep[to])    std::swap(from,to);
        int x=deep[from]-deep[to],ans=0x7fffffff;
        for(int j=;(<<j)<=x;++j)
            if((<<j)&x){
                ans=std::min(ans,s[from][j]);
                from=d[from][j];
            }
        if(from==to){
            printf("%d\n",ans);
            continue;
        }
        for(int j=log2(n);j>=;--j)
            if(d[from][j]!=d[to][j]){
                ans=std::min(ans,std::min(s[from][j],s[to][j]));
                from=d[from][j];
                to=d[to][j];
            }
        ans=std::min(ans,std::min(s[from][],s[to][]));
        printf("%d\n",ans);
    }
    return ;
}

完毕。