hdu 4750 Count The Pairs （思维+并查集+离散化+二分查找）

Count The Pairs

Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others)

Total Submission(s): 465    Accepted Submission(s): 226

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
  
  

 

Source

2013 ACM/ICPC Asia Regional Nanjing Online

感想：

开始拿到这题，还以为是什么图论呢，完全不会做。后来听男神说是并查集，就会做了。（︶︿︶） 还是思维能力不强额，有些东西其实你已经掌握了，但是那些题你根本就分析不到那一步额。忧伤。。。要努力提高思维能力了。

思路：

突破口：每条边的权值不一样。（比赛时我就觉得有点奇怪，可惜没想到并查集额）

将边从小到大排序之后，从小到大依次加边，如果两点已经是同一个集合，则这条边没用，想一想为什么？如果两点属于不同的集合，则会产生num1*num2条有效边值。仔细想想就知道为什么了。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <string>
#include <map>
#include <stack>
#include <vector>
#include <set>
#include <queue>
//#pragma comment (linker,"/STACK:102400000,102400000")
#define maxn 500005
#define mod 1000000000
#define INF 0x3f3f3f3f
using namespace std;

int n,m,ans,q,cnt;
int pre[maxn],num[maxn];
int a[maxn],sum[maxn],disc[maxn];
struct Node
{
    int u,v,w;
}pp[maxn];

void init()
{
    int i;
    for(i=0; i<=n; i++)
    {
        pre[i]=i;
        num[i]=1;
    }
    cnt=n;
}
int Find(int x)        // 优化路径
{
    if(pre[x]==x) return x;
    pre[x]=Find(pre[x]);
    return pre[x];
}
void Merge(int u,int v,int k)    // 合并时将深度小的集合合并到大的里面
{
    int x,y;
    x=Find(u);
    y=Find(v);
    if(x!=y)
    {
        cnt--;
        pre[x]=y;
        a[k]=2*num[x]*num[y];
        num[y]+=num[x];
    }
}
bool cmp(const Node&xx,const Node&yy)
{
    return xx.w<yy.w;
}
void solve()
{
    int i,j,u,v;
    memset(a,0,sizeof(a));
    sort(pp+1,pp+m+1,cmp);
    for(i=1;i<=m;i++)
    {
        Merge(pp[i].u,pp[i].v,i);
        disc[i]=pp[i].w;
    }
    disc[m+1]=INF;
    sum[m+1]=0;
    for(i=m;i>=1;i--)
    {
        sum[i]=sum[i+1]+a[i];
    }
}
int main()
{
    int i,j,t,pos;
    while(~scanf("%d%d",&n,&m))
    {
        init();
        for(i=1;i<=m;i++)
        {
            scanf("%d%d%d",&pp[i].u,&pp[i].v,&pp[i].w);
        }
        solve();
        scanf("%d",&q);
        while(q--)
        {
            scanf("%d",&t);
            pos=lower_bound(disc+1,disc+m+1,t)-disc;  // 找到disc[]>=t的第一个位置
            printf("%d\n",sum[pos]);
        }
    }
    return 0;
}