贪心算法——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 ;
}