[NOIP2013]货车运输 D1 T3

[NOIP2013]货车运输 D1 T3

Description:

A 国有 n 座城市，编号从 1 到 n，城市之间有 m 条双向道路。每一条道路对车辆都有重量限制，简称限重。现在有 q 辆货车在运输货物，司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。

Input

第一行有两个用一个空格隔开的整数 n，m，表示 A 国有 n 座城市和 m 条道路。
接下来 m 行每行 3 个整数 x、y、z，每两个整数之间用一个空格隔开，表示从 x 号城市到 y 号城市有一条限重为 z 的道路。注意：x 不等于 y，两座城市之间可能有多条道路。
接下来一行有一个整数 q，表示有 q 辆货车需要运货。
接下来 q 行，每行两个整数 x、y，之间用一个空格隔开，表示一辆货车需要从 x 城市运输货物到 y 城市，注意：x 不等于 y。

Output

输出共有 q 行，每行一个整数，表示对于每一辆货车，它的最大载重是多少。如果货车不能到达目的地，输出-1。

Sample Input

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

Sample Output

3
-1
3

HINT

对于 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。

Source

NOIP2013提高组

就是这道题让我用了整整一个下午的时间来A掉，本来的想法是一般的水题模板题就不必写题解了，但是做完这道思想极其简单的题后我突然觉得，做计算机题真的是一个打发时间的好方法。
现在进入正题。。。
解这道题的思路很容易想到，用手模拟一下就知道是求从A点到B点的所有路径中边权最小值的最大值，但是图论的东西那么多，该怎么办？
第一个突破点就是做一个最大生成树，方法还是kruskal，只需要改一下符号就好了，这是第一步。
然后就是LCA，求出最近公共祖先，这个就有点纠结了。。到底是用Tarjan，倍增，还是朴素算法？！当然我尝试了两种，第一次用的Tarjan（因为刚学过特顺手。。）最后的结果当然是实现不了，朴素算法就可以过。
找到A，B两点的LCA后，只需要求出A，B，分别到其路径中最小值，再求最小值就是答案。
说了这么多，思想还是很简单，不过写代码就。。
因为你需要定义两个图，即两个结构体，然后再加边，求一大堆东西。。
废话少说，上代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define MAXN 90000
#define INF 999999
using namespace std;
struct node1
{
    int next,from,to,val;
}edge[MAXN<<1];
struct tree1
{
    int from,to,next,val;
}tree[MAXN<<1];
struct node2
{
    int from,to,next,index;
}que[MAXN<<1];
int n,m,cnt1,cnt3,ans=INF;
int head1[MAXN],head3[MAXN],fa[MAXN],visit[MAXN],dis[MAXN],deep[MAXN],diet[MAXN],used[MAXN],fa2[MAXN];
void addedge(int from,int to,int val)
{
    edge[cnt1].to=to;
    edge[cnt1].from=from;
    edge[cnt1].val=val;
    edge[cnt1].next=head1[from];
    head1[from]=cnt1++;
}
void addtree(int from,int to,int val)
{
    tree[cnt3].from=from;
    tree[cnt3].to=to;
    tree[cnt3].val=val;
    tree[cnt3].next=head3[from];
    head3[from]=cnt3++;
}
void pre_fa()
{
    for(int i=1;i<=n;i++)
    {
        fa[i]=i;
    }
}
int find(int v)
{
    if(fa[v]==v)
    {
        return fa[v];
    }
    else 
    {
        fa[v]=find(fa[v]);
        return fa[v];
    }
}
void swap(int& x,int& y)
{
    int t=y;
    y=x;
    x=t;
}
void dfs(int x,int pre,int step)
{
    used[x]=1;
    deep[x]=step;
    for(int i=head3[x];i!=-1;i=tree[i].next)
    {
        int to=tree[i].to;
        if(to==pre) continue;
        diet[tree[i].to]=tree[i].val;
        fa2[to]=x;
        dfs(to,x,step+1);
    }
}
int min(int a,int b){return a<b?a:b;}
int lca(int x,int y)
{
    int ans1=INF,ans2=INF;
    if(deep[x]<deep[y])     swap(x,y);
    while(deep[x]>deep[y])  ans1=min(ans1,diet[x]),x=fa2[x];
    while(x!=y)  ans1=min(ans1,diet[x]),ans2=min(ans2,diet[y]),x=fa2[x],y=fa2[y];
    return min(ans1,ans2);
}
void init()
{
    memset(head1,-1,sizeof(head1));
    memset(head3,-1,sizeof(head3));
    cnt1=cnt3=1;
}
int cmp(node1 a,node1 b)
{
    return a.val > b.val ? 1 : 0;
}
int main()
{
    scanf("%d%d",&n,&m);
    pre_fa();
    init();
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        addedge(a,b,c);
        addedge(b,a,c);
    }
    sort(edge+1,edge+1+m*2,cmp);
    int num=0,k=1;
    for(int i=1;i<=m*2;i++)
    {
        int t1=find(edge[i].from);
        int t2=find(edge[i].to);
        if(t1!=t2)
        {
            fa[t1]=t2;
            addtree(edge[i].from,edge[i].to,edge[i].val);
            addtree(edge[i].to,edge[i].from,edge[i].val);
        }
    }
    for(int i=1;i<=n;i++)
    {
        if(used[i]==0)
        {
            dfs(i,-1,1); 
        } 
    }
    int q;
    scanf("%d",&q);
    for(int i=1;i<=q;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        if(find(a)!=find(b))
        {
            printf("-1\n");
            continue;
        }
        int c=lca(a,b);
        printf("%d\n",c);
    }
    return 0;
}    

思路有了之后其实就很简单了。
多思考。。
老师说得对