常用算法五（分支界限法）

一、基本描述

    类似于回溯法，也是一种在问题的解空间树T上搜索问题解的算法。但在一般情况下，分支限界法与回溯法的求解目标不同。回溯法的求解目标是找出T中满足约束条件的所有解，而分支限界法的求解目标则是找出满足约束条件的一个解，或是在满足约束条件的解中找出使某一目标函数值达到极大或极小的解，即在某种意义下的最优解。

   （1）分支搜索算法

    所谓“分支”就是采用广度优先的策略，依次搜索E-结点的所有分支，也就是所有相邻结点，抛弃不满足约束条件的结点，其余结点加入活结点表。然后从表中选择一个结点作为下一个E-结点，继续搜索。

     选择下一个E-结点的方式不同，则会有几种不同的分支搜索方式。

   1）FIFO搜索

   2）LIFO搜索

   3）优先队列式搜索

（2）分支限界搜索算法 

二、分支限界法的一般过程

    由于求解目标不同，导致分支限界法与回溯法在解空间树T上的搜索方式也不相同。回溯法以深度优先的方式搜索解空间树T，而分支限界法则以广度优先或以最小耗费优先的方式搜索解空间树T。

    分支限界法的搜索策略是：在扩展结点处，先生成其所有的儿子结点（分支），然后再从当前的活结点表中选择下一个扩展对点。为了有效地选择下一扩展结点，以加速搜索的进程，在每一活结点处，计算一个函数值（限界），并根据这些已计算出的函数值，从当前活结点表中选择一个最有利的结点作为扩展结点，使搜索朝着解空间树上有最优解的分支推进，以便尽快地找出一个最优解。

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

三、回溯法和分支限界法的一些区别

    有一些问题其实无论用回溯法还是分支限界法都可以得到很好的解决，但是另外一些则不然。也许我们需要具体一些的分析——到底何时使用分支限界而何时使用回溯呢？

回溯法和分支限界法的一些区别：

   方法对解空间树的搜索方式       存储结点的常用数据结构      结点存储特性常用应用

  回溯法深度优先搜索堆栈活结点的所有可行子结点被遍历后才被从栈中弹出找出满足约束条件的所有解

  分支限界法广度优先或最小消耗优先搜索队列、优先队列每个结点只有一次成为活结点的机会找出满足约束条件的一个解或特定意义下的最优解

旅行售货员问题用回溯法貌似更容易实现一些，网上代码很多。这里给出用分支限界法的java实现。

四、应用示例

问题描述：
某售货员要到若干城市去推销商品，已知各城市之间的路程（或旅费）。他要选定一条从驻地出发，经过每个城市一遍，最后回到驻地的路线，使总的路程（ 或旅费）最小。各个城市之间可能是有向连通的、无向连通的、以及存在某个城市不连通的情况，你的程序应该能够处理所有可能的情况。如下图表示各个城市间无向连通。
输入：

第一行为一个整数n(n<=10)，表示城市的总个数。接下来是一个n*n的矩阵，用来表示城市间的连通情况以及花费，例如path[i][j]=len，len=-1表示从城市i到城市j没有通路，len>0表示从i到j的路程长度为len。对于上面图示的问题我们可以按照下面方式输入：

4
-1 30 6 4
30 -1 5 10
6 5 -1 20
4 10 20 -1

输出：

输出占一行，对于给定的问题，如果找到了最小路程（花费），输出该最小花费，如果没有通路可以到达每个城市，则输出-1。

输入样例：

4
-1 30 6 4
30 -1 5 10
6 5 -1 20
4 10 20 -1

输出样例：

25

代码：

[java] view plaincopyprint?

1. //旅行售货员问题，用分支限界法实现 2010-10-28  
2.   
3. import java.util.Scanner;  
4.   
5. public class Main  
6. {  
7.   
8. //Main  
9. public static void main(String args[])  
10. {  
11. Scanner s=new Scanner(System.in);  
12. int n=0;//结点的个数  
13. String line=s.nextLine();//读入n  
14. n=Integer.parseInt(line);  
15. a=new float[n][n];  
16. int []vv=new int[n];  
17.   
18. for(int i=0;i<n;i++)  
19. {  
20. line=s.nextLine();  
21. String []sArray=line.split(" ");  
22. for(int j=0;j<sArray.length;j++)  
23. {  
24. a[i][j]=Integer.parseInt(sArray[j]);  
25. }  
26. }  
27. System.out.println(bbTsp(vv));  
28. }//Main  
29.   
30.   
31. static float [][]a;//图的邻接矩阵  
32. //static float a[][]={{-1,-1,-1,2},{2,-1,-1,-1},{1,3,-1,-1},{-1,-1,1,-1}};  
33. //static float a[][]={{-1,30,6,4},{30,-1,5,10},{6,5,-1,20},{4,10,20,-1}};  
34. //static float a[][]={{5,5,5,5},{5,5,5,5},{5,5,5,5},{5,5,5,5}};  
35.   
36. private static class HeapNode implements Comparable  
37. {  
38. float lcost,//子树费用下界  
39. cc,//当前费用  
40. rcost;//X[s:n-1]中顶点最小出边费用和  
41. int s;//根节点到当前结点的路径为X[0:s]  
42. int []x;//需要进一步搜索的结点是x[s+1:n-1]  
43.   
44. //HeapNode的构造函数  
45. HeapNode(float lc,float ccc,float rc,int ss,int []xx)  
46. {  
47. lcost=lc;  
48. cc=ccc;  
49. s=ss;  
50. x=xx;  
51. }//HeapNode 构造函数  
52.   
53. public int compareTo(Object x)  
54. {  
55. float xlc=((HeapNode)x).lcost;  
56. if(lcost<xlc)  
57. return -1;  
58. if(lcost==xlc)  
59. return 0;  
60. return 1;  
61. }  
62.   
63. }//class HeapNode  
64.   
65. public static int  bbTsp(int []v)  
66. {  
67. int n=v.length;  
68. MinHeap heap=new MinHeap(100);  
69. float []minOut=new float[n];//minOut[i]是顶点i的最小出边费用  
70. float minSum=0;//最小出边费用和  
71.   
72. //计算最小出边费用和  
73. for(int i=0;i<n;i++)  
74. {  
75. float min=Float.MAX_VALUE;  
76. for(int j=0;j<n;j++)  
77. {  
78. if(a[i][j]!=-1&&a[i][j]<min)  
79. min=a[i][j];//有回路  
80. }//for j  
81.   
82. if(min==Float.MAX_VALUE)  
83. {  
84. return -1;//无回路  
85. }//if  
86.   
87. minOut[i]=min;  
88. minSum+=min;  
89. }//for i  
90.   
91. //初始化  
92. int []x=new int[n];  
93. for(int i=0;i<n;i++)  
94. {  
95. x[i]=i;  
96. }  
97. HeapNode enode=new HeapNode(0,0,minSum,0,x);  
98. float bestc=Float.MAX_VALUE;  
99.   
100. //搜索排列空间树  
101. while(enode!=null&&enode.s<n-1)  
102. {  
103. //System.out.println(bestc);  
104. x=enode.x;  
105. if(enode.s==n-2)//叶子结点  
106. {  
107. if(a[x[n-2]][x[n-1]]!=-1&&  
108. a[x[n-1]][1]!=-1||  
109. bestc==Float.MAX_VALUE)//当前最优解还不存在的情况  
110. {  
111. bestc=enode.cc+a[x[n-2]][x[n-1]]+a[x[n-1]][0];  
112. enode.cc=bestc;  
113. enode.lcost=bestc;  
114. enode.s++;  
115. heap.put(enode);  
116. }  
117. }//if(enode.s==n-2)  
118.   
119. //if(enode.s!=n-2)  
120. else  
121. {  
122. for(int i=enode.s+1;i<n;i++)  
123. {  
124. if(a[x[enode.s]][x[i]]!=-1)  
125. {  
126. float cc=enode.cc+a[x[enode.s]][x[i]];  
127. float rcost=enode.rcost-minOut[x[enode.s]];  
128. float b=cc+rcost;  
129. if(b<bestc)  
130. {  
131. int []xx=new int[n];  
132. for(int j=0;j<n;j++)  
133. xx[j]=x[j];  
134. xx[enode.s+1]=x[i];  
135. xx[i]=x[enode.s+1];  
136. HeapNode node=new HeapNode(b,cc,rcost,enode.s+1,xx);  
137. heap.put(node);  
138. }//if(b<bestc)  
139. }//if 可行儿子结点  
140. }//for  
141. }//else,if(enode.s!=n-2)  
142.   
143. enode=(HeapNode)heap.removeMin();  
144. }//while  
145. for(int i=0;i<n;i++)  
146. v[i]=x[i];  
147. return (int)bestc;  
148. }//Class bbTsp  
149.   
150.   
151.   
152. //构造最小堆  
153. public static class MinHeap  
154. {  
155. private HeapNode[] heapArray; // 堆容器  
156. private int maxSize; // 堆的最大大小  
157. private int currentSize=0; // 堆大小  
158.   
159. //构造函数  
160. public MinHeap(int _maxSize)  
161. {  
162. maxSize = _maxSize;  
163. heapArray = new HeapNode[maxSize];  
164. currentSize = 0;  
165. }  
166.   
167. //自上而下调整  
168. public void filterDown(int start, int endOfHeap)  
169. {  
170. int i = start;  
171. int j = 2 * i + 1; // j是i的左子女位置  
172. HeapNode temp = heapArray[i];  
173.   
174. while (j <= endOfHeap)  
175. { // 检查是否到最后位置  
176. if (j < endOfHeap // 让j指向两子女中的小者  
177. && heapArray[j].cc > heapArray[j + 1].cc)  
178. {  
179. j++;  
180. }  
181. if (temp.cc <= heapArray[j].cc)  
182. { // 小则不做调整  
183. break;  
184. } else  
185. { // 否则小者上移，i，j下降  
186. heapArray[i] = heapArray[j];  
187. i = j;  
188. j = 2 * j + 1;  
189. }  
190. }  
191. heapArray[i] = temp;  
192. }//filterDown  
193.   
194. //自下而上的调整:从结点start开始到0为止，自下向上比较，如果子女的值小于双亲结点的值则互相交换  
195. public void filterUp(int start)  
196. {  
197. int j = start;  
198. int i = (j - 1) / 2;  
199. HeapNode temp = heapArray[j];  
200.   
201. while (j > 0)  
202. { // 沿双亲结点路径向上直达根节点  
203. if (heapArray[i].cc <= temp.cc)  
204. {// 双亲结点值小，不调整  
205. break;  
206. } else {// 双亲结点值大，调整  
207. heapArray[j] = heapArray[i];  
208. j = i;  
209. i = (i - 1) / 2;  
210. }  
211. heapArray[j] = temp; // 回送  
212. }  
213. }//filterUp  
214.   
215. //插入结点  
216. public void put(HeapNode node)   
217. {  
218. HeapNode newNode = node;  
219. heapArray[currentSize] = newNode;  
220. filterUp(currentSize);  
221. currentSize++;  
222.   
223. }//put  
224.   
225. //删除堆中的最小值  
226. public HeapNode removeMin()   
227. {  
228. HeapNode root = heapArray[0];  
229. heapArray[0] = heapArray[currentSize - 1];  
230. currentSize--;  
231. filterDown(0, currentSize - 1);  
232. return root;  
233. }  
234. }//class MinHeap  
235. }//class Main