Aizu - 2224

Save your cats

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_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 Nlines 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

总长度减去最大生成树长度，因为如果连通再加一条边一定封闭，即可求出最小长度
因为要删除所有圈的某条边，这样的话，就是破坏掉了所有的圈，只剩下了连接着1、2、3、4……N的一条路径。。这样的话， 也就是：M条边 － 某些边　＝　连接着1、2、3、4……N的路径。。那么我们会发现，如果连接着1、2、3、4……N的路径的边的总权值最大的话， 删掉的边的权值就最小，因为M条边的总权值是确定的。。那么问题就转化成了， 求1、2、3、4……N的最大生成树。。由于1－N这些点不一定连通，所以不能用prim算法， 可以用kruskal。


#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
const int N = 1000100;
struct node
{
    int l, r;
    double cost;
}p[N];
double  x[N], y[N];
int f[N];
int Find(int x);
int merg(int a,int b);
int cmp(node a,node b)
{
    return a.cost>b.cost;
}




int main()
{
    int n, m;
    while(scanf("%d %d", &n, &m)!=EOF)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%lf %lf", &x[i], &y[i]);
        }
        double s=0;
        for(int i=0;i<m;i++)
        {
            scanf("%d %d", &p[i].l, &p[i].r);
            int a=p[i].l ,b=p[i].r;
            p[i].cost=sqrt((x[a]-x[b])*(x[a]-x[b])+(y[a]-y[b])*(y[a]-y[b]));
            s+=p[i].cost;
        }
        for(int i=1;i<=n;i++)
        {
            f[i]=i;
        }
        sort(p,p+m,cmp);
        double sum=0;
        for(int i=0;i<m;i++)
        {
            if(!merg(p[i].l,p[i].r))
            {
                sum+=p[i].cost;
            }
        }
        printf("%.3f\n",s-sum);
    }
    return 0;
}




int merg(int a,int b)
{
    int t1=Find(a);
    int t2=Find(b);
    if(t1!=t2)
    {
        f[t2]=t1;
        return 0;
    }
    return 1;
}




int Find(int x)
{
    if(x==f[x])
    {
        return x;
    }
    else
    {
        f[x]=Find(f[x]);
        return f[x];
    }
}