JZOJsenior3534、luoguP1967.【NOIP2013提高组day1】货车运输

problem

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

Data Constraint

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

---

analysis

• 正解为树上倍增或树链剖分

• 但这题我用的还是树剖大法——

• 可以容易看出，我们先要求这图的最大生成树，然后再用树剖维护点权最小值

• 然后这不就是一道裸题？！

树剖大法好啊

---

code

#include<bits/stdc++.h>
#define MAXN 10001
#define MAXM 50001

using namespace std;

int last[2*MAXM],next[2*MAXM],tov[2*MAXM],dis[2*MAXM];
bool visited[MAXN],flag[MAXM]; 
int to_num[MAXN],father[MAXN],tree[4*MAXN];
int n,m,q,tot,total;

struct array
{
    int x,y,z;
}dist[2*MAXM];

struct information
{
    int depth,father,size,heavy_son,top,to_tree,value;
}a[MAXN];

bool cmp(array a,array b)
{
    return a.z>b.z;
}

int min(int x,int y)
{
    return x<y?x:y;
}

int getfather(int x)
{
    if (father[x]==0)return x;
    return father[x]=getfather(father[x]);
}

void insert(int x,int y,int z)
{
    next[++tot]=last[x];
    last[x]=tot;
    tov[tot]=y;
    dis[tot]=z;
}

void dfs1(int x,int father)
{
    visited[x]=0;
    a[x].size=1;
    int mx=-1;
    for (int i=last[x];i;i=next[i])
    {
        int j=tov[i];
        if (j!=father)
        {
            if (visited[j]==0)
            {
                a[j].value+=dis[i];
                continue;
            }
            a[j].depth=a[x].depth+1;
            a[j].value=dis[i];
            a[j].father=x;
            dfs1(j,x);
            a[x].size+=a[j].size;
            if (a[j].size>mx)
            {
                a[x].heavy_son=j;
                mx=a[j].size;   
            } 
        }
    }
}

void dfs2(int x,int top)
{
    if (x==0)return;
    a[x].top=top;
    a[x].to_tree=++total;
    to_num[total]=x;
    dfs2(a[x].heavy_son,top);
    for (int i=last[x];i;i=next[i])
    {
        int j=tov[i];
        if (j!=a[x].father && j!=a[x].heavy_son && j!=0)
        {
            dfs2(j,j);
        }
    }
}

void maketree(int t,int l,int r)
{
    if (l==r)
    {
        tree[t]=a[to_num[l]].value;
        return;
    }
    int mid=(l+r)/2;
    maketree(2*t,l,mid),maketree(2*t+1,mid+1,r);
    tree[t]=min(tree[2*t],tree[2*t+1]);
}

int tree_query_min(int t,int l,int r,int x,int y)
{
    if (l==x && y==r)
    {
        return tree[t];
    }
    int mid=(l+r)/2;
    if (y<=mid)
    {
        return tree_query_min(t*2,l,mid,x,y);
    }
    else if (x>mid)
    {
        return tree_query_min(t*2+1,mid+1,r,x,y);
    }
    else
    {
        return min(tree_query_min(t*2,l,mid,x,mid),tree_query_min(t*2+1,mid+1,r,mid+1,y));
    }
}

int query_min(int x,int y)
{
    int temp=1000000007;
    while (a[x].top!=a[y].top)
    {
        if (a[a[x].top].depth>a[a[y].top].depth)
        {
            temp=min(temp,tree_query_min(1,1,n,a[a[x].top].to_tree,a[x].to_tree));
            x=a[a[x].top].father;   
        }
        else
        {
            temp=min(temp,tree_query_min(1,1,n,a[a[y].top].to_tree,a[y].to_tree));
            y=a[a[y].top].father;
        }
    } 
    if (x==y)return temp;
    if (a[x].depth<a[y].depth)
    {
        return min(temp,tree_query_min(1,1,n,a[a[x].heavy_son].to_tree,a[y].to_tree));
    }
    else
    {
        return min(temp,tree_query_min(1,1,n,a[a[y].heavy_son].to_tree,a[x].to_tree));
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&dist[i].x,&dist[i].y,&dist[i].z);
    }
    sort(dist+1,dist+m+1,cmp);
    for (int i=1;i<=m;i++)
    {
        int u=dist[i].x,v=dist[i].y,w=dist[i].z;
        if (getfather(u)!=getfather(v))
        {
            father[getfather(u)]=v;
            insert(u,v,w),insert(v,u,w);
            flag[i]=1;
        }
    }
    memset(visited,1,sizeof(visited));
    for (int i=1;i<=n;i++)
    if (visited[i])
    {
        a[i].depth=1;
        a[i].father=0;
        dfs1(i,0),dfs2(i,i);
    }
    maketree(1,1,n);
    memset(father,0,sizeof(father));
    for (int i=1;i<=m;i++)
    if (flag[i])
    {
        int u=dist[i].x,v=dist[i].y;
        father[getfather(u)]=getfather(v);
    }
    scanf("%d",&q);
    while (q--)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        if (getfather(x)==getfather(y))
        {
            printf("%d\n",query_min(x,y));
        }
        else printf("-1\n");
    }
    return 0;
}