HDU 5441 Travel (最小生成树+离线处理)

Travel

Time Limit: 1500/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 4420    Accepted Submission(s): 1462

Problem Description

Jack likes to travel around the world, but he doesn’t like to wait. Now, he is traveling in the Undirected Kingdom. There are n cities and m bidirectional roads connecting the cities. Jack hates waiting too long on the bus, but he can rest at every city. Jack can only stand staying on the bus for a limited time and will go berserk after that. Assuming you know the time it takes to go from one city to another and that the time Jack can stand staying on a bus is x minutes, how many pairs of city (a,b) are there that Jack can travel from city a to b without going berserk?

 

Input

The first line contains one integer T,T≤5, which represents the number of test case.

For each test case, the first line consists of three integers n,m and q where n≤20000,m≤100000,q≤5000. The Undirected Kingdom has n cities and m bidirectional roads, and there are q queries.

Each of the following m lines consists of three integers a,b and d where a,b∈{1,...,n} and d≤100000. It takes Jack d minutes to travel from city a to city b and vice versa.

Then q lines follow. Each of them is a query consisting of an integer x where x is the time limit before Jack goes berserk.

 

Output

You should print q lines for each test case. Each of them contains one integer as the number of pair of cities (a,b) which Jack may travel from a to b within the time limit x.

Note that (a,b) and (b,a) are counted as different pairs and a and b must be different cities.

 

Sample Input

1 5 5 3 2 3 6334 1 5 15724 3 5 5705 4 3 12382 1 3 21726 6000 10000 13000

 

Sample Output

2 6 12

 

Source

2015 ACM/ICPC Asia Regional Changchun Online

 

Recommend

hujie   |   We have carefully selected several similar problems for you:   6297  6296  6295  6294  6293 

 

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<algorithm>
#define maxn 200010
using namespace std;
/*
对于不断输入的上界，
可以先排序处理，
然后进行遍历，遍历推进的过程也是建树的过程，
创建查询结构体和存储id均是些细节问题，
用并查集维护树和数的总结点个数，
数学思想便是在合并中答案累加两个树的点数积。




另外，这题代码过不了，，，原因不明。。。
*/
int n,m,q;
int x,y,d;
struct node
{
    int x,y,d;
    node(int x1=0,int x2=0,int x3=0)
    {
        x=x1;
        y=x2;
        d=x3;
    }
};
struct qnode//封装查询节点
{
    int id,ub;
    qnode()
    {
        id=ub=0;
    }
};
bool cmp(node x,node y)
{
    return x.d<y.d;
}
bool qcmp(qnode x,qnode y)
{
    return x.ub<y.ub;
}
node seq[100010];
qnode tmp[5050];
int num[maxn],pre[maxn],op[5050];
int xx,cnt;
int Find(int x)
{
    if(pre[x]==x) return x;
    return pre[x]=Find(pre[x]);
}
int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&n,&m,&q);
        for(int i=1;i<=m;i++) scanf("%d%d%d",&seq[i].x,&seq[i].y,&seq[i].d);
        for(int i=1;i<=q;i++) { scanf("%d",&tmp[i].ub); tmp[i].id=i; }
        memset(num,0,sizeof(num));
        memset(pre,0,sizeof(pre));
        memset(tmp,0,sizeof(tmp));
        sort(seq+1,seq+m+1,cmp);
        sort(tmp+1,tmp+q+1,qcmp);

        for(int i=1;i<=n;i++) { pre[i]=i;num[i]=1; }

         int j,pos=1,ans=0;
         for(int i=1;i<=q;i++)
         {
            for(j=pos;j<=m;j++)
            {
                if(seq[j].d>tmp[i].ub)
                {
                    pos=j;
                    break;
                }
                else
                {
                   int uu=Find(seq[i].x);
                   int vv=Find(seq[i].y);
                   if(uu!=vv)
                    {
                      pre[uu]=vv;
                      ans+=2*num[vv]*num[uu];
                      num[vv] += num[uu];
                    }
                 }
              }
            op[tmp[i].id]=ans;
            pos=j;
         }
         for(int i=1;i<=q;i++) printf("%d\n",op[i]);
    }
    return 0;
}