hdu1162(最小生成树 prim or kruscal模板)

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1162

意义：给出一些点，用线问使所有点直接或间接连通，需要多长；

思路：裸最小生成树；

法1：

prim算法：MST（Minimum Spanning Tree，最小生成树）问题有两种通用的解法，Prim算法就是其中之一，它是从点的方面考虑构建一颗MST，大致思想是：设图G顶点集合为U，首先任意选择图G中的一点作为起始点a，将该点加入集合V，再从集合U-V中找到另一点b使得点b到V中任意一点的权值最小，此时将b点也加入集合V；以此类推，现在的集合V={a，b}，再从集合U-V中找到另一点c使得点c到V中任意一点的权值最小，此时将c点加入集合V，直至所有顶点全部被加入V，此时就构建出了一颗MST。因为有N个顶点，所以该MST就有N-1条边，每一次向集合V中加入一个点，就意味着找到一条MST的边。（这短话复制的别人的，感觉写的蛮好的）

prim算法就是从待选点集中依次选出距离已选点集中距离最小的点加入已选点集中；

代码：

#include <iostream>
#include <math.h>
#include <algorithm>
#include <string.h>
#include <stdio.h>
#define MAXN 100+10
#define INF 9999999999
using namespace std;

int n, tag[MAXN];
double mp[MAXN][MAXN], low[MAXN];

double prime(void){
    memset(tag, 0, sizeof(tag));  //×××标记数组清 0
    int s=1;
    double cnt=0;
    for(int i=1; i<=n; i++){   //×××从点 1 开始
        low[i]=mp[s][i];
    }
    for(int i=2; i<=n; i++){
        double min=INF;
        for(int j=2; j<=n; j++){  //×××找到未添加点中到以添加点中距离最近的点即当前要添加的点
            if(!tag[j]&&min>low[j]){
                min=low[j];
                s=j;
            }
        }
        cnt+=min;      //***本题中不存在不能连同的情况，所以不需要加 if(min>=INF) return -1
        tag[s]=1;
        for(int j=2; j<=n; j++){
            if(!tag[j]&&low[j]>mp[s][j]){  //×××更新low数组
                low[j]=mp[s][j];
            }
        }
    }
    return cnt;
}

int main(void){
    while(~scanf("%d", &n)){
        pair<double, double> p[MAXN];
        for(int i=1; i<=n; i++){
            scanf("%lf%lf", &p[i].first, &p[i].second);
        }
        for(int i=1; i<=n; i++){
            for(int j=1; j<=n; j++){
                mp[i][j]=sqrt((p[j].first-p[i].first)*(p[j].first-p[i].first)+(p[j].second-p[i].second)*(p[j].second-p[i].second));
            }
        }
        double ans=prime();
        printf("%.2lf
", ans);
    }
    return 0;
}

法2：

kruscal算法：

将图中边按其权值由小到大的次序顺序选取,若选边后不形成回路,则保留作为一条边,若形成回路则除去.依次选够(n-1)条边,即得最小生成树.(n为顶点数)

代码：

#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <math.h>
#define MAXN 10000+10
using namespace std;

struct node{
    int x, y;
    double weight;
}map[MAXN];

int m, n, pre[MAXN];

bool cmp(node a, node b){
    return a.weight < b.weight;
}

int find(int x){
    while(pre[x]!=x){
        x=pre[x];
    }
    return x;
}

double join(node a){
    int px=find(a.x);
    int py=find(a.y);
    if(px!=py){
        pre[px]=py;
        return a.weight;
    }else{
        return 0;   //××××若成环则返回 0
    }
}

double kruskal(void){
    for(int i=1; i<=n; i++){
        pre[i]=i;
    }
    double cnt=0;
    sort(map, map+m, cmp);
    for(int i=0; i<m; i++){
        cnt+=join(map[i]);
    }
    return cnt;
}

int main(void){
    while(~scanf("%d", &n)){
        pair<double, double> p[MAXN];
        for(int i=1; i<=n; i++){
            scanf("%lf%lf", &p[i].first, &p[i].second);
        }
        int k=0;
        for(int i=1; i<=n; i++){
            for(int j=i+1; j<=n; j++){
                double cnt=sqrt((p[i].first-p[j].first)*(p[i].first-p[j].first)+(p[i].second-p[j].second)*(p[i].second-p[j].second));
                map[k].x=i;
                map[k].y=j;
                map[k].weight=cnt;
                k++;
            }
        }
        m=k;
        double ans=kruskal();
        printf("%.2lf
", ans);
    }
    return 0;
}