hdu 4750 2013 ACM/ICPC Asia Regional Nanjing Online 1003 并查集+离线操作

Count The Pairs

Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others)
Total Submission(s): 222    Accepted Submission(s): 114

Problem Description

  With the 60th anniversary celebration of Nanjing University of Science and Technology coming soon, the university sets n tourist spots to welcome guests. Of course, Redwood forests in our university and its Orychophragmus violaceus must be recommended as top ten tourist spots, probably the best of all. Some undirected roads are made to connect pairs of tourist spots. For example, from Redwood forests (suppose it’s a) to fountain plaza (suppose it’s b), there may exist an undirected road with its length c. By the way, there is m roads totally here. Accidently, these roads’ length is an integer, and all of them are different. Some of these spots can reach directly or indirectly to some other spots. For guests, they are travelling from tourist spot s to tourist spot t, they can achieve some value f. According to the statistics calculated and recorded by us in last years, We found a strange way to calculate the value f:
  From s to t, there may exist lots of different paths, guests will try every one of them. One particular path is consisted of some undirected roads. When they are travelling in this path, they will try to remember the value of longest road in this path. In the end, guests will remember too many longest roads’ value, so he cannot catch them all. But, one thing which guests will keep it in mind is that the minimal number of all these longest values. And value f is exactly the same with the minimal number.
  Tom200 will recommend pairs (s, t) (start spot, end spot points pair) to guests. P guests will come to visit our university, and every one of them has a requirement for value f, satisfying f>=t. Tom200 needs your help. For each requirement, how many pairs (s, t) you can offer?

 

Input

  Multiple cases, end with EOF.
  First line:n m
  n tourist spots ( 1<n<=10000), spots’ index starts from 0.
  m undirected roads ( 1<m<=500000).

  Next m lines, 3 integers, a b c
  From tourist spot a to tourist spot b, its length is c. 0<a, b<n, c(0<c<1000000000), all c are different.

  Next one line, 1 integer, p (0<p<=100000)
  It means p guests coming.

  Next p line, each line one integer, t(0<=t)
  The value t you need to consider to satisfy f>=t.

 

Output

  For each guest's requirement value t, output the number of pairs satisfying f>=t.
  Notice, (1,2), (2,1) are different pairs.

 

Sample Input

  
  

   
   2 1
0 1 2
3
1
2
3
3 3
0 1 2
0 2 4
1 2 5
5
0 
2
3
4
5
  
  

 

Sample Output

  
  

   
   2
2
0
6
6
4
4
0
  
  

 

   题目大意是对于任意两个点S,T,此时考虑每一条从S->T 的路径，然后取该路径的最大路段值，对于所有这些路径得到的取值的最小值作为 S->T 的 F 值。

   这里题目给出很多t，让求F>=T的点对数。

   思路是考虑反面，就是用总对数减去F<t的对数。

   对于 F < t的点对，其实就是至少存在一条由小于t长度的边构成的路径，因为如果不存在，此时所有路径的最大路段值肯定大于等于t，从而F>=t。

   所以我们把问题先收集起来，然后从t值小的问题开始，每次将小于当前问题t的边加入图中，然后回答当前问题即可，其中用并查集来判断连通性和计算连通区域节点数目。

   每个连通区域内节点数目任意 两点都是符合的点，因此，便可以轻松计算。

  下面上代码：

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn=10010;
int pre[maxn];
int n,m,q;
int sum[maxn];
struct enode
{
    int u,v,len;
    friend bool operator <(const enode& a,const enode& b)
    {
        return a.len<b.len;
    }
}edge[500010];
struct qnode
{
    int len,id;
    friend bool operator <(const qnode& a,const qnode& b)
    {
        return a.len<b.len;
    }
}qq[100010];
int ans[100010];
void init()
{
    for (int i=0;i<n;i++) pre[i]=i,sum[i]=1;
}
int findx(int x)
{
    return pre[x]=(pre[x]==x?x:findx(pre[x]));
}
int main()
{
    int i,j,s,t;
    int ttt,mmm;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init();
        mmm=n*(n-1);
        for (i=0;i<m;i++)
        {
            scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].len);
        }
        sort(edge,edge+m);
        scanf("%d",&q);
        for (i=0;i<q;i++)
        {
            scanf("%d",&qq[i].len);
            qq[i].id=i;
        }
        sort(qq,qq+q);
        ttt=0;
        for (i=0,j=0;i<q;i++)
        {
            for (;j<m&&edge[j].len<qq[i].len;j++)
            {
                s=findx(edge[j].u);t=findx(edge[j].v);
                if (s!=t)
                {
                    ttt-=sum[s]*(sum[s]-1);
                    ttt-=sum[t]*(sum[t]-1);
                    pre[s]=t;
                    sum[t]+=sum[s];
                    ttt+=sum[t]*(sum[t]-1);
                }
            }
            ans[qq[i].id]=mmm-ttt;
        }
        for (i=0;i<q;i++) printf("%d\n",ans[i]);

    }
    return 0;
}