BZOJ 3732: Network 最小瓶颈路

3732: Network

Time Limit: 10 Sec Memory Limit: 128 MB
Submit: 2054 Solved: 979
[Submit][Status][Discuss]

Description

给你N个点的无向图 (1 <= N <= 15,000)，记为：1…N。
图中有M条边 (1 <= M <= 30,000) ，第j条边的长度为： d_j ( 1 < = d_j < = 1,000,000,000).

现在有 K个询问 (1 < = K < = 20,000)。
每个询问的格式是：A B，表示询问从A点走到B点的所有路径中，最长的边最小值是多少？

Input

第一行： N, M, K。
第2..M+1行: 三个正整数：X, Y, and D (1 <= X <=N; 1 <= Y <= N). 表示X与Y之间有一条长度为D的边。
第M+2..M+K+1行: 每行两个整数A B,表示询问从A点走到B点的所有路径中，最长的边最小值是多少？

Output

对每个询问，输出最长的边最小值是多少。

Sample Input

6 6 8

1 2 5

2 3 4

3 4 3

1 4 8

2 5 7

4 6 2

1 2

1 3

1 4

2 3

2 4

5 1

6 2

6 1

Sample Output

5

5

5

4

4

7

4

5

HINT

1 <= N <= 15,000

1 <= M <= 30,000

1 <= d_j <= 1,000,000,000

1 <= K <= 15,000

Source

题解：
求u，v之间的最长路径的最小值即求u，v之间的最小瓶颈路，等价于建一颗最小生成树，再求出u和v之间的路径的最大值。【自己瞎yy一下就可以得出这个结论了。

我大概是个只会链剖不会倍增的傻逼了
不过链剖的时间复杂度很科学。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

inline int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9') {if(ch=='-') f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

const int N = 15000 + 10;
const int M = 30000 + 10;

int n,m,q;
struct node{
    int pre,v,u,w;
}edge[M<<1],e[M<<1];

int num=0,head[N];
void adde(int from,int to,int w){
    e[++num].pre=head[from],head[from]=num;
    e[num].v=to,e[num].w=w;
}

void addedge(int from,int to,int w,int i){
    edge[i].u=from,edge[i].v=to,edge[i].w=w;
}

bool operator < (node a,node b){
    return a.w<b.w;
}

int fa[N];
int find(int x){
    if(x==fa[x]) return fa[x];
    return fa[x]=find(fa[x]);
}

int siz[N],son[N],dep[N],a[N];
void dfs1(int u,int f){
    siz[u]=1,fa[u]=f;
    for(int i=head[u];i;i=e[i].pre){
        int v=e[i].v;
        if(v==f) continue;
        dep[v]=dep[u]+1;
        a[v]=e[i].w;
        dfs1(v,u);
        siz[u]+=siz[v];
        if(siz[v]>siz[son[u]]) son[u]=v;
    }
}

int in[N],indx=0,top[N],seq[N];
void dfs2(int u,int tp){
    top[u]=tp;in[u]=++indx;seq[indx]=u;
    if(!son[u]) return ;
    dfs2(son[u],tp);
    for(int i=head[u];i;i=e[i].pre){
        int v=e[i].v;
        if(v==fa[u]||v==son[u]) continue;
        dfs2(v,v);
    }
}

struct TREE{
    int mmax;
}t[N<<2];

void update(int root){
    t[root].mmax=max(t[root<<1].mmax,t[root<<1|1].mmax);
}

void build(int root,int l,int r){
    if(l==r){
        t[root].mmax=a[seq[l]];
        return ;
    }
    int mid=l+r>>1;
    build(root<<1,l,mid);
    build(root<<1|1,mid+1,r);
    update(root);
}

int query(int root,int l,int r,int pos,int val){
    if(pos<=l&&val>=r) return t[root].mmax;
    int mid=l+r>>1;
    int ans=-1;
    if(pos<=mid) ans=max(ans,query(root<<1,l,mid,pos,val));
    if(val>mid) ans=max(ans,query(root<<1|1,mid+1,r,pos,val));
    return ans;
}

int query(int u,int v){
    int f1=top[u],f2=top[v];
    int ans=-1;
    while(f1!=f2){
        if(dep[f1]<dep[f2]) swap(f1,f2),swap(u,v);
        ans=max(ans,query(1,1,n,in[f1],in[u]));
        u=fa[f1],f1=top[u];
    }
    if(dep[u]>dep[v]) swap(u,v);
    ans=max(ans,query(1,1,n,in[son[u]],in[v]));
    return ans;
}

int main(){
    n=read(),m=read(),q=read();
    for(int i=1;i<=n;++i) fa[i]=i;
    for(int i=1;i<=m;++i){
        int u=read(),v=read(),w=read();
        addedge(u,v,w,i);
    }
    sort(edge+1,edge+m+1);int cnt=0;
    for(int i=1;i<=m;++i){
        int u=edge[i].u,v=edge[i].v;
        int x=find(u),y=find(v);
        if(x==y) continue;
        ++cnt;fa[x]=y;
        adde(u,v,edge[i].w);adde(v,u,edge[i].w);
        if(cnt==n-1) break;
    }
    dep[1]=1;dfs1(1,0);dfs2(1,1);

    build(1,1,n);
    while(q--){
        int u=read(),v=read();
        printf("%d\n",query(u,v));
    }
    return 0;
}