【最小生成树】 --Kruskal算法 poj2031

题目来源：poj 2031

思路：

依次计算两个球体球心之间的距离，如果距离小于或者等于两个球体半径的大小，则设两个球体的距离为0。否则为两个球体球心的距离减去两个球体半径之和。

#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
const int maxn = 100;
const int maxm = 5100;
struct edge
{
    int u, v;
    double w;
    edge() {}
    edge(int _u, int _v, double _w) : u(_u), v(_v), w(_w) {}
} E[maxm];

struct node
{
    double x, y, z;
    double r;
} V[maxn];

bool cmp(edge e1, edge e2)
{
    return e1.w < e2.w;
}

//并查集部分
int father[maxn];

int find(int x)
{
    if (x == father[x])
    {
        return x;
    }
    else
    {
        int F = find(father[x]);
        father[x] = F;
        return F;
    }
}

//kruskal部分
double kruskal(int n, int m)
{
    double ans = 0;              //所求边权之和
    int num_edge = 0;            //当前生成树包含的边的数目
    for (int i = 0; i < n; i++) //并查集初始化，顶点编号范围是[1,n]!!!
    {
        father[i] = i;
    }
    sort(E, E + m, cmp);
    for (int i = 0; i < m; i++)
    {
        int faU = find(E[i].u);
        int faV = find(E[i].v);
        if (faU != faV)
        {
            father[faU] = faV; //合并集合，即把测试边加入最小生成树中
            num_edge++;
            ans += E[i].w;
            if (num_edge == n - 1)
            {
                break;
            }
        }
    }
    if (num_edge != n - 1)
    {
        return 0; //无法连通时返回0
    }
    else
    {
        return ans;
    }
}

double dist(node n1, node n2)
{
    return sqrt((n1.x - n2.x) * (n1.x - n2.x) + (n1.y - n2.y) * (n1.y - n2.y) + (n1.z - n2.z) * (n1.z - n2.z));
}

int main()
{
    int n;
    while (cin >> n && n != 0)
    {
        for (int i = 0; i < n; i++)
        {
            cin >> V[i].x >> V[i].y >> V[i].z >> V[i].r;
        }
        int count = 0;
        for (int i = 0; i < n; i++)
        {
            for (int j = i + 1; j < n; j++)
            {
                double dis = dist(V[i], V[j]);
                if (dis <= V[i].r + V[j].r)
                {
                    E[count++] = edge(i, j, 0);
                }
                else
                {
                    E[count++] = edge(i, j, dis - V[i].r - V[j].r) ;
                }
            }
        }
        printf("%.3f\n", kruskal(n, count));
    }
    return 0;
}