关于贪心算法详解-电子发烧友网

顾名思义，贪心算法总是作出在当前看来最好的选择。也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。

当然，希望贪心算法得到的最终结果也是整体最优的。虽然贪心算法不能对所有问题都得到整体最优解，但对许多问题它能产生整体最优解。

如单源最短路经问题，最小生成树问题等。在一些情况下，即使贪心算法不能得到整体最优解，其最终结果却是最优解的很好近似。

基本思路：

1. 建立数学模型来描述问题。

⒉.把求解的问题分成若干个子问题。

⒊.对每一子问题求解，得到子问题的局部最优解。

⒋.把子问题的解局部最优解合成原来解问题的一个解。

实现该算法的过程：

⒈.从问题的某一初始解出发;

2. while 能朝给定总目标前进一步 do

3.求出可行解的一个解元素;

4.由所有解元素组合成问题的一个可行解。从问题的某一初始解出发

背包问题

有一个背包，最多能承载150斤的重量，现在有7个物品，重量分别为[35, 30, 60, 50, 40, 10, 25]，它们的价值分别为[10, 40, 30, 50, 35, 40, 30]，应该如何选择才能使得我们的背包背走最多价值的物品？

把物品一个个的往包里装，要求装入包中的物品总价值最大，要让总价值最大，就可以想到怎么放一个个的物品才能让总的价值最大，因此可以想到如下三种选择物品的方法，即可能的局部最优解：

1：每次都选择价值最高的往包里放。

2：每次都选择重量最小的往包里放。

3：每次都选择单位重量价值最高的往包里放。

4：选择价值最高的，按照制订的规则（价值）进行计算，顺序是：4 2 6 5 。

最终的总重量是：130；最终的总价值是：165。

2：选择重量最小的，按照制订的规则（重量）进行计算，顺序是：6 7 2 1 5 。

最终的总重量是：140；最终的总价值是：155。可以看到，重量优先是没有价值优先的策略更好。

3:选择单位密度价值最大的，按照制订的规则（单位密度）进行计算，顺序是：6 2 7 4 1。

最终的总重量是：150；最终的总价值是：170。

可以看到，单位密度这个策略比之前的价值策略和重量策略都要好。

单源最大路径问题

给定带权有向图G =(V,E)，其中每条边的权是非负实数。另外，还给定V中的一个顶点，称为源。现在要计算从源到所有其它各顶点的最短路长度。这里路的长度是指路上各边权之和。这个问题通常称为单源最短路径问题。

Dijkstra算法是解单源最短路径问题的贪心算法。

其基本思想是，设置顶点集合S并不断地作贪心选择来扩充这个集合。一个顶点属于集合S当且仅当从源到该顶点的最短路径长度已知。

初始时，S中仅含有源。设u是G的某一个顶点，把从源到u且中间只经过S中顶点的路称为从源到u的特殊路径，并用数组dist记录当前每个顶点所对应的最短特殊路径长度。

Dijkstra算法每次从V-S中取出具有最短特殊路长度的顶点u，将u添加到S中，同时对数组dist作必要的修改。一旦S包含了所有V中顶点，dist就记录了从源到所有其它顶点之间的最短路径长度。

例如，对下图中的有向图，应用Dijkstra算法计算从源顶点1到其它顶点间最短路径的过程列在下表中。

Dijkstra算法的迭代过程：

算法的正确性和计算复杂性

(1)贪心选择性质

(2)最优子结构性质

(3)计算复杂性

对于具有n个顶点和e条边的带权有向图，如果用带权邻接矩阵表示这个图，那么Dijkstra算法的主循环体需要O(n)时间。这个循环需要执行n-1次，所以完成循环需要O(n)时间。算法的其余部分所需要时间不超过O(n^2)。

代码实现(来自于第四个参考链接)：

#include #include #include using namespace std ;
class BBShortestDijkstra{public:  BBShortestDijkstra (const vector<vector<int> >& vnGraph)     :m_cnMaxInt (numeric_limits<int>::max())   {    m_vnGraph = vnGraph ;    m_stCount = vnGraph.size () ;    m_vnDist.resize (m_stCount) ;    for (size_t i = 0; i < m_stCount; ++ i) {      m_vnDist[i].resize (m_stCount) ;    }  }    void doDijkatra (){    int nMinIndex = 0 ;    int nMinValue = m_cnMaxInt ;    vector<bool> vbFlag (m_stCount, false) ;    for (size_t i = 0; i < m_stCount; ++ i) {      m_vnDist[0][i] = m_vnGraph[0][i] ;      if (nMinValue > m_vnGraph[0][i]) {        nMinValue = m_vnGraph[0][i] ;        nMinIndex = i ;      }    }
    vbFlag[0] = true ;    size_t k = 1 ;    while (k < m_stCount) {      vbFlag[nMinIndex] = true ;      for (size_t j = 0; j < m_stCount ; ++ j) {        // 没有被选择        if (!vbFlag[j] && m_vnGraph[nMinIndex][j] != m_cnMaxInt ) {          if (m_vnGraph[nMinIndex][j] + nMinValue            < m_vnDist[k-1][j]) {            m_vnDist[k][j] = m_vnGraph[nMinIndex][j] + nMinValue ;          }          else {            m_vnDist[k][j] = m_vnDist[k-1][j] ;          }        }        else {          m_vnDist[k][j] = m_vnDist[k-1][j] ;        }      }      nMinValue = m_cnMaxInt ;      for (size_t j = 0; j < m_stCount; ++ j) {        if (!vbFlag[j] && (nMinValue > m_vnDist[k][j])) {          nMinValue = m_vnDist[k][j] ;          nMinIndex = j ;        }      }      ++ k ;    }
    for (int i = 0; i < m_stCount; ++ i) {      for (int j = 0; j < m_stCount; ++ j) {        if (m_vnDist[i][j] == m_cnMaxInt) {          cout << "maxint " ;        }        else {          cout << m_vnDist[i][j] << " " ;        }      }      cout << endl ;    }  }private:   vector<vector<int> >  m_vnGraph ;  vector<vector<int> >  m_vnDist ;  size_t m_stCount ;  const int m_cnMaxInt ;} ;
int main(){  const int cnCount = 5 ;  vector<vector<int> > vnGraph (cnCount) ;  for (int i = 0; i < cnCount; ++ i) {    vnGraph[i].resize (cnCount, numeric_limits<int>::max()) ;  }  vnGraph[0][1] = 10 ;  vnGraph[0][3] = 30 ;  vnGraph[0][4] = 100 ;  vnGraph[1][2] = 50 ;  vnGraph[2][4] = 10 ;  vnGraph[3][2] = 20 ;  vnGraph[3][4] = 60 ;
  BBShortestDijkstra bbs (vnGraph) ;  bbs.doDijkatra () ;}