NOIP2013 货车运输 （最大生成树+树上倍增LCA）

死磕一道题，中间发现倍增还是掌握的不熟 ，而且深刻理解：SB错误毁一生，憋了近2个小时才调对，不过还好一遍AC省了更多的事，不然我一定会疯掉的。。。

3287 货车运输 2013年NOIP全国联赛提高组

时间限制: 1 s

空间限制: 128000 KB

题目等级 : 钻石 Diamond

题解

查看运行结果

题目描述 Description

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

输入描述 Input Description

第一行有两个用一个空格隔开的整数 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 Description

输出共有 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

数据范围及提示 Data Size & 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。

开始用并查集和kruskal编了个最大生成树，具体操作和原版相似度99%。。然后用树上倍增求LCA来优化两点之间的查找，开一个新的数组c【i】【j】记录从节点i跳2^j个点路径上的最小的路径权值（此题反应为路径承受重量的限度）@SLYZLZR感谢调试时的帮助orz

—————————–分割线——————————-

代码：

#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<cstring>
using namespace std;
struct data{
    int start,end,weight;
};
data road[60000]={0};
int n,m,q;
int i,j;
int num=0;//最大生成树边数
int father[50000]={0};
vector <int> g[100010];
vector <int> qz[100010];
int f[50010][40]={0};
int c[50010][40]={0};
int depth[100010]={0};
bool visit[10010]={false};

int find(int x)
{
    if (father[x]==x)
        return x;
    father[x]=find(father[x]);
    return father[x];
}//并查集查找代表元素

void merge(int x,int y,int k)
{
    int f1=find(x);
    int f2=find(y);
    if (f1!=f2)
        {
            father[f1]=f2;
            num++;
            g[x].push_back(y);
            g[y].push_back(x);
            qz[x].push_back(road[k].weight);
            qz[y].push_back(road[k].weight);
            //f[y][0]=x;
        }
}//并查集合并（上述多加的操作因为是无向图，在此处无法得知谁是谁的父亲，故要两次赋值，为接下来dfs建树做基础）

void chushi()
{
    for (int i=1; i<=n; i++)
        father[i]=i;
}//并查集初始化

int cmp(data x,data y)
{
    if (x.weight>y.weight)
        return 1;
    return 0;
}//结构体排序cmp函数

void dfs(int u)
{
    int i;
    visit[u]=true;
    for (i=0; i<g[u].size(); i++)
        {
            int v=g[u][i];
            if (!visit[v])
                {
                    depth[v]=depth[u]+1;
                    c[v][0]=qz[u][i];//处理权值的问题
                    f[v][0]=u;
                    dfs(v);
                }
        }
}//dfs建树求出每个节点的深度（算是lca的预处理吧）

void bz()
{
    int i,j;
    for (j=1;j<=30;j++)
        for (i=1;i<=n;i++)
         if (f[f[i][j-1]][j-1]!=0)
            {
                f[i][j]=f[f[i][j-1]][j-1];
                c[i][j]=min(c[i][j-1],c[f[i][j-1]][j-1]);
            }
}//倍增求出f【i】【j】和c【i】【j】

int LCA(int a,int b)
{
    int i,u=a,v=b;
    if (depth[u]<depth[v])
        {
            i=u;
            u=v;
            v=i;
        }
    int dc=depth[u]-depth[v];
    int ans=1000000000;
    for (i=0; i<30; i++)
        {
            if ((1<<i)&dc)
                {
                    ans=min(ans,c[u][i]);
                    u=f[u][i];
                }
        }
    if (u==v) return ans;
    for (i=29; i>=0; i--)
        {
            if (f[u][i]!=f[v][i])
                {
                    ans=min(min(ans,c[u][i]),c[v][i]);
                    u=f[u][i];
                    v=f[v][i];
                }
        }
    ans=min(min(ans,c[u][0]),c[v][0]);
    //u=f[u][0];
    return ans;
} //lca不过不同于平常的是此处返回的值是答案

int main()
{
    scanf("%d%d",&n,&m);
    chushi();
    for (i=0; i<=n; i++)
        g[i].clear();
    for (i=1; i<=m; i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            road[i].start=x;
            road[i].end=y;
            road[i].weight=z;
        }
    sort(road+1,road+m+1,cmp);
    for (i=1; i<=m; i++)
        {
            if (num==n-1)
                break;
            merge(road[i].start,road[i].end,i);
        }//kruskal最大生成树
        depth[1]=1;
        dfs(1);
        bz();
    scanf("%d",&q);
    for (i=1; i<=q; i++)
        {
            int now,to;
            scanf("%d%d",&now,&to);
            if (find(now)!=find(to))
                {
                    printf("-1\n");
                    continue;
                }//如果两点不能到达直接输出-1（用并查集处理即可）
            else
                printf("%d\n",LCA(now,to));
        }
  return 0;
}

累死了，晚上又要和QDEZ打模拟赛，感觉要炸。。。