分别采用prim算法与kruskal算法构造最小生成树（第一次作业）

分别采用prim算法与kruskal算法构造最小生成树

1.问题
举一个实例，画出采用Prim算法构造最小生成树的过程，并按实验报告模板编写算法。
举一个实例，画出采用Kruskal算法构造最小生成树的过程，并按实验报告模板编写算法。

有n个村庄需要修通道路，已知每两个村庄之间的距离，问怎么修路，使得所有村庄都连通（但不一定有直接的公路相连，只要能间接通过公路到达即可），并且道路总长度最小？请计算最小的公路总长度。

2.解析
令一张连通图的点集为V，未标记的点集合为V1；
V1 = V;
Prim算法的核心思想就是先在V中随意取一个点p并标记p，然后找出与p相连的最短边（是最小生成树的一部分），令这条边的另一个端点为q，我们标记q，然后同理找已经标记的点的未找到的最短边。最后得到的这些边构成了最小生成树。（下图为先取d点）

Kruskal算法的核心就是将两两点之间的距离进行升序排序，然后依次取出边加入到最小生成树中，但是每次加入前都应判断加入该边之后是否会生成环，若会则舍去这条边。当加入的边的数量为|V| - 1时最小生成树完成。

3.设计
Prim算法：利用优先队列优化获取满足条件的最短边，新的点加入后将新的边入队。
Kruskal算法：以边长为关键词进行升序排序，取出最短边，对两个端点进行并查集查找父亲结点，判断是否成环。
Prim:

#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#include<cstdlib>
using namespace std;

const int maxn = 1e4 + 10;

struct Node{ // 定义端点结构体
	int id, dist;
	Node(int id, int dist):id(id), dist(dist){}
	bool operator<(const Node & tmp)const{//重载<使其升序排序
		return tmp.dist < dist;
	}
};
int n, m, vis[maxn] = {0};//点数、边数、标记数组
vector<Node>graph[maxn];//记录图
int Prim(int st){
	int cnt = 0, res = 0;//边的数量、最小生成树结果
	priority_queue<Node>q;//定义优先队列进行优化获取最小边
    q.push(Node(st, 0));//起点入队
    while(!q.empty()){
        int v = q.top().id;
        int w = q.top().dist;
        q.pop();
        if(vis[v] == 1)continue;//判断该点有无被标记
        vis[v] = 1;
        res += w;
        for(int i = 0; i < graph[v].size(); i++){//将其所有领点且未被标记入队。
            if(vis[graph[v][i].id] == 1)continue;
            q.push(Node(graph[v][i].id, graph[v][i].dist));
        }
    }

	return res;
}

int main(){
	scanf("%d %d", &n, &m);
	for(int i = 0; i < m; i++){
		int u, v, w;
		scanf("%d %d %d", &u, &v, &w);
		graph[u].push_back(Node(v, w));
		graph[v].push_back(Node(u, w));
	}
	printf("%d\n", Prim(1));
	system("pause");
	return 0;
}

Kruskal:

#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#include<cstdlib>
using namespace std;

const int maxn = 1e4 + 10;

struct Edge{//定义边的结构体
    int u, v, w;
    Edge(){}
    Edge(int u, int v, int w):u(u), v(v), w(w){}
    bool operator<(Edge tmp){//重载小于号进行升序排序
        return w < tmp.w;
    }
}e[maxn];

int n, m, fa[maxn];

void init(){//初始化
    for(int i = 1; i <= n; i++)fa[i] = i;
}

int Find(int x){//查找父亲结点
    return x == fa[x] ? x : fa[x] = Find(fa[x]);
}

void Union(int x, int y){//合并
    int fx = Find(x);
    int fy = Find(y);
    fa[fx] = fy;
}

int Kruskal(){
    int cnt = 0, res = 0;
    init();
    sort(e, e + m);
    for(int i = 0; i < m; i++){
        if(Find(e[i].u) != Find(e[i].v)){//用并查集判断是否成环
            Union(e[i].u, e[i].v);
            cnt++;
            res += e[i].w;
        }
        if(cnt == n - 1)break;
    }
    return res;
}

int main(){
    scanf("%d %d", &n, &m);
    for(int i = 0; i < m; i++){
        int u, v, w;
        scanf("%d %d %d", &u, &v, &w);
        e[i] = Edge(u, v, w);
    }
    printf("%d\n", Kruskal());
    system("pause");
    return 0;
}

4.分析
Prim算法遍历了每一个点，符合条件的点进行判断是否有符合条件的边，其中用优先队列优化了获取最短边的操作，时间复杂度为ELogV，空间复杂度为 n * n。
Kruskal算法对边进行了排序，又进行了并查集操作，时间复杂度为 ELogE + E。

5.github地址
Prim
Kruskal