Save your cats Aizu - 2224（并查集求最大生成树）

Save your cats

Aizu - 2224

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
x₁ y₁
.
.
.
x_N y_N
p₁ q₁
.
.
.
p_M q_M

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 x_i and y_i (-10000 ≤ x_i, y_i ≤ 10000). The following M lines describe the both ends of the fences. Each line contains two integers p_j and q_j (1 ≤ p_j, q_j ≤ N). It indicates a fence runs between the p_j-th pile and the q_j-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

题意：给你一个图，这个图形成封闭区域（可能多个可能一个可能没有），问最少需要破坏多少边使得封闭区域不封闭。题目先给了你每个点的坐标，然后给你边的关系

思路：这个题因为封闭区域可能一个可能多个可能没有，所以正向思维去做这个题会比较复杂，这样我们就想，如果我们把一些边破坏掉之后，得到的图不在存在封闭区域，那么
破坏边之后得到的图就是一棵树，那么我们可以得到，总的边长度之和 = 我们要破坏的长度 + 破坏完后剩下的树的边的总长度，那么既然我们希望我们破坏的长度尽可能的小，
那么我们只需要让得到的树尽可能的大就可以了，这样问题就转化成了求一棵最大生成树，用并查集来做，这样这个问题就很简单了。
code：
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
struct node{
    double x,y;
}ver[10010];
struct Edge{
    int u,v;
    double l;
}e[1000000];
int n,m;
int pre[10010];
int Find(int x){
    if(x == pre[x])
        return x;
    else return pre[x] = Find(pre[x]);
}
int Union(int x,int y){
    int fx = Find(x),fy = Find(y);
    if(fx == fy)
        return 0;
    else{
        pre[fy] = fx;
        return 1;
    }
}
bool cmp(Edge a,Edge b){
    return a.l > b.l;
}
int main(){
    int i,j;
    cin >> n >> m;
    for(i = 0; i < 10010; i++)
        pre[i] = i;
    for(i = 1; i <= n; i++){
        cin >> ver[i].x >> ver[i].y;
    }
    double allsum = 0.0;
    for(i = 0; i < m; i++){
        int u,v;
        double len;
        cin >> u >> v;
        len = sqrt((ver[u].x-ver[v].x)*(ver[u].x-ver[v].x)+(ver[u].y-ver[v].y)*(ver[u].y-ver[v].y));
        e[i].u = u;
        e[i].v = v;
        e[i].l = len;
        allsum += len;
    }
    //cout << allsum << endl;
    sort(e,e+m,cmp);
    double sum = 0.0;
    int num = 0;
    for(i = 0; i < m; i++){
        if(Union(e[i].u,e[i].v)){
            sum += e[i].l;
            num++;
        }
        if(num == n-1)
            break;
    }
    //cout << sum << endl;
    printf("%.3f\n",allsum-sum);
    return 0;
}