最小生成树的prim算法和kruskal算法

最新推荐文章于 2020-03-01 17:09:48 发布

DDUp_

最新推荐文章于 2020-03-01 17:09:48 发布

阅读量397

点赞数

分类专栏：算法 C++

本文链接：https://blog.csdn.net/zhxuan30/article/details/39399965

版权

C++ 同时被 2 个专栏收录

31 篇文章 0 订阅

订阅专栏

算法

19 篇文章 0 订阅

订阅专栏

<span style="font-size:18px;">#include "stdafx.h"
#include <iostream>
using namespace std;

//oj1017
//畅通工程，求最小公路长度
//====》求最小生成树
//  prim算法  适合于求边稠密的图  O(n^2)
// Kruskal算法   适合于求边稀疏的图  O(e*loge)
//图用邻接矩阵表示

#include <vector>
#include <utility>
class Graph_113
{
public:
	int vexnum;
	int arcnum;
	vector<vector<int> > arcs;  //邻接矩阵

	Graph_113(int );
	int PrimShortTree();

};

Graph_113::Graph_113(int _vexnum) 
{
	vexnum=_vexnum;
	arcnum = vexnum*(vexnum - 1) / 2;
	//初始化邻接矩阵
	vector<int> row(vexnum + 1, 0);
	for (int i = 0; i <= vexnum; ++i)
	{
		arcs.push_back(row);
	}
	row.clear();
	//构造邻接矩阵
	int i, j, w;
	int N = arcnum;
	while (N--)
	{
		cin >> i >> j >> w;
		arcs[i][j] = w;
		arcs[j][i] = w;
	}
}

int Graph_113::PrimShortTree()
{
	int res = 0;
	//辅助数组
	vector<pair<int,int> > closedge(vexnum+1,make_pair(0,0));
	//初始点为1
	for (int i = 2; i <= vexnum; ++i)
	{
		closedge[i].first = 1;
		closedge[i].second = arcs[1][i];
	}
	for (int i = 1; i <= vexnum; ++i)
	{
		//找V-U集合中到U集合中点最近的点
		//作为T中的下一个顶点
		int min = 0;
		int j = 1;
		for (; j <= vexnum; ++j)
		{
			if (closedge[j].second != 0)
			{
				min = j;
				break;
			}
		}
		for (; j <= vexnum; ++j)
		{
			if (closedge[j].second < closedge[min].second &&closedge[j].second!=0)
				min = j;
		}
		//加入最短路径
		res += closedge[min].second;
		//将第min个节点并入U集合
		for (int k = 1; k <= vexnum; ++k)
		{
			if (arcs[min][k] < closedge[k].second)
			{
				closedge[k].first = min;
				closedge[k].second = arcs[min][k];
			}
		}

	}
	return res;
}

//Kruskal算法，存储边
int KruskalPath(int N,int arcs)  //节点数，边数
{
	int i, j, w;
	int res = 0;
	vector<int> visit(N + 1, 0);
	vector<pair<int, pair<int, int> > > arc;
	while (arcs--)
	{
		cin >> i >> j >> w;
		arc.push_back(make_pair(w, make_pair(i, j)));
	}
	//依次找出n-1条边，边满足要求：边的两个点来自两个连通区
	int count = N - 1;
	while (count--)
	{
		typedef vector<pair<int, pair<int, int> > >::iterator myIter;
		//第一条满足要求的边
		myIter iter = arc.begin();
		pair<int, pair<int, int> > min;
		for ( ; iter != arc.end(); ++iter)
		{
			if (!visit[iter->second.first] || !visit[iter->second.second])
			{
				min = *iter;
				break;
			}
		}
		//求最小边
		for (; iter != arc.end(); ++iter)
		{
			if (visit[iter->second.first] && visit[iter->second.second])
				continue;
			if (iter->first < min.first)
				min = *iter;
		}
		//将最小边加入T
		res += min.first;
		visit[min.second.first] = 1;
		visit[min.second.second] = 1;
	}
	return res;
}



#include <fstream>
#include <string>
int main()
{
	ifstream infile;
	string filename = "case.txt";
	infile.open(filename.c_str());
	cin.rdbuf(infile.rdbuf());

	int N;
	while (cin >> N)
	{
		if (N == 0)
			break;
//		Graph_113 _graph(N);
//		cout << _graph.PrimShortTree() << endl;
		cout << KruskalPath(N, N*(N - 1) / 2) << endl;
	}
	return 0;
}
</span>