最常用算法汇总（一）

一、贪心算法

贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。贪心算法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题他能产生整体最优解或者是整体最优解的近似解。

用贪心法设计算法的特点是一步一步地进行，常以当前情况为基础根据某个优化测度作最优选择，而不考虑各种可能的整体情况，它省去了为找最优解要穷尽所有可能而必须耗费的大量时间，它采用自顶向下，以迭代的方法做出相继的贪心选择，每做一次贪心选择就将所求问题简化为一个规模更小的子问题，通过每一步贪心选择，可得到问题的一个最优解，虽然每一步上都要保证能获得局部最优解，但由此产生的全局解有时不一定是最优的，所以贪心法不需要回溯。

注意：对于一个给定的问题，往往可能有好几种量度标准。初看起来，这些量度标准似乎都是可取的，但实际上，用其中的大多数量度标准作贪婪处理所得到该量度意义下的最优解并不是问题的最优解，而是次优解。因此，选择能产生问题最优解的最优量度标准是使用贪婪算法的核心。

经典的求最小生成树的Prim算法和Kruskal算法、计算强连通子图的Dijkstra算法、构造huffman树的算法都是漂亮的贪心算法

基本思路：

⒈建立数学模型来描述问题。
⒉把求解的问题分成若干个子问题。
⒊对每一子问题求解，得到子问题的局部最优解。
⒋把子问题的解局部最优解合成原来解问题的一个解。
实现该算法的过程：
从问题的某一初始解出发；
while 能朝给定总目标前进一步 do
求出可行解的一个解元素；
由所有解元素组合成问题的一个可行解。

例子：

马踏棋盘的贪心算法
【问题描述】
马的遍历问题。在8×8方格的棋盘上，从任意指定方格出发，为马寻找一条走遍棋盘每一格并且只经过一次的一条最短路径。

【贪心算法】
其实马踏棋盘的问题很早就有人提出，且早在1823年，J.C.Warnsdorff就提出了一个有名的算法。在每个结点对其子结点进行选取时，优先选择‘出口’最小的进行搜索，‘出口’的意思是在这些子结点中它们的可行子结点的个数，也就是‘孙子’结点越少的越优先跳，为什么要这样选取，这是一种局部调整最优的做法，如果优先选择出口多的子结点，那出口少的子结点就会越来越多，很可能出现‘死’结点（顾名思义就是没有出口又没有跳过的结点），这样对下面的搜索纯粹是徒劳，这样会浪费很多无用的时间，反过来如果每次都优先选择出口少的结点跳，那出口少的结点就会越来越少，这样跳成功的机会就更大一些。

二、分治算法

思想：

分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解，就可得到原问题的解。

分治法应用场景：

运用分治策略解决的问题一般来说具有以下特点：
1、原问题可以分解为多个子问题
这些子问题与原问题相比，只是问题的规模有所降低，其结构和求解方法与原问题相同或相似。
2、原问题在分解过程中，递归地求解子问题
由于递归都必须有一个终止条件，因此， 当分解后的子问题规模足够小时，应能够直接求解。
3、在求解并得到各个子问题的解后
应能够采用某种方式、方法合并或构造出原问题的解。
不难发现，在分治策略中，由于子问题与原问题在结构和解法上的相似性，用分治方法解决的问题，大都采用了递归的形式。在各种排序方法中，如 归并排序、堆排序、快速排序等，都存在有分治的思想。

分治法解题的一般步骤：

（1） 分解，将要解决的问题划分成若干规模较小的同类问题；
（2） 求解，当子问题划分得足够小时，用较简单的方法解决；
（3） 合并，按原问题的要求，将子问题的解逐层合并构成原问题的解。

三、动态规划

基本思想：

动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，这样就可以避免大量的重复计算，节省时间。我们可以用一个表来记录所有已解的子问题的答案。不管该子问题以后是否被用到，只要它被计算过，就将其结果填入表中。这就是动态规划法的基本思路。具体的动态规划算法多种多样，但它们具有相同的填表格式。

与分治法最大的差别是：适合于用动态规划法求解的问题，经分解后得到的子问题往往不是互相独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解）

应用场景：

适用动态规划的问题必须满足最优化原理、无后效性和重叠性。
1.最优化原理（最优子结构性质） 最优化原理可这样阐述：一个最优化策略具有这样的性质，不论过去状态和决策如何，对前面的决策所形成的状态而言，余下的诸决策必须构成最优策略。简而言之，一个最优化策略的子策略总是最优的。一个问题满足最优化原理又称其具有最优子结构性质。

2.无后效性  将各阶段按照一定的次序排列好之后，对于某个给定的阶段状态，它以前各阶段的状态无法直接影响它未来的决策，而只能通过当前的这个状态。换句话说，每个状态都是过去历史的一个完整总结。这就是无后向性，又称为无后效性。

3.子问题的重叠性  动态规划将原来具有指数级时间复杂度的搜索算法改进成了具有多项式时间复杂度的算法。其中的关键在于解决冗余，这是动态规划算法的根本目的。动态规划实质上是一种以空间换时间的技术，它在实现的过程中，不得不存储产生过程中的各种状态，所以它的空间复杂度要大于其它的算法。

求全路径最短路径的Floyd算法就是漂亮地运用了动态规划思想。

下面是我找到的一个关于 0-1背包问题 的动态规划思想PPT截图：

问题描述：
给定n种物品和一背包。物品i的重量是wi，其价值为vi，背包的容量为C。问应如何选择装入背包的物品，使得装入背包中物品的总价值最大?

对于一种物品，要么装入背包，要么不装。所以对于一种物品的装入状态可以取0和1.我们设物品i的装入状态为xi,xi∈ (0,1)，此问题称为0-11背包问题。

数据：物品个数n=5,物品重量w[n]={0，2，2，6，5，4},物品价值V[n]={0，6，3，5，4，6},
（第0位，置为0，不参与计算，只是便于与后面的下标进行统一，无特别用处，也可不这么处理。）总重量c=10。背包的最大容量为10，那么在设置数组m大小时，可以设行列值为6和11，那么，对于m(i,j)就表示可选物品为i…n背包容量为j(总重量)时背包中所放物品的最大价值。

四、回溯法

回溯法（探索与回溯法）是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

基本思想：

回溯法在问题的解空间树中，按深度优先策略，从根结点出发搜索解空间树。算法搜索至解空间树的任意一点时，先判断该结点是否包含问题的解。如果肯定不包含（剪枝过程），则跳过对该结点为根的子树的搜索，逐层向其祖先结点回溯；否则，进入该子树，继续按深度优先策略搜索。

回溯法就是对隐式图的深度优先搜索算法

回溯法：为了避免生成那些不可能产生最佳解的问题状态，要不断地利用限界函数(bounding function)来处死(剪枝)那些实际上不可能产生所需解的活结点，以减少问题的计算量。具有限界函数的深度优先生成法称为回溯法。（回溯法 = 穷举 +　剪枝）

一般步骤：

(1)针对所给问题，定义问题的解空间；
(2)确定易于搜索的解空间结构；
(3)以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索。

两个常用的剪枝函数：

(1)约束函数：在扩展结点处减去不满足约束的子数
(2)限界函数：减去得不到最优解的子树

　　用回溯法解题的一个显著特征是在搜索过程中动态产生问题的解空间。在任何时刻，算法只保存从根结点到当前扩展结点的路径。如果解空间树中从根结点到叶结点的最长路径的长度为h(n)，则回溯法所需的计算空间通常为O(h(n))。而显式地存储整个解空间则需要O(2^h(n))或O(h(n)!)内存空间。

五、分支限界法

基本思想：

分支限界法常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。
在分支限界法中，每一个活结点只有一次机会成为扩展结点。活结点一旦成为扩展结点，就一次性产生其所有儿子结点。在这些儿子结点中，导致不可行解或导致非最优解的儿子结点被舍弃，其余儿子结点被加入活结点表中。
此后，从活结点表中取下一结点成为当前扩展结点，并重复上述结点扩展过程。这个过程一直持续到找到所需的解或活结点表为空时为止。

分支限界法与回溯法的区别：

（1）求解目标：回溯法的求解目标是找出解空间树中满足约束条件的所有解，而分支限界法的求解目标则是找出满足约束条件的一个解，或是在满足约束条件的解中找出在某种意义下的最优解。 
（2）搜索方式的不同：回溯法以深度优先的方式搜索解空间树，而分支限界法则以广度优先或以最小耗费优先的方式搜索解空间树。 

常见的两种分支限界法：

（1）队列式(FIFO)分支限界法
按照队列先进先出（FIFO）原则选取下一个节点为扩展节点。
（2）优先队列式分支限界法
按照优先队列中规定的优先级选取优先级最高的节点成为当前扩展节点。

例子：单源最短路径问题（参考http://www.cnblogs.com/chinazhangjie/archive/2010/11/01/1866136.html）

1、问题描述 
在下图所给的有向图G中，每一边都有一个非负边权。要求图G的从源顶点s到目标顶点t之间的最短路径。

下图是用优先队列式分支限界法解有向图G的单源最短路径问题产生的解空间树。其中，每一个结点旁边的数字表示该结点所对应的当前路长。

找到一条路径：

目前的最短路径是8，一旦发现某个结点的下界不小于这个最短路进，则剪枝：

同一个结点选择最短的到达路径：

2.剪枝策略
在算法扩展结点的过程中，一旦发现一个结点的下界不小于当前找到的最短路长，则算法剪去以该结点为根的子树。
在算法中，利用结点间的控制关系进行剪枝。从源顶点s出发，2条不同路径到达图G的同一顶点。由于两条路径的路长不同，因此可以将路长长的路径所对应的树中的结点为根的子树剪去。 
3.算法思想
解单源最短路径问题的优先队列式分支限界法用一极小堆来存储活结点表。其优先级是结点所对应的当前路长。
算法从图G的源顶点s和空优先队列开始。结点s被扩展后，它的儿子结点被依次插入堆中。此后，算法从堆中取出具有最小当前路长的结点作为当前扩展结点，并依次检查与当前扩展结点相邻的所有顶点。如果从当前扩展结点i到顶点j有边可达，且从源出发，途经顶点i再到顶点j的所相应的路径的长度小于当前最优路径长度，则将该顶点作为活结点插入到活结点优先队列中。这个结点的扩展过程一直继续到活结点优先队列为空时为止。

源码如下：

[cpp]  view plain copy print ?

1. /* 主题：单源最短路径问题 
2. * 作者：chinazhangjie 
3. * 邮箱：chinajiezhang@gmail.com 
4. * 开发语言：C++ 
5. * 开发环境：Mircosoft Virsual Studio 2008 
6. * 时间: 2010.11.01 
7. */  
8.   
9. #include <iostream>  
10. #include <vector>  
11. #include <queue>  
12. #include <limits>  
13. using namespace std;  
14.   
15. struct node_info  
16. {  
17. public:  
18.     node_info (int i,int w)   
19.         : index (i), weight (w) {}  
20.     node_info ()   
21.         : index(0),weight(0) {}  
22.     node_info (const node_info & ni)   
23.         : index (ni.index), weight (ni.weight) {}  
24.   
25.     friend   
26.     bool operator < (const node_info& lth,const node_info& rth) {  
27.         return lth.weight > rth.weight ; // 为了实现从小到大的顺序  
28.     }  
29.   
30. public:  
31.     int index; // 结点位置  
32.     int weight; // 权值  
33. };  
34.   
35. struct path_info   
36. {  
37. public:  
38.     path_info ()  
39.         : front_index(0), weight (numeric_limits<int>::max()) {}  
40.   
41. public:  
42.     int front_index;  
43.     int weight;  
44. };  
45.   
46. // single source shortest paths  
47. class ss_shortest_paths  
48. {  
49.        
50. public:  
51.     ss_shortest_paths (const vector<vector<int> >& g,int end_location)   
52.         :no_edge (-1), end_node (end_location), node_count (g.size()) , graph (g)   
53.     {}  
54.   
55.     // 打印最短路径  
56.     void print_spaths () const {  
57.         cout << "min weight : " << shortest_path << endl;  
58.         cout << "path: " ;  
59.         copy (s_path_index.rbegin(),s_path_index.rend(),  
60.             ostream_iterator<int> (cout, " "));  
61.         cout << endl;  
62.     }  
63.   
64.     // 求最短路径  
65.     void shortest_paths () {  
66.         vector<path_info> path(node_count);  
67.         priority_queue<node_info,vector<node_info> > min_heap;  
68.         min_heap.push (node_info(0,0));    // 将起始结点入队  
69.   
70.         while (true) {  
71.             node_info top = min_heap.top ();    // 取出最大值  
72.             min_heap.pop ();  
73.   
74.             // 已到达目的结点  
75.             if (top.index == end_node) {  
76.                 break ;  
77.             }  
78.             // 未到达则遍历  
79.             for (int i = 0; i < node_count; ++ i) {  
80.                 // 顶点top.index和i间有边，且此路径长小于原先从原点到i的路径长   
81.                 if (graph[top.index][i] != no_edge &&   
82.                     (top.weight + graph[top.index][i]) < path[i].weight) {  
83.                     min_heap.push (node_info (i,top.weight + graph[top.index][i]));  
84.                     path[i].front_index = top.index;  
85.                     path[i].weight = top.weight + graph[top.index][i];  
86.                 }  
87.             }  
88.             if (min_heap.empty()) {  
89.                 break ;  
90.             }  
91.         }  
92.   
93.         shortest_path = path[end_node].weight;  
94.         int index = end_node;  
95.         s_path_index.push_back(index) ;  
96.         while (true) {  
97.             index = path[index].front_index ;  
98.             s_path_index.push_back(index);  
99.             if (index == 0) {  
100.                 break;  
101.             }  
102.         }  
103.     }  
104.   
105. private:  
106.     vector<vector<int> >    graph ;            // 图的数组表示  
107.     int                        node_count;        // 结点个数  
108.     const int                no_edge;        // 无通路  
109.     const int                end_node;        // 目的结点  
110.     vector<int>                s_path_index;    // 最短路径  
111.     int                        shortest_path;    // 最短路径  
112. };  
113.   
114. int main()  
115. {  
116.     const int size = 11;   
117.     vector<vector<int> > graph (size);  
118.     for (int i = 0;i < size; ++ i) {  
119.         graph[i].resize (size);  
120.     }  
121.     for (int i = 0;i < size; ++ i) {  
122.         for (int j = 0;j < size; ++ j) {  
123.             graph[i][j] = -1;  
124.         }  
125.     }  
126.     graph[0][1] = 2;  
127.     graph[0][2] = 3;  
128.     graph[0][3] = 4;  
129.     graph[1][2] = 3;  
130.     graph[1][5] = 2;  
131.     graph[1][4] = 7;  
132.     graph[2][5] = 9;  
133.     graph[2][6] = 2;  
134.     graph[3][6] = 2;  
135.     graph[4][7] = 3;  
136.     graph[4][8] = 3;  
137.     graph[5][6] = 1;  
138.     graph[5][8] = 3;  
139.     graph[6][9] = 1;  
140.     graph[6][8] = 5;  
141.     graph[7][10] = 3;  
142.     graph[8][10] = 2;  
143.     graph[9][8] = 2;  
144.     graph[9][10] = 2;  
145.   
146.     ss_shortest_paths ssp (graph, 10);  
147.     ssp.shortest_paths ();  
148.     ssp.print_spaths ();  
149.     return 0;  
150. }  

测试数据（图）

测试结果：

min weight :8
path: 0 2 6 9 10