題目描述

A 國有 n 座城市，編號從 1 到 n，城市之間有 m 條雙向道路。每一條道路對車輛都有重量限制，簡稱限重。現在有 q 輛貨車在運輸貨物， 司機們想知道每輛車在不超過車輛限重的情況下，最多能運多重的貨物。
輸入輸出格式
輸入格式：

輸入檔名為 truck.in。

輸入檔案第一行有兩個用一個空格隔開的整數 n，m，表示 A 國有 n 座城市和 m 條道

路。 接下來 m 行每行 3 個整數 x、 y、 z，每兩個整數之間用一個空格隔開，表示從 x 號城市到 y 號城市有一條限重為 z 的道路。注意： x 不等於 y，兩座城市之間可能有多條道路 。

接下來一行有一個整數 q，表示有 q 輛貨車需要運貨。

接下來 q 行，每行兩個整數 x、y，之間用一個空格隔開，表示一輛貨車需要從 x 城市運輸貨物到 y 城市，注意： x 不等於 y 。

輸出格式：

輸出檔名為 truck.out。

輸出共有 q 行，每行一個整數，表示對於每一輛貨車，它的最大載重是多少。如果貨

車不能到達目的地，輸出-1。

輸入輸出樣例
輸入樣例#1：

4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3

輸出樣例#1：

3
-1
3

說明

對於 30%的資料，0 < n < 1,000，0 < m < 10,000，0 < q< 1,000；

對於 60%的資料，0 < n < 1,000，0 < m < 50,000，0 < q< 1,000；

對於 100%的資料，0 < n < 10,000，0 < m < 50,000，0 < q< 30,000，0 ≤ z ≤ 100,000。

分析

　　易知，ans絕對在該圖的最大生成樹上．
　　於是，果斷先kurskal將圖處理成樹，那麼給出x,y後只需要在x–>y的路徑上取權值最小即可（保證不超載）．
　　x–>y的路徑(保證x,y聯通)：x–>lca(x,y)–>y {在知道fa的情況下，直接for就行了}
　　然後．．就沒有然後了（貌似有點暴力，然而資料就是這麼水）

　　在翻題解的時候，偶然翻到某位dalao的kruskal重構樹，於是baidu了一下（貌似挺簡單的）：
　　–方法：按照kruskal求最小生成樹的方式加邊，但每次在加邊時，新建一個節點，然後把兩個聯通塊（其實是兩棵二叉樹）的根節點作為其左右兒子，把邊權賦值給新建節點
　　–性質：
　　　1.是一棵二叉樹；
　　　2.滿足父節點的值大於等於兒子節點，是一個大頂堆，這是最關鍵的一點；
　　　3.原圖上任意兩點間路徑最長邊的最小值等於其lca的值；
　　根據性質3，可解決圖中兩點路徑最長邊的最小值，即本題的所求
　　
　　So,與上文類似，除去遍歷步驟，改動一下kruskal即可

程式碼

法一：　kruskal+lca(倍增)+遍歷
（貌似有點凌亂）

#include <cstdio>
#include <cstdlib>
#include <algorithm>
#define min_(x,y) x<y?x:y;
#define open(s) freopen(s".in","r",stdin); freopen(s".out","w",stdout);
#define close fclose(stdin); fclose(stdout); 
using namespace std;

int n,m,q;

struct Edge
{
    int to;
    int nxt;
    int w;
};
int cnt;
int head[10005];
Edge edge[20005];
inline void add(int x,int y,int z)//存樹
{
    edge[++cnt]=(Edge){y,head[x],z};
    head[x]=cnt;
}

struct Side//kruskal
{
    int x,y,w;
    bool operator < (const Side &b) const
    {
        return w>b.w;
    }
}side[50005];
int pa[10005];
int size[10005];
inline int find(int x)
{
    return pa[x]=(pa[x]==x)?x:find(pa[x]);
}
inline bool join(int x,int y)
{
    int x1=find(x),y1=find(y);
    if(x1==y1) return 0;
    if(size[x1]>size[y1])
    {
        size[x1]+=size[y1];
        pa[y1]=x1;
    }else
    {
        size[y1]+=size[x1];
        pa[x1]=y1;
    }
    return 1;
}
int dep[10005];//LCA
int w[10005];
int fa[10005][14];
int lg[10005];
inline void swap_(int &x,int &y)
{
    int tmp=x; x=y; y=tmp;
}
inline void get_lg()
{
    for(int i=1;i<=n;++i)
        lg[i]=lg[i-1]+(1<<(lg[i-1]+1)==i);
}
inline void get_dep(int u,int pre)
{
    for(int i=head[u],v;i;i=edge[i].nxt)
    if(edge[i].to!=pre)
    {
        v=edge[i].to;
        dep[v]=dep[u]+1;
        fa[v][0]=u;
        w[v]=edge[i].w;
        get_dep(v,u);
    }
}
inline void get_fa()
{
    for(int j=1;j<=lg[n];++j)
    for(int i=1;i<=n;++i)
    if(j<=lg[dep[i]])
        fa[i][j]=fa[ fa[i][j-1] ][j-1];
}
inline int get_lca(int x,int y)
{
    if(dep[x]<dep[y]) swap_(x,y);
    for(;dep[x]>dep[y];)
        x=fa[x][lg[dep[x]-dep[y]]];
    if(x==y) return x;
    for(int i=lg[dep[x]];i>=0;--i)
    if(fa[x][i]!=fa[y][i])
    {
        x=fa[x][i];
        y=fa[y][i];
    }
    return fa[x][0];
}

inline int read()
{
    int k=1;
    int sum=0;
    char c=getchar();
    for(;'0'>c || c>'9' ;c=getchar())
        if(c=='-') k=-1;
    for(;'0'<=c && c<='9';c=getchar())
        sum=sum*10+c-'0';
    return sum*k;
}

inline void write(int x)
{
    if(x<0) { putchar('-'); x*=-1; }
    if(x>9) write(x/10);
    putchar(x%10+'0');
}

inline void kruskal()
{
    sort(side+1,side+m+1);
    for(int i=1;i<=n;++i) pa[i]=i,size[i]=1;
    int T=n-1;
    for(int i=1,x,y;i<=m && T;++i)
    {
        x=side[i].x; y=side[i].y;
        if(join(x,y))
        {
            --T;
            add(x,y,side[i].w);
            add(y,x,side[i].w);
        }
    }
}

int main()
{
    open("1967");

    n=read();
    m=read();

    for(int i=1,x,y,z;i<=m;++i)
    {
        x=read(); y=read(); z=read();
        side[i]=(Side){x,y,z};
    }
    kruskal();
    get_lg();
    for(int i=1;i<=n;++i)
    if(!dep[i])
        get_dep(i,0);
    get_fa();

    q=read();
    for(int l,r,mid,ans;q;--q)
    {
        l=read(); r=read();
        if(find(l)!=find(r)) { printf("-1\n"); continue; }//不聯通直接處理
        mid=get_lca(l,r);
        ans=0x3f3f3f3f;
        for(;l!=mid;l=fa[l][0]) ans=min_(ans,w[l]);
        for(;r!=mid;r=fa[r][0]) ans=min_(ans,w[r]);//利用fa直接遍歷查詢
        printf("%d\n",ans);
    }

    close;
    return 0;
}

法二：　ruskal重構樹+lca(倍增)
（貌似寫炸了，還沒上面的快．．．）

#include <cstdio>
#include <cstdlib>
#include <algorithm>
#define open(s) freopen(s".in","r",stdin); freopen(s".out","w",stdout);
#define close fclose(stdin); fclose(stdout); 
using namespace std;

int n,m,q;

int fa[20005][14];
int dep[20005];
int w[20005];
int lg[20005];

struct Side
{
    int x,y,w;
    bool operator < (const Side &b) const
    {
        return w>b.w;
    }
}side[50005];
int pa[20005];
inline int find(int x)
{
    return pa[x]=(pa[x]==x)?x:find(pa[x]);
}
inline bool join(int x,int y,int z)
{
    int x1=find(x),y1=find(y);
    if(x1==y1) return 0;
    ++n;  //新增節點
    fa[x1][0]=n;　//x1,y1分別作為其左右兒子
    fa[y1][0]=n;　
    pa[x1]=pa[y1]=pa[n]=n;　//由於連通了，更新pa
    w[n]=z;//x--y的邊權最為點權
    return 1;
}

inline void swap_(int &x,int &y)
{
    int tmp=x; x=y; y=tmp;
}
inline void get_lg()
{
    for(int i=1;i<=n;++i)
        lg[i]=lg[i-1]+(1<<(lg[i-1]+1)==i);
}
inline int get_dep(int u)
{
    if(!fa[u][0] || dep[u]) return dep[u];
    return dep[u]=get_dep(fa[u][0])+1;
}
inline void get_fa()
{
    for(int j=1;j<=lg[n];++j)
    for(int i=1;i<=n;++i)
    if(j<=lg[dep[i]])
        fa[i][j]=fa[ fa[i][j-1] ][j-1];
}
inline int get_lca(int x,int y)
{
    if(find(x)!=find(y)) return -1;
    if(dep[x]<dep[y]) swap_(x,y);
    for(;dep[x]>dep[y];)
        x=fa[x][lg[dep[x]-dep[y]]];
    if(x==y) return w[x];
    for(int i=lg[dep[x]];i>=0;--i)
    if(fa[x][i]!=fa[y][i])
    {
        x=fa[x][i];
        y=fa[y][i];
    }
    return w[fa[x][0]];
}

inline int read()
{
    int k=1;
    int sum=0;
    char c=getchar();
    for(;'0'>c || c>'9' ;c=getchar())
        if(c=='-') k=-1;
    for(;'0'<=c && c<='9';c=getchar())
        sum=sum*10+c-'0';
    return sum*k;
}

inline void write(int x)
{
    if(x<0) { putchar('-'); x*=-1; }
    if(x>9) write(x/10);
    putchar(x%10+'0');
}

inline void kruskal()
{
    sort(side+1,side+m+1);
    for(int i=1;i<=n;++i) pa[i]=i;
    int T=n-1;
    for(int i=1,x,y;i<=m && T;++i)
    {
        x=side[i].x; y=side[i].y;
        if(join(x,y,side[i].w))
            --T;
    }
}

int main()
{
    open("1967");

    n=read();
    m=read();

    for(int i=1,x,y,z;i<=m;++i)
    {
        x=read(); y=read(); z=read();
        side[i]=(Side){x,y,z};
    }
    kruskal();

    get_lg();
    for(int i=1;i<=n;++i)
    if(!dep[i])
        get_dep(i);
    get_fa();

    q=read();
    for(;q;--q)
    {
        write(get_lca(read(),read()));
        putchar('\n');
    }

    close;
    return 0;
}