Kruskal 并查集 最小生成树问题

 一、使用场景

一般就是给几个点、村庄等问将其所有连通的最小代价

二、解决思路

 通过结构体定义点节点，边节点；配合并、查集、以及对边长（代价）进行排序，然后按照kruskal算法进行选边构造最小生成树。

 

 三、辅助数组及sort的用法

1、辅助数组

int father[n];//记录点的父节点   辅助查找是否在一颗树 记-1为根
int hight[n];//记录点所在树的高度 辅助合并时小树并大树上


point pointList[n];//记录点
edge graph[n*n];//存放边

2、c++ 中sort用法

 （1）头文件

#include<iostream>
#include<algorithm>
using namespace std;

 

   (2)sort（pram1，pram2，pram3） 参数

各个参数代表啥意思呢？

pram1：排序起始位置

pram2：排序结束位置

pram3:排序方法的定义，可以省略不写，默认从小到大

（3）比较函数cmp定义方法 

//整型从小到大排序
bool cmp(int a ,int b){

    return a<b;
}

//整型从大到小排序
bool cmp(int a ,int b){

    return a>b;
}

 多属性排序函数又将怎么定义呢？

 

//多属性排序和整型类似
struct T{
    int x;
    int y;

};
对T按属性x从小到大排序，当x相同时按属性y从大到小排序
bool cmp(T a,T b){
    if(a.x==b.x){
        return a.y>b.y;
    }
    else{
        return a.x<b.x;
    }
}

 四、并查集

初始化时我们将每个节点的父节点都标记为-1，所在树高都标记为1；

什么是并查集？

 

1、查

定义：查找节点是否在同一颗树下；

方法：找根结点，看其根节点是否相同 

//找 根    查
int find(int x){
    if(father[x]==-1)
        return x;
    else{
        return find(father[x]);
    }
}

2、合并

定义：将在不同树下的节点合并到一颗树下

方法：将小树的根节点的父节点设置为大树的根

//合并
void Union(int x,int y){
    int fx = find(x);//找根
    int fy = find(y);
    if(fx==fy)
    return ;
    else if(hight[fx]>hight[fy]){//不在同一个树下 小树合并到大树
        father[fy]=fx;
    }else if(hight[fx]<hight[fy]){//不在同一个树下 小树合并到大树
        father[fx]=fy;
    }else{
        // 不在同一棵树，且所在树高度一样，将其中一个合并过来，高度加一
        father[fx]=fy;
        hight[fy]++;
    }
}

 五、完整示例

 

1、问题背景

有一些点的坐标，求连通这些点的最小代价

2、代码示例 

#include <cmath>
#include <iostream>
#include <algorithm>
#include <math.h>
using namespace std;

#define Max 1010

int father[Max];//记录每个点的父节点
int hight[Max];//记录树高
//定义 点
struct point{
    int x;
    int y;
};

// 定义 边
struct edge{
    int node1;//起点编号
    int node2;//终点编号
    float dist; //边长
};
//找 根    查
int find(int x){
    if(father[x]==-1)
        return x;
    else{
        return find(father[x]);
    }
}
// 不连通的进行联通 合并
void Union(int x,int y){
    int fx = find(x);//找根
    int fy = find(y);
    if(fx==fy)
    return ;
    else if(hight[fx]>hight[fy]){//不在同一个树下 小树合并到大树
        father[fy]=fx;
    }else if(hight[fx]<hight[fy]){//不在同一个树下 小树合并到大树
        father[fx]=fy;
    }else{
        // 不在同一棵树，且所在树高度一样，将其中一个合并过来，高度加一
        father[fx]=fy;
        hight[fy]++;
    }
}
point pointList[Max];//记录点
edge  graph[Max*Max];//记录各条边

// 初始化
void initial(){
    for(int i=0;i<=Max;i++){
        father[i]=-1;
        hight[i]=1;
    }
}
// 用kruskal 实现最小生成树
float kruskal(int edgeNum){//参数为边的个数
    float sum=0;//记录总代价
    for(int i=0;i<edgeNum;i++){
        edge e = graph[i];//取出最短的一条边 （对边已经排序，按顺序取即可）
        if(find(e.node1)!=find(e.node2)){//边的两个顶点未在同一树下，合并
            Union(e.node1, e.node2);
            sum+=e.dist;
        }
    }
    return sum;
}

//sort 的比较函数
bool cmp(edge a,edge b){
    return a.dist<b.dist;
}

// 计算两点距离
float dist(point a,point b){
    return sqrt(pow(a.x-b.x,2)+pow(a.y-b.y,2));
    // return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
int main() {
    int n;
    while (cin >>n) { // 注意 while 处理多个 case
        initial();
        for(int i = 0;i<n;i++){
            cin>>pointList[i].x>>pointList[i].y;
        }
        int index=0;
        for(int i=0;i<n-1;i++){
            for(int j=i+1;j<n;j++){
                point point1 = pointList[i];
                point point2 = pointList[j];
                graph[index].node1=i;
                graph[index].node2=j;
                graph[index].dist=dist(point1, point2);
                index++;
            }
        }
        // 按边长排序 边
        sort(graph,graph+index,cmp);
        // cout<<kruskal(index);
         printf("%.2f\n",kruskal(index));
    }
}
// 64 位输出请用 printf("%lld")