Count The Pairs(hdu-4750)(最小生成树)

最新推荐文章于 2020-12-04 20:29:42 发布

ZX_zengxi

最新推荐文章于 2020-12-04 20:29:42 发布

阅读量449

点赞数

分类专栏：并查集文章标签：并查集最小生成树

本文链接：https://blog.youkuaiyun.com/ZX_zengxi/article/details/76732308

版权

并查集专栏收录该内容

3 篇文章

订阅专栏

本文介绍了一种利用最小生成树解决特定图论问题的方法，该问题涉及寻找多个点间路径上的最大边权值，并统计满足特定条件的点对数量。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Count The Pairs

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

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

Sample Output

Source

2013 ACM/ICPC Asia Regional Nanjing Online

题意理解：就是有两个点，他们会有很多条路径可以到达，我要找的是每条线路里最长的一条边，里面最小的。这个就会作为两个点之间的值，然后会输入一些询问值，就是问有多少对点之间的值，大于等于这个要询问的值。

解题思路：这一开始真的毫无头绪，别人给我说这是最小生成树的时候，我也是一脸懵逼，根本不知道怎么和最小生成树联系上，想了很久，终于想通了。最小生成树的算法就是从最小的权值开始，逐渐连成一棵树，当出现两个集需要连成一个集合时，那个连接的边，就是这两个集合的点与点之间的值，就是我们需要比较的值，因为他一定是，目前两边的点相连必经的边，那么也就是最大边，无论怎样两边点的最大边都是这条边。那么也就是最大里最小的了。

#include<stdio.h>
#include<algorithm>
#include<map>
#include<string.h>
using namespace std;
struct s{
    int u;
    int v;
    int val;
}a[500010];
int pre[10100];
int num[10010];
int find_(int x)  //并查集
{
    int r=x;
    while(pre[r]!=r)
    {
        r=pre[r];
    }
    int t=x,y;
    while(pre[t]!=r)   //路径压缩
    {
        y=pre[t];
        pre[t]=r;
        t=y;
    }
    return r;
}
int cmp(s x,s y)
{
    return x.val<y.val;
}
long long sum[10100];
int  oo[10100];
int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(a,0,sizeof(a));
        for(int i=0;i<=n;i++)
        {
            pre[i]=i;
            num[i]=1;
        }
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&a[i].u,&a[i].v,&a[i].val);
        }
        sort(a,a+m,cmp);
        int len=0;
        for(int i=0;i<m;i++)
        {
             int y1=find_(a[i].u);
             int y2=find_(a[i].v);
             if(y1!=y2)
             {
                 pre[y1]=y2;
                 sum[len]=(long long )num[y1]*num[y2]*2;  //把当前两个集合的元素乘起来，就是有多少条路径都是这条边相连
                 oo[len]=a[i].val;
                 len++;
                 num[y2]=num[y1]+num[y2];  
             }
        }
        for(int i=1;i<len;i++)
        {
            sum[i]+=sum[i-1];    //将刚才所求累加起来
        }
        int q;
        scanf("%d",&q);
        for(int i=0;i<q;i++)
        {
            int p;
            scanf("%d",&p);
            int x=lower_bound(oo,oo+len,p)-oo-1;  //二分求到第一个大于等于p的在数组里的位置
            printf("%I64d\n",sum[len-1]-sum[x]);
        }
    }
}