Save your cat （Aizu 2224 并查集）

Save your cat

Time Limit:8000MS     Memory Limit:65536KB     64bit IO Format:%lld & %llu

Submit Status

Description

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_Ny_N

p₁q₁

.

.

.

p_Mq_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 Mindicates the number of magical fences. The following N lines describe
the coordinates of the piles. Each line contains two integers x_i andy_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

题意：有N个木桩M个栅栏，栅栏连接木桩，现在这些栅栏围成的封闭空间里有至少一只猫，要求破环若干个栅栏救出猫，问破环栅栏的最小长度。

思路：并查集，我也是参考了别人的思想，首先将边存在结构体edge里面，按照边长从大到小排序，然后遍历M条边，当加入某条边时，若两个端点的father值不同，则修改father[x]，添加到同一个集合里；设想当加人某一条边时，它的两个端点的father值相同，则加入这条边将形成一个封闭空间（题目中说栅栏不会相交错），那么要打破这个封闭空间就是将这条边破环就行了。

代码：

#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 10000+10
#define MAXN 2005
#define mod 1000000009
#define INF 0x3f3f3f3f
#define pi acos(-1.0)
#define eps 1e-6
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r
typedef long long ll;
using namespace std;

struct Edge
{
    int u,v;
    double dis;
}edge[maxn*maxn/2];

int N,M;
int father[maxn];
double x[maxn],y[maxn];

int cmp(Edge x,Edge y)
{
    return x.dis>y.dis;
}

void init(int n)
{
    for (int i=1;i<=n;i++)
        father[i]=i;
}

int find_father(int x)
{
    if (x!=father[x])
        father[x]=find_father(father[x]);
    return father[x];
}

double Kruskal()
{
    double s=0;
    for (int i=0;i<M;i++)
    {
        int fu=find_father(edge[i].u);
        int fv=find_father(edge[i].v);
        if (fu!=fv)
        {
            father[fu]=fv;
            s+=edge[i].dis;     //不需要破环的边的长度之和
        }
    }
    return s;
}

int main()
{
    while (~scanf("%d%d",&N,&M))
    {
        init(N);
        for (int i=1;i<=N;i++)
            scanf("%lf%lf",&x[i],&y[i]);
        int u,v;
        double sum=0.0;
        for (int i=0;i<M;i++)
        {
            scanf("%d%d",&u,&v);
            edge[i].u=u;
            edge[i].v=v;
            edge[i].dis=sqrt( (x[u]-x[v])*(x[u]-x[v])+(y[u]-y[v])*(y[u]-y[v]) );
            sum+=edge[i].dis;       //sum存下所有边的长度之和
        }
        sort(edge,edge+M,cmp);
        printf("%.3f\n",sum-Kruskal());
    }
    return 0;
}