bzoj 3732 Network（最短路+倍增 | LCT）

 

【题目链接】

 

    http://www.lydsy.com/JudgeOnline/problem.php?id=3732

 

【题意】

 

    给定一个无向图，处理若干询问:uv路径上最长的边最小是多少？

 

【思路一】

 

    最小生成树+倍增算法。

    同NOIP2013货车运输。

 

【代码】

 

#include<set>
#include<cmath>
#include<queue>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define trav(u,i) for(int i=front[u];i;i=e[i].nxt)
#define FOR(a,b,c) for(int a=(b);a<=(c);a++)
using namespace std;

typedef long long ll;
const int N = 1e5+10;
const int M = 2e5+10;
const int D = 21;
const int inf = 2e9;

ll read() {
    char c=getchar();
    ll f=1,x=0;
    while(!isdigit(c)) {
        if(c=='-') f=-1; c=getchar();
    }
    while(isdigit(c))
        x=x*10+c-'0',c=getchar();
    return x*f;
}

struct Edge { 
    int u,v,w,nxt;
    bool operator < (const Edge& rhs) const{
        return w<rhs.w;
    }
}e[M];
int en=1,front[N];
void adde(int u,int v,int w) 
{
    e[++en]=(Edge){u,v,w,front[u]}; front[u]=en;
}
vector<Edge> es;

int n,m,K,p[N],_max[N][D],fa[N][D],dep[N];

int ifind(int u)
{
    return u==p[u]? u:p[u]=ifind(p[u]);
}

void Kruskal()
{
    sort(es.begin(),es.end());
    FOR(i,0,(int)es.size()-1) {
        int u=es[i].u,v=es[i].v,w=es[i].w;
        int x=ifind(u),y=ifind(v);
        if(x!=y) {
            p[x]=y;
            adde(u,v,w); adde(v,u,w);
        }
    }
}
void dfs(int u,int father)
{
    trav(u,i) {
        int v=e[i].v;
        if(v!=father) {
            fa[v][0]=u;
            _max[v][0]=e[i].w;
            dep[v]=dep[u]+1;
            FOR(j,1,D-1) {
                fa[v][j]=fa[fa[v][j-1]][j-1];
                _max[v][j]=max(_max[v][j-1],_max[fa[v][j-1]][j-1]);
            }
            dfs(v,u);
        }
    }
}

int query(int u,int v)
{
    if(dep[u]<dep[v]) swap(u,v);
    int t=dep[u]-dep[v],ans=-inf;
    FOR(i,0,D-1)
        if(t&(1<<i)) {
            ans=max(ans,_max[u][i]);
            u=fa[u][i];
        }
    if(u==v) return ans;
    for(int i=D-1;i>=0;i--)
        if(fa[u][i]!=fa[v][i]) {
            ans=max(ans,max(_max[u][i],_max[v][i]));
            u=fa[u][i],v=fa[v][i];
        }
    ans=max(ans,max(_max[u][0],_max[v][0]));
    return ans;
}

int main()
{
    n=read(),m=read(),K=read();
    FOR(i,0,n) FOR(j,0,D-1) _max[i][j]=-inf;
    FOR(i,1,n) p[i]=i;
    FOR(i,1,m) {
        int u=read(),v=read(),w=read();
        es.push_back((Edge){u,v,w,0});
    }
    Kruskal();
    dfs(1,-1);
    FOR(i,1,K) {
        int u=read(),v=read();
        printf("%d\n",query(u,v));
    }
    return 0;
}

 

【思路二】

   

    用LCT换个姿势AC。LCT维护最小生成树？

    给每条边每个点开一个LCT结点，边的maxe初始为自己，点的maxe为0。对于新加的一条边，找到u->v目前的最大边与之比较，如果更小则切断原来的边连上新的边。u,v之间连边的时候以边界点为中间点。

 

【代码】

 

#include<cstdio>
#include<cstring>
#include<iostream>
#define FOR(a,b,c) for(int a=b;a<=c;a++)
#define trav(u,i) for(int i=front[u];i;i=e[i].nxt)
using namespace std;

typedef long long ll;
typedef unsigned int ul;
const int N = 4e5+10;

ll read() {
    char c=getchar();
    ll f=1,x=0;
    while(!isdigit(c)) {
        if(c=='-') f=-1; c=getchar();
    }
    while(isdigit(c))
        x=x*10+c-'0',c=getchar();
    return x*f;
}

struct Edge { int u,v,w;
}e[N<<2];

namespace LCT {

    struct Node {
        Node *ch[2],*fa;
        int rev,id,maxe;
        Node() ;
        void reverse() {
            rev^=1;
            swap(ch[0],ch[1]);
        }
        void up_push() {
            if(fa->ch[0]==this||fa->ch[1]==this) 
                fa->up_push();
            if(rev) {
                ch[0]->reverse();
                ch[1]->reverse();
                rev=0;
            }
        }
        void maintain() {
            int _max=-1;
            if(e[ch[0]->maxe].w>_max)
                _max=e[ch[0]->maxe].w,maxe=ch[0]->maxe;
            if(e[ch[1]->maxe].w>_max)
                _max=e[ch[1]->maxe].w,maxe=ch[1]->maxe;
            if(e[id].w>_max) maxe=id;
        }
    } *null=new Node,T[N],E[N<<2];
    Node::Node() {
        id=maxe=rev=0;
        fa=ch[0]=ch[1]=null;
    }
    
    void rot(Node* o,int d) {
        Node *p=o->fa;
        p->ch[d]=o->ch[d^1];
        o->ch[d^1]->fa=p;
        o->ch[d^1]=p;
        o->fa=p->fa;
        if(p==p->fa->ch[0])
            p->fa->ch[0]=o;
        else if(p==p->fa->ch[1])
            p->fa->ch[1]=o;
        p->fa=o;
        p->maintain();
    }
    void splay(Node *o) {
        o->up_push();
        Node *nf,*nff;
        while(o->fa->ch[0]==o||o->fa->ch[1]==o) {
            nf=o->fa,nff=nf->fa;
            if(o==nf->ch[0]) {
                if(nf==nff->ch[0]) rot(nf,0);
                rot(o,0);
            } else {
                if(nf==nf->ch[1]) rot(nf,1);
                rot(o,1);
            }
        }
        o->maintain();
    }
    void Access(Node* o) {
        Node *son=null;
        while(o!=null) {
            splay(o);
            o->ch[1]=son;
            o->maintain();
            son=o; o=o->fa;
        }
    }
    void evert(Node* o) {
        Access(o);
        splay(o);
        o->reverse();
    }
    void Link(Node* u,Node* v) {
        evert(u);
        u->fa=v;
    }
    void Cut(Node* u,Node* v) {
        evert(u);
        Access(v); splay(v);
        u->fa=v->ch[0]=null;
        v->maintain();
    }
    Node* find(Node* o) {
        while(o->fa!=null) o=o->fa;
        return o;
    }
    
}
using namespace LCT;

const int inf = 1e9+10;

int n,m,K;

int query(Node *u,Node *v)
{
    evert(u);
    Access(v),splay(v);
    return v->maxe;
}
void insert(Node *u,Node *v,int x)
{
    if(e[x].u==e[x].v) return ;
    if(find(u)==find(v)) {
        int maxe=query(u,v);
        if(e[x].w>=e[maxe].w) return ;
        Cut(&E[maxe],&T[e[maxe].v]);
        Cut(&E[maxe],&T[e[maxe].u]);
    }
    Link(u,&E[x]);
    Link(v,&E[x]);
}

int main()
{
    n=read(),m=read(),K=read();
    FOR(i,1,m) E[i].id=E[i].maxe=i;
    FOR(i,1,m) {
        e[i].u=read(),e[i].v=read(),e[i].w=read();
        insert(&T[e[i].u],&T[e[i].v],i);
    }
    FOR(i,1,K) {
        int u=read(),v=read();
        printf("%d\n",e[query(&T[u],&T[v])].w);
    }
    return 0;
}