Save your cats Aizu - 2224 （最大生成树）

题目：

Problem C:

Nicholas Y. Alford was a cat lover. He had a garden in a village and kept many cats in his garden. The cats were so cute that people in the village also loved them.

One day, an evil witch visited the village. She envied the cats for being loved by everyone. She drove magical piles in his garden and enclosed the cats with magical fences running between the piles. She said “Your cats are shut away in the fences until they become ugly old cats.” like a curse and went away.

Nicholas tried to break the fences with a hummer, but the fences are impregnable against his effort. He went to a church and asked a priest help. The priest looked for how to destroy the magical fences in books and found they could be destroyed by holy water. The Required amount of the holy water to destroy a fence was proportional to the length of the fence. The holy water was, however, fairly expensive. So he decided to buy exactly the minimum amount of the holy water required to save all his cats. How much holy water would be required?

Input

The input has the following format:

N M
x1 y1
.
.
.
xN yN
p1 q1
.
.
.
pM qM

The first line of the input contains two integers N (2 ≤ N ≤ 10000) and M (1 ≤ M). N indicates the number of magical piles and M indicates the number of magical fences. The following N lines describe the coordinates of the piles. Each line contains two integers xi and yi (-10000 ≤ xi, yi ≤ 10000). The following M lines describe the both ends of the fences. Each line contains two integers pj and qj (1 ≤ pj, qj ≤ N). It indicates a fence runs between the pj-th pile and the qj-th pile.

You can assume the following:

• No Piles have the same coordinates.
• A pile doesn’t lie on the middle of fence.
• No Fences cross each other.
• There is at least one cat in each enclosed area.
• It is impossible to destroy a fence partially.
• A unit of holy water is required to destroy a unit length of magical fence.

Output

Output a line containing the minimum amount of the holy water required to save all his cats. Your program may output an arbitrary number of digits after the decimal point. However, the absolute error should be 0.001 or less.

Sample Input 1

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

Output for the Sample Input 1

3.000

Sample Input 2

4 3
0 0
-100 0
100 0
0 100
1 2
1 3
1 4

Output for the Sample Input 2

0.000

Sample Input 3

6 7
2 0
6 0
8 2
6 3
0 5
1 7
1 2
2 3
3 4
4 1
5 1
5 4
5 6

Output for the Sample Input 3

7.236

Sample Input 4

6 6
0 0
0 1
1 0
30 0
0 40
30 40
1 2
2 3
3 1
4 5
5 6
6 4

Output for the Sample Input 4

31.000

题意：

你的猫被女巫用栅栏围住了，每一个围栏之间会有不一定数量的猫，这种栅栏只能用药水打碎，一单位的栅栏需要一单位的药水，一单位的药水需要一单位的金币（只能全部打碎，不能部分打碎），你想要解救你的猫，问最少需要多少金币去购买药水；

给你两个数字N和K，代表有N个桩子，有K对桩子之间有栅栏；

下面的N行是两个整数，代表桩子所在的位置；

下面的K行是两个整数，代表K这两个桩子之间有一道栅栏（桩子的编号从1开始）；

思路：

这道题可以看成让你去掉多少的栅栏才能够把所有的栅栏圈破坏掉，那么就可以使用最大生成树算法来解决这道题；

记得输出的格式，保留三位小数；

图需要自己构建，计算两点之间的距离；

ans = 距离总和 - 最大生成树；

代码如下：

#include<math.h>
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

const int N=10010;

struct node//存储每一条边
{
    int from;
    int to;
    double w;
} a[N*10];

struct Node
{
    int x;
    int y;
} q[N];

bool cmp(node aa,node bb)//排序
{
    return aa.w>bb.w;
}

int n,m,k,t,aa,bb;
int f[N];//存储每一个点的父亲节点

int getf(int v)//寻找父亲节点；
{
    if(f[v]==v)
        return f[v];
    else
        return f[v]=getf(f[v]);
}

void Kruskal(double sum)
{
    sort(a,a+k,cmp);//按照边的权值由小到大进行排序；
    double ans=0.0;
    int countt=1;
    for(int i=0; i<k; i++)
    {
        int t1=getf(a[i].from);
        int t2=getf(a[i].to);
        if(t1!=t2)//父亲节点不同，不会构成环路；
        {
            ans+=a[i].w;
            f[t2]=t1;//把父亲节点改成相同；
            countt++;
            if(countt==n)//如果加入n条边就可以结束了；
                break;
        }
    }
    printf("%.3lf\n",sum-ans);//总距离之和减去最大生成树；
}

double juli(int u,int v)//计算两点之间的距离；
{
    int uu=fabs(q[u].x-q[v].x);
    int vv=fabs(q[u].y-q[v].y);
    return sqrt(uu*uu+vv*vv*1.0);
}

int main()
{
    while(~scanf("%d%d",&n,&k))
    {
        double sum=0.0;
        for(int i=1; i<=n; i++)
        {
            scanf("%d%d",&q[i].x,&q[i].y);
        }
        for(int i=0; i<k; i++)
        {
            scanf("%d%d",&aa,&bb);
            double ss=juli(aa,bb);
            sum+=ss;//计算总的距离之和；
            a[i].from=aa;
            a[i].to=bb;
            a[i].w=ss;
        }
        for(int i=0; i<=N; i++) //初始化，自己的父亲节点是自己；
            f[i]=i;
        Kruskal(sum);
    }
    return 0;
}