贪心算法——Prim最小生成树

1、首先介绍一下什么是贪心算法：

贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。ps：不懂得话可以百度百科，仔细了解。

2、prim算法的原理：

从连通网N={V,E}中的某一顶点U0出发，选择与它关联的具有最小权值的边(U0,v)，将其顶点加入到生成树的顶点

集合U中。以后每一步从一个顶点在U中，而另一个顶点不在U中的各条边中选择权值最小的边(u,v),把它的顶点

加入到集合U中。如此继续下去，直到网中的所有顶点都加入到生成树顶点集合U中为止。

3、

Prim算法

设G=(V,E)是连通带权图，V={1,2,…,n}。构造G的最小生成树的Prim算法的基本思想是：

(1)置S={1}

(2)只要S是V的真子集，就作如下的贪心选择

选取满足条件i ∈ S，j ∈ V-S，且c[i][j]最小的边，将顶点j添加到S中。

一直到S=V时为止。

(3)选取到的所有边恰好构成G的一棵最小生成树。



代码：

#include <iostream>
#include <vector>
#include <limits>
using namespace std ;

class TreeNode//定义一个最小生成树类
{
public:
int m_firstNode;
int m_lastNode ;
int m_Value ;
TreeNode (int firstNode= 0, int lastNode = 0, int Value = 0)
{
m_firstNode=firstNode;
m_lastNode =lastNode;
m_Value =Value;
}
};

class Prim //定义一个Prim算法的类
{
private:
vector<vector<int> > m_nvvalues ; //无向连通图
vector<TreeNode> MinTree ;    //最小生成树
int NodeCount; //无相连通图的结点数
public:
Prim (const vector<vector<int> >& vnvalues)
{
m_nvvalues = vnvalues ;
NodeCount = (int)m_nvvalues.size () ;
}
void DoPrim ()
{
// 是否被访问标志
vector<bool> bFlag (NodeCount, false) ;
bFlag[0]=true ;
int firstNode ;
int lastNode;
int k=0 ;
while(k<NodeCount-1)
{
//voctor<int>的最大值,也是默认值
int nMaxWeight=numeric_limits<int>::max () ;
// 找到当前最短路径
int i = 0 ;
while (i<NodeCount)
{
if(!bFlag[i])
{
++ i ;
continue ;
}
for (int j = 0; j < NodeCount; ++ j)
{
if (!bFlag[j] && nMaxWeight > m_nvvalues[i][j])
{
nMaxWeight = m_nvvalues[i][j] ;
firstNode = i ;
lastNode = j ;
}
}
++ i ;
}
bFlag[lastNode] = true ;
MinTree.push_back (TreeNode(firstNode, lastNode, nMaxWeight)) ;
++k ;
}
// 输出结果
for (vector<TreeNode>::const_iterator ite = MinTree.begin() ;
ite != MinTree.end() ;
++ ite )
{
cout << (*ite).m_firstNode+1 << "->"
<< (*ite).m_lastNode+1<< " : "
<< (*ite).m_Value << endl ;
}
}
} ;

int main()
{
const int NodeCount=6 ;//定义结点个数
vector<vector<int> > values(NodeCount);//定义一个二维容器用来存储连通图
for(size_t i=0;i<values.size();++i)//重定义容器的大小
{
values[i].resize(NodeCount,numeric_limits<int>::max()) ;
}
//将连通图中的权值赋值
values[0][1] = 6 ;
values[0][2] = 1 ;
values[0][3] = 5 ;
values[1][0] = 6 ;
values[1][2] = 5 ;
values[1][4] = 3 ;
values[2][0] = 1 ;
values[2][1] = 5 ;
values[2][3] = 5 ;
values[2][4] = 6 ;
values[2][5] = 4 ;
values[3][0] = 5 ;
values[3][2] = 5 ;
values[3][5] = 2 ;
values[4][1] = 3 ;
values[4][2] = 6 ;
values[4][5] = 6 ;
values[5][2] = 4 ;
values[5][3] = 2 ;
values[5][4] = 6 ;
//定义一个prim类的对象
Prim prim1(values) ;
//使用prim类的DoPrim方法实现Prim算法
prim1.DoPrim () ;
return 0 ;
}