最小生成树-Prim和Kruskal算法实现

最小生成树实现

约定

只考虑连通图。

边的权重可以为负数或者是0。

原理

用一条边连接树中的任意的两个顶点都会产生一个新的环。

从树中删去一条边会得到两个独立的树。

切分：图的一种切分是将图中所有的顶点分为两个非空且不重叠的两个集合。

横切：便是一条连接两个属于不同集合的顶点的边。

切分定理：在一幅加权图中，给定任意的切分，它的横切边中的最小权重者必然属于图中的最小生成树。

在假设所有的边的权重均不相同的情况下，每一幅连通图都只有一颗唯一的最小生成树。

切分定理表明对于每一种的切分，权重最小的横切边必然属于最小生成树。

贪心：切分定理是解决最小生成树的基础。

Prim算法

在这里只需要存边，不管结点的事。或许换句话说，就是现在边才是“上司”，谁还管小职员呢
主要是通过三步筛选得到一个关于选择的最小生成树的边集add_e。

#include <bits/stdc++.h>
using namespace std;

struct Edge {
	int u;
	int v;   //与该边相连的两个结点
	double w;//该边的权值
	
	bool operator<(const Edge&a)const{
		return w>a.w;
	}
};

int node, edge;
int vis[100000] = {0}; //结点数组,查看是否走过
//三步筛选
vector<Edge>all_e;//存全部的边
priority_queue<Edge>vis_e;//这个是最小生成树的"candidates"
queue<Edge>add_e;//对于已经加入最小生成树中的边是不动的

void Visit() {
	cout << "共有多少结点?";
	cin >> node;
	cout << endl << "共有多少边？";
	cin >> edge;

	for (int i = 0; i < edge; i++) {
		Edge a;
		//输入格式为：起点-终点-权值
		cin >> a.u >> a.v >> a.w;
		all_e.push_back(a);
	}
}

void add(int start) { //把与该结点有关的边全部加入优先队列
	vis[start] = 1;
	for (int i = 0; i < all_e.size(); i++) {
		if (all_e[i].u == start || all_e[i].v == start)vis_e.push(all_e[i]);
	}
}

void Prim(int start) { //起始节点
	add(start);
	while (!vis_e.empty()) {
		Edge a = vis_e.top();
		vis_e.pop();
		if (vis[a.u] && vis[a.v])continue;//说明会构成环
		else add_e.push(a);//不然就加入最小生成树
		if (!vis[a.u]) add(a.u);//把另外一个结点相连的所有边加入候选人
		if (!vis[a.v]) add(a.v);
	}
}

void Show() { //已经得到了最小生成树的所有边，输出
	while (!add_e.empty()) {
		Edge a = add_e.front();
		add_e.pop();
		cout << a.u << " " << a.v << " " << a.w << endl;
	}
}

int main() {
	int s;
	Visit();//获得所有存在的边
	cout << "选定开始的起点：";
	cin >> s;
	Prim(s);
	Show();
	return 0;
}

过的洛谷板子题P3366

上述的并不能直接套到这个题里面，然后还T了8 9 10三个点。
需要进行一些优化。
显然，需要进行一个大修的操作。【已经修改完毕】
结论：基本上是和原来的代码完全不同了。使用了链式前向星+堆优化。（是一个类似Dijkstra算法算最短路径的操作）

#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647; //2^31-1
const int MAXN = 6000006;

struct Edge {
	int to;//终点
	int w;//权值
	int next;//实际上是上一点
};

struct Node {
	int node;//编号
	int cost;

	bool operator<(const Node &a)const {
		return cost > a.cost;
	}
};

int node, edge, cnt = 1;
int vis[100000] = {0}; //结点数组
Edge edgeTo[MAXN];//与父节点
int head[MAXN];
int dis[MAXN];//得到父节点到其他点的最短路径

void init() {
	for (int i = 0; i < node; i++)head[i] = -1;
}

void add(int from, int to, int w) {
	edgeTo[cnt].to = to;
	edgeTo[cnt].w = w;
	edgeTo[cnt].next = head[from]; //起始：next=-1;类似头插法，指针操作
	head[from] = cnt++; //起点的第一条边指向cnt
}

void Visit() {
	int u, v, w;
	init();
	cin >> node >> edge;

	for (int i = 0; i < edge; i++) {
		//输入格式为：起点-终点-权值
		cin >> u >> v >> w;
		add(u, v, w);
		add(v, u, w);
	}
}

int Prim(int start) { //起始节点
	for (int i = 1; i <= node; i++)dis[i] = INF;//初始化
	dis[start] = 0;
	int cnt_node = 0, sum = 0;

	priority_queue<Node>q;
	q.push(Node{start, 0});
	while (!q.empty()) {
		int u = q.top().node;
		q.pop();
		if (!vis[u]) {
			vis[u] = 1;
			cnt_node++;
			sum += dis[u];
			dis[u] = 0; //并入集合内部，因此dis=0
			for (int i = head[u]; i; i = edgeTo[i].next) {
				int &t = edgeTo[i].to;
				if (!vis[t] && dis[t] > dis[u] + edgeTo[i].w) {
					dis[t] = dis[u] + edgeTo[i].w;
					q.push(Node{t, dis[t]});
				}
			}
		}
	}
	if (cnt_node < node)sum = -1;
	return sum;
}

int main() {
	int s, sum = 0;
	Visit();//获得所有存在的边
	int n = Prim(1);
	if (n == -1)cout << "orz";
	else cout << n;
	return 0;
}

Kruskal算法

需要使用一个并查集的操作。
并查集的数据结构如下：

#include <iostream>
using namespace std;
const int maxn = 1e5;
int father[maxn];

void Init() {
	for (int i = 1; i < maxn; i++) father[i] = i
}

void Union(const int &u, const int &v) { //联合
	father[Find(u)] = Find(v); //v的最老祖宗的爹是u的最老祖宗的爹
}

int Find(const int &u) { //查找u的祖宗是谁
	if (u == father[u])return u;
	return father[u] = Find(father[u]); //扁平化
}

int main() {
	Init();
	return 0;
}

【Kruskal】

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

struct Edge {
	int u;//起点
	int v;//终点
	int w;//权值

	bool operator<(const Edge &a)const {
		return w > a.w;
	}
};

int node, edge; //总结点数以及边数
priority_queue<Edge> all_e;//存放所有的边
queue<Edge> vis_e;//加入最小生成树的所有的边
const int maxn = 1e5;
int father[maxn];

void Init() {
	for (int i = 1; i < maxn; i++) father[i] = i;
}

int Find(const int &u) { //查找u的祖宗是谁
	if (u == father[u])return u;
	return father[u] = Find(father[u]); //扁平化
}

void Union(const int &u, const int &v) { //联合
	father[Find(u)] = Find(v); //v的最老祖宗的爹是u的最老祖宗的爹
}

void Visit() {
	cout << "【请输入结点数以及边数】:" << endl;
	cin >> node >> edge;
	cout << "【请按照 起点-终点-权值 的格式输入边】：" << endl;
	for (int i = 0; i < edge; i++) {
		Edge a;
		cin >> a.u >> a.v >> a.w;
		all_e.push(a);
	}
}

int Kruskal() {
	int n_edge = 0, sum = 0;
	while (!all_e.empty()) {
		Edge a = all_e.top();
		all_e.pop();
		if (Find(a.u) != Find(a.v)) { //就加入这条边
			Union(a.u, a.v);
			vis_e.push(a);
			sum += a.w;
			n_edge++;
		}
	}
	if (n_edge < node - 1)sum = -1;
	return sum;
}

void Show() {
	while (!vis_e.empty()) {
		Edge a = vis_e.front();
		vis_e.pop();
		cout << a.u << " " << a.v << " " << a.w << endl;
	}
}

int main() {
	Init();
	Visit();
	cout << "===========" << endl;
	int n=Kruskal();
	if(n==-1)cout<<"此图不连通"<<endl;
	else {
		cout<<n<<endl;
		Show();
	}
	return 0;
}

这个稍作修改就可以ACP3366了。。。