The backtracking method to find the loading problem

1. Backtracking method

(1) Description: Backtracking method is an optimal search method, according to the selection criteria to search forward to achieve the goal. But when the exploration of a step, found that the original choice is not good or not reach the goal, then return to a step back to choose, such a failure to return to go back to the technology of backtracking .

(2) Principle: Backtracking method in the solution space tree of the problem, according to the depth first strategy , from the root node to search the solution space tree. When the algorithm searches to any point in the solution space tree, it first determines whether the node contains the solution of the problem. If it is not included, then the search for the subtree that the node is rooted is skipped, and its ancestor nodes are traced from layer to row; otherwise, go to the subtree and continue searching by depth-first policy .

The basic approach to backtracking is search, or a poorly organized search method that avoids unnecessary searches. This method is suitable for solving the problem that some combinatorial numbers are quite large. There are many problems with backtracking when it is necessary to find out its solution set or ask what solution is the best solution to satisfy certain constraints.

(3) The solution space of the problem

The solution vector of the problem: backtracking expects that the solution of a problem can be expressed as a form of n-ary (x1,x2,..., xn).

Explicit constraint: The value of the component Xi is qualified.

Implicit constraint: A constraint imposed on different components to satisfy the solution of a problem.

Solution space: For an example of a problem, the solution vector satisfies the explicit constraints of all multivariate groups, constituting a solution space for the instance.

Note: The same problem can be expressed in several ways, some of which are simpler and require a smaller state space (less storage and a simple search method).

(4) basic methods for generating problem states

Extension nodes: A node that is producing a son is called an extension node.
Slipknot Point: A node that has been generated by itself but whose son has not yet fully generated is called a biopsy.
Knot point: A knot that all sons have produced is called a knot point.
Depth-First problem state generation method: If an extension node R is created, once it has a son, C, it is treated as a new extension node. After completing the exhaustive search for the subtree C (subtree with root c), turn R into an extension node and continue to generate the next son of R (if present).

The problem state generation method of width first : It is an extension node until an extension node becomes a knot point.
Backtracking: In order to avoid generating problem states that are not likely to produce the best solution, it is necessary to continually use the bounding function to execute Slipknot points that are not actually possible to produce the desired solution, to reduce the computational effort of the problem. the depth-first generation method with the bound function is called backtracking .

(5) The basic idea of backtracking method

Basic idea:

A notable feature of solving problems by backtracking is that the solution space of the problem is generated dynamically during the searching process. At any point in time, the algorithm saves only the path from the root node to the current extension node. If the length of the longest path from the root node to the leaf node in the solution space tree is h (n), the computational space required for backtracking is usually O (h (n)). An O (2h (n)) or O (h (n)) is required to store the entire solution space explicitly. Memory space.

Problem Solving steps:

1) define the solution space of the problem for the given problem;
2) Determine the spatial structure of the solution that is easy to search;
3) Search the solution space in depth first, and use pruning function to avoid invalid search during the search.

Commonly used pruning function: The constraint function is used to cut off the sub-tree that does not satisfy the constraint at the extension node, and the sub-tree without the optimal solution is clipped by the limit function .

Recursive backtracking:

The backtracking method is a depth-first search for the solution space, so the backtracking method is implemented by recursive method in the general case.

 

iterative Backtracking:

using the non-recursive depth-first traversal algorithm of the tree, the backtracking method can be expressed as a non-recursive iterative process.

 

subset Tree : The corresponding solution space is called a subset tree When the given problem is to find a subset that satisfies a certain property from the set S of n elements. For example, the solution space tree for the 0-1 knapsack problem of that item is a subset tree. Such subset problems usually have 2^n leaf nodes, the total number of nodes is 2^ (n+1)-1. Any algorithm that traverses a subset tree requires an O (2^n) calculation time.

The general algorithm for traversing a subset tree by backtracking can be described as follows:

 

Arrange trees : When the given question is to determine the arrangement of n elements satisfying a certain nature, the corresponding solution space tree is called an arrangement tree . An arrangement tree usually has a n! leaf node. So traversing the arrangement tree requires O (n!) The calculation time.

The general algorithm for traversing the arrangement tree by backtracking can be described as follows:

Problem Description : There are a batch of n containers to be loaded with 2 load capacity of C1 and C2 ships, of which the weight of container I is WI, and, loading problems require to determine whether there is a reasonable loading scheme can be installed on these 2 ships. If so, find a loading scheme.

For example: When N=3,c1=c2=50 and w=[10,40,40], containers 1 and 2 can be installed on the first steamer, and container 3 is loaded on the second ship, if W=[20,40,40], the 3 containers will not be installed on the ship.

Basic idea : It is easy to prove that if a given loading problem has a solution, the following strategy can be used to obtain the optimal loading scheme.
(1) First ship as full as possible;
(2) Attach the remaining container to the second ship.
Fill the first ship as full as possible equivalent to selecting a subset of the container, so that the sub-centralized container weight of the nearest C1. The loading problem is equivalent to the following special 0-1 knapsack problem.

An O (2^n) Computational time algorithm for solving loading problems is designed by backtracking method. In some cases, the algorithm is better than the dynamic programming algorithm.

Algorithm design:

When the problem is solved by backtracking, it is obviously most suitable to use subset tree to represent its solution space. The sub-tree which does not meet the constraint condition can be cut by using the feasible constraint function. At the node z of the j+1 layer of the subset tree, the current load weight is recorded with CW, i.e., cw=, when the CW>C1, all nodes in the subtree with node Z root do not satisfy the constraints, so the solution in the subtree is not a solution, so the subtree can be cut off. ( the constraint function removes the infeasible solution and obtains all feasible solutions .)

an upper bound function can be introduced to cut down the subtree without the optimal solution, thus improving the operation efficiency of the algorithm on average . Set Z is the current extension node on the first layer of the space tree. CW is the current load capacity, BESTW is the current optimal load capacity, R is the weight of the remaining container, that is, r=. Defines the upper bound function as cw+r. The weight of any leaf node in a subtree with the root of z does not exceed cw+r. Therefore, when CW+R<=BESTW, you can cut the right subtree of Z.

2. #include "stdafx.h"
4. #include <iostream>
6. Using namespace std;
10. template<class type>
12. Type maxloading (type w[], type C, int n, int bestx[]);
16. int main ()
18. {
20. int n=3,m;
22. int c=50,c2=50;
24. int w[4]={0,10,40,40};
26. int bestx[4];
30. M=maxloading (W, c, N, BESTX);
34. cout<<"The load capacity of the ship is:" <<endl;
36. cout<<"C (1) =" <<c<<", C (2) =" <<c2<<endl;
40. cout<<"The weight of the container to be loaded is:" <<endl;
42. cout<<"W (i) =";
44. For (int i=1;i<=n;i++)
46. {
48. cout<<w[i]<<"";
50. }
52. cout<<endl;
56. cout<<"Retrospective selection result:" <<endl;
58. cout<<"m (1) =" <<m<<endl;
60. cout<<"x (i) =";
64. For (int i=1;i<=n;i++)
66. {
68. cout<<bestx[i]<<"";
70. }
72. cout<<endl;
76. int m2=0;
78. For (int j=1;j<=n;j++)
80. {
82. m2=m2+w[j]* (1-bestx[j]);
84. }
86. cout<<"m (2) =" <<m2<<endl;
90. if (M2>C2)
92. {
94. cout<<"because M (2) is greater than C (2), so the original problem no solution!"  "<<endl;
96. }
98. return 0;
100. }
106. Template <class type>
108. Type maxloading (type W[],type c,int n,int bestx[])//iterative backtracking, returns the optimal load weight and its corresponding solution, initializes the root node.
110. {
112. int i=1; //Current layer, x[1:i-1] is the current path
114. int *x=new int[n+1];
118. Type bestw=0, //Current optimal load weight
120. Cw=0, //Current load weight
122. r=0; //remaining container weight
126. For (int j=1;j<=n;j++)
128. {
130. R+=W[J];
132. }
136. While (true)//Search subtree
138. {
140. While (i<=n &&cw+w[i]<=c)//Enter the left sub-tree
142. {
144. R-=w[i];
146. Cw+=w[i];
148. X[i]=1;
150. i++;
152. }
156. if (i>n)//Reach Leaf junction
158. {
160. For (int j=1;j<=n;j++)
162. {
164. BESTX[J]=X[J];
166. }
168. BESTW=CW;
170. }
172. Else//Enter Right sub-tree
174. {
176. R-=w[i];
178. x[i]=0; i++;
180. }
182. While (CW+R<=BESTW)
184. { //pruning backtracking
186. i--;
188. While (i>0 &&!x[i])
190. {
192. R+=w[i];
194. i--;
196. }
198. //Return from right subtree
200. if (i==0)
202. {
204. delete []x;
206. return BESTW;
208. }
210. x[i]=0;
212. Cw-=w[i];
214. i++;
216. }
218. }
220. }

The backtracking method to find the loading problem