【51nod1743】雪之国度（最小生成树+倍增）

点此看题面

大致题意： 给你一张无向连通图，其中每条边的边权为这条边连接的两点的权值之差。每次询问两点之间是否存在两条不重复的路径，若存在则输出这两条路径上最大值的最小值。

大致思路

这题显然就是要让你维护边双。

我们可以先对原图求一遍最小生成树，然后再将其余非树边（按权值从小到大先排一次序）一条一条地加到图中。

对于这条边连接的两个点，我们需要对它们在树上路径进行修改。

要注意的是，对于已经修改过的，我们就不能对它进行再一次修改，因为边已经排过序，新加上的边肯定没有原来加上的边更优。

至于维护，可以采用并查集。

如果要查询，直接采用倍增法在树上乱跳求答案即可。

代码

#include<bits/stdc++.h>
#define ten(x) (((x)<<3)+((x)<<1))
#define N 100000
#define M 500000
#define LogN 20
#define INF 1000000000
#define add(x,y,z) (e[++ee].nxt=lnk[x],e[lnk[x]=ee].to=y,e[ee].val=z)
#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)<(y)?(x):(y))
#define abs(x) ((x)<0?-(x):(x))
using namespace std;
int n,m,ee=0,val[N+5],lnk[N+5];
struct edge
{
    int from,to,nxt,val,vis;
    inline friend bool operator < (edge x,edge y) {return x.val<y.val;}//按边权从小到大排序
}s[M+5],e[(N<<1)+5];
class FIO
{
    private:
        #define Fsize 100000
        #define tc() (A==B&&(B=(A=Fin)+fread(Fin,1,Fsize,stdin),A==B)?EOF:*A++)
        #define pc(ch) (FoutSize<Fsize?Fout[FoutSize++]=ch:(fwrite(Fout,1,Fsize,stdout),Fout[(FoutSize=0)++]=ch))
        int Top,FoutSize;char ch,*A,*B,Fin[Fsize],Fout[Fsize],Stack[Fsize];
    public:
        inline void read(int &x) {x=0;while(!isdigit(ch=tc()));while(x=ten(x)+(ch&15),isdigit(ch=tc()));}
        inline void write(int x) {if(!x) return (void)(pc('0'));while(x) Stack[++Top]=x%10+48,x/=10;while(Top) pc(Stack[Top--]);}
        inline void write_char(char x) {pc(x);}
        inline void write_string(string x) {for(register int i=0,len=x.length();i<len;++i) pc(x[i]);}
        inline void clear() {fwrite(Fout,1,FoutSize,stdout);}
}F;
class UnionFindSet//并查集
{
    public:
        int fa[N+5];
        inline void Clear() {for(register int i=1;i<=N;++i) fa[i]=i;}
        UnionFindSet() {Clear();}
        inline int getfa(int x) {return fa[x]^x?fa[x]=getfa(fa[x]):x;}
        inline void Union(int x,int y) {if((x=getfa(x))^(y=getfa(y))) fa[y]=x;}
}U;
class Class_MulSolver//倍增
{
    public:
        int Depth[N+5],fa[N+5][LogN+5],Max[N+5][LogN+5];
    private:
        inline void dfs(int x,int lst)//DFS遍历预处理
        {
            for(register int i=lnk[x];i;i=e[i].nxt)
                if(e[i].to^lst) Depth[e[i].to]=Depth[fa[e[i].to][0]=x]+1,Max[e[i].to][0]=e[i].val,dfs(e[i].to,x);
        }
    public:
        inline void DfsInit() {dfs(1,0);}
        inline void MulInit() {for(register int i,j=1;j<=LogN;++j) for(i=1;i<=n;++i) fa[i][j]=fa[fa[i][j-1]][j-1],Max[i][j]=max(Max[i][j-1],Max[fa[i][j-1]][j-1]);}//预处理倍增数组
        inline int get_max(int x,int y)//求树上路径最大值
        {
            if(Depth[x]<Depth[y]) swap(x,y);
            register int i,res=0;
            for(i=0;Depth[x]^Depth[y];++i) if((Depth[x]^Depth[y])&(1<<i)) res=max(res,Max[x][i]),x=fa[x][i];
            if(!(x^y)) return res;
            for(i=0;fa[x][i]^fa[y][i];++i);
            for(--i;i>=0;--i) if(fa[x][i]^fa[y][i]) res=max(res,max(Max[x][i],Max[y][i])),x=fa[x][i],y=fa[y][i];
            return max(res,max(Max[x][0],Max[y][0]));
        }
}MulSolver;
int main()
{
    register int i,Q,x,y;
    for(F.read(n),F.read(m),F.read(Q),i=1;i<=n;++i) F.read(val[i]);
    for(i=1;i<=m;++i) F.read(s[i].from),F.read(s[i].to),s[i].val=abs(val[s[i].from]-val[s[i].to]);//存边
    for(sort(s+1,s+m+1),i=1;i<=m;++i) if(U.getfa(s[i].from)^U.getfa(s[i].to)) U.Union(s[i].from,s[i].to),s[i].vis=1,add(s[i].from,s[i].to,s[i].val),add(s[i].to,s[i].from,s[i].val);//建一棵最小生成树
    for(U.Clear(),MulSolver.DfsInit(),i=1;i<=m;++i)//将非树边一条一条加到树上
    {
        if(s[i].vis) continue;//如果是树边，跳过
        for(x=U.getfa(s[i].from),y=U.getfa(s[i].to);x^y;x=U.getfa(x))//如果遇到已修改过的，则结束更新过程
        {
            if(MulSolver.Depth[x]<MulSolver.Depth[y]) swap(x,y);//如果x比y深度小，交换
            MulSolver.Max[x][0]=s[i].val,U.fa[x]=MulSolver.fa[x][0];//更新信息
        }
    }
    for(MulSolver.MulInit();Q;--Q) F.read(x),F.read(y),(U.getfa(x)^U.getfa(y)?F.write_string("infinitely\n"):(F.write(MulSolver.get_max(x,y)),F.write_char('\n')));//用倍增法求解
    return F.clear(),0;
}

原文地址：https://www.cnblogs.com/chenxiaoran666/p/51nod1743.html