uva 12655 Trucks(树剖+MST)

题目链接：点击打开链接

题意：给出n个点，m条双向边，每个边都有个权值（这个路可以通行的最大重量），然后有q个查询，每次查询u到v上最大可以运输多少重量（每次只从u出发一辆车）

分析：为使u到v运输重量最大，那么就要使u到v路径上最小的边尽量大，于是这里可以搞个最大生成树，这样就使得每一条边尽量大了，然后根据最大生成树建LCT，查询即可

#include<bits/stdc++.h>
using namespace std;
const int N=2e4+200;
#define mem(a,b) memset(a,b,sizeof(a))
typedef long long ll;
struct edge
{
    int v,next,w;
} e[N*10];
int siz[N],tid[N],rnk[N],top[N],faz[N],son[N],dep[N];
int first[N],tot,cnt,a[N],f[N];
struct Map
{
    int u,v,w;
} g[N*10];
struct node
{
    int l,r,minn;
    int mid()
    {
        return (l+r)>>1;
    }
} t[N<<2];
void add(int u,int v,int w)
{
    e[tot].v=v;
    e[tot].w=w;
    e[tot].next=first[u];
    first[u]=tot++;
}
void dfs1(int u,int father,int depth)
{
    siz[u]=1;
    dep[u]=depth;
    faz[u]=father;
    for(int i=first[u]; ~i; i=e[i].next)
    {
        int v=e[i].v;
        if(v!=father)
        {
            a[v]=e[i].w;
            dfs1(v,u,depth+1);
            siz[u]+=siz[v];
            if(son[u]==-1||siz[v]>siz[son[u]])
                son[u]=v;
        }
    }
}
void dfs2(int u,int t)
{
    tid[u]=++cnt;
    rnk[cnt]=u;
    top[u]=t;
    if(son[u]==-1)
        return;
    dfs2(son[u],t);
    for(int i=first[u]; ~i; i=e[i].next)
    {
        int v=e[i].v;
        if(v!=faz[u]&&v!=son[u])
            dfs2(v,v);
    }
}
void pushup(int rt)
{
    t[rt].minn=min(t[rt<<1].minn,t[rt<<1|1].minn);
}
void build(int l,int r,int rt)
{
    t[rt].l=l,t[rt].r=r;
    if(l==r)
    {
        t[rt].minn=a[rnk[l]];
        return;
    }
    int m=t[rt].mid();
    build(l,m,rt<<1);
    build(m+1,r,rt<<1|1);
    pushup(rt);
}

int query(int ql,int qr,int rt)
{
    if(ql<=t[rt].l&&t[rt].r<=qr)return t[rt].minn;
    int m=t[rt].mid(),ans=0x3f3f3f3f;
    if(ql<=m)ans=min(ans,query(ql,qr,rt<<1));
    if(qr>m)ans=min(ans,query(ql,qr,rt<<1|1));
    return ans;
}
int query_path(int u,int v)
{
    int ans=0x3f3f3f3f;
    while(top[u]!=top[v])
    {
        if(dep[top[u]]<dep[top[v]])swap(u,v);
        ans=min(ans,query(tid[top[u]],tid[u],1));
        u=faz[top[u]];
    }
    if(u!=v)
    {
    if(tid[u]>tid[v])swap(u,v);
    ans=min(ans,query(tid[son[u]],tid[v],1));
    }
    return ans;
}
void init()
{
    mem(son,-1);
    mem(first,-1);
    tot=cnt=0;
}
bool cmp(Map A,Map B)
{
    return A.w>B.w;
}
int getf(int x)
{
    return f[x]==x?x:f[x]=getf(f[x]);
}
bool mix(int x,int y)
{
    int tx=getf(x),ty=getf(y);
    if(tx!=ty)
    {
        f[tx]=ty;
        return 1;
    }
    return 0;
}
void kruskal(int n,int m)
{
    for(int i=1; i<=n; i++)f[i]=i;
    sort(g+1,g+1+m,cmp);
    int cnt=0;
    for(int i=1; i<=m; i++)
    {
        if(g[i].u==g[i].v)continue;
        if(mix(g[i].u,g[i].v))
        {
            add(g[i].u,g[i].v,g[i].w);
            add(g[i].v,g[i].u,g[i].w);
            cnt++;
        }
        if(cnt==n-1)break;
    }
}
int main()
{
    int n,q,u,v,w,m;
    while(~scanf("%d%d%d",&n,&m,&q))
    {
        init();
        for(int i=1; i<=m; i++)
            scanf("%d%d%d",&g[i].u,&g[i].v,&g[i].w);
        kruskal(n,m);

        dfs1(1,1,1);
        dfs2(1,1);
        a[1]=0x3f3f3f3f;
        build(1,n,1);
        while(q--)
        {
            scanf("%d%d",&u,&v);
            printf("%d\n",query_path(u,v));
        }
    }
    return 0;
}