0/1 knapsack problem knapsack problem

Transcription

1 1 (1) 0/1 knapsack problem. A thief robbing a safe finds it filled with N types of items of varying size and value, but has only a small knapsack of capacity M to use to carry the goods. More precisely, the knapsack problem is to find the combination of items which the thief should choose for his knapsack in order to maximize the total value of all the items he takes. It is called 0/1 since the items only can be taken as whole not a fraction. For example, suppose that he has a knapsack of capacity 17 and the safe contains many items of each of the sizes and values shown in the figure below. (Here, we use single-letter names for the items in the example and integers in the program.) Then the thief can take five A s (but not six) for total of 20, or he can fill up his knapsack with a D and an E for a total of 24, or he can try many other combinations. But which will maximize his total take? There are clearly many commercial situations in which a solution to the knapsack problem could be important. For example, a shipping company might wish to know the best way to load a truck or cargo plane with items for shipment. In such applications, other variants to the problem might arise as well: for example, there might be a limited number of each kind of item available. Many such variants can be handled with the same approach that we are about to examine for solving the basic stated above. In a dynamic programming solution to the knapsack problem, we calculate the best combination for all knapsack size up to M. It turns out that we can perform this calculation very efficiently by doing things in an appropriate order, as in the following program: For j:=1 to N do Begin For i:=1 to M do If i-size[j]>=0 then If cost[i]<(cost[i-size[j]+val[j]) then Begin cost[i]:=cost[i-size[j]]+val[j]; best [i[:=j; End;

2 End; In this program, cost[i] is the highest value that can be achieved with a knapsack of capacity I and best[i] is the last item that was added to achieve that maximum (as described below, this is used to recover the contents of the knapsack). First, we calculate the best we can do for all knapsack size when only items of type A are taken, then we calculate the best that we can do when only A s and The actual contents of the optimal knapsack can be computed with the aid of the best array. By definition, best[m] is included, and the remaining contents are the same as for the optimal knapsack of size M-size[best[M]]. Therefore, best[m-size[best[m]] is included, and so forth. B s are taken, etc. The solution reduces to a simple calculation for cost[i]. Suppose an item j is chosen for the knapsack: then the best value that could be achieved for the total would be val[j] (for the item) plus cost[i-size[j]] (to fill up the rest of the knapsack). If this value exceeds the best value that can be achieved without an item j, then we update cost[i] and best[i]; otherwise we leave them alone. A simple induction proof shows that this strategy solves the problem. The figure above traces the computation for our example. The first pair of lines shows the best that can be done (the contents of the cost and best arrays) with only A s, the second pair of lines shows the best that can be done with only A s and B s, etc.. The highest value that can be achieved with a knapsack of size 17 is 24. In the course of computing this result, we also solved may smaller sub-problems. For example, the highest values that can be achieved with a knapsack of size 16 using A s and B s and C s is 22. The actual contents of the optimal knapsack can be computed with the aid of the best array. By definition, best[m] is included, and the remaining contents are the same as for the optimal knapsack of size M-size[best[M]]. Therefore, size[best[m-size[m]]] is included, and so forth. For our example, best[17]=c; then we find another type-c item at size 10, then a type-1 item at size 3. (2) Traveling salesperson problem Given a graph with nonnegative lengths attached to the edges, we are required to find the shortest possible circuit that begins and ends at the same node, after having gone exactly once through each of the other nodes.

3 Let G = <V, E> be a directed graph. As usual, we take N = {1, 2,, n}, an the lengths of the edges are denoted by Lij, with L[i, i] = 0, L[i, j] 0 if i j, and L[i, j]= if the edge (i, j) does not exist. Suppose without loss of generality that the circuit begins and ends at node 1. it therefore consists of an edge (I, j), j 1, followed by a path from j to 1 that passes exactly once through each node in S N {1, j}. If the circuit is optimal (as short as possible), then so is the path from j to 1: the principle of optimality holds. Consider a set of nodes S N {1} and a node i N S, with i=1 allowed only if S = N {1}. Define g( i, S) as the length of the shortest path from node I to node 1 that passes exactly once through each node in S. Using this definition g(1, N {1}) is the length of an optimal circuit. By the principle of optimality, we see that g(1, N {1}) = min( L + g( j, N {1, j}). 2 j n 1, j (*) More generally, if i 1, S Φ, S N {1}, and i S, g( i, S) = min( L + g( j, S { j})). i, j j S (**) Furthermore, g( i, Φ ) = L, i = 2,3,..., n. i,1 The value of g( i, S) are therefore known when S is empty. We can apply (**) to calculate the function g for all the sets S that contain exactly one node (other than 1); then we can apply (**) again to calculate f for all the set S that contain two nodes (other than 1), and so on. Once the value of g( j, N {1, j}) is known for all the nodes j except node 1, we can use (*) to calculate g( j, N {1}) and solve the problem. Example1: Let G is the complete graph on four nodes given in Figure below.

4 We initialize g(2, ) = 5, g(3, ) = 6, g(4, ) = 8 and g(2,{3}) = L + g(3, ) = g(2,{4}) = L + g(4, ) = 18 and 24 g(3,{2}) = 18, g(3,{4}) = 20 g(4,{2}) = 13, g(4,{4}) = 15 Next, we use (**) for sets of two nodes, we have Finally we apply (*) to obtain g(2,{3, 4}) = min( L + g(3,{4}), L + g(4,{3})) = min(29, 25) = g(3,{2, 4}) = min( L + g(2,{4}), L + g(4,{2})) = min(31, 25) = g(4,{2,3}) = min( L + g(2,{3}), L + g(3,{2})) = min(23, 27) = g(1,{2,3, 4}) = min( L + g(2,{3, 4}), L + g(3,{2, 4}), L + g(4,{2,3}) = min(25, 40,43) = The optimal circuit in Example1 has length 35. To known where this circuit goes, we need an extra function: J ( i, S) is the value of j chosen to minimize g at the moment when we apply (*) or (**) to calculate J ( i, S ). Example2 (Continuation of Example1) In this example find

5 J (2,{3, 4}) = 4 J (3,{2, 4}) = 4 J (4,{2,3}) = 2 J (1,{2,3, 4}) = 2 And the optimal circuit is 1 J (1,{2,3, 4}) = 2 J (2,{3, 4}) = 4 J (4,3) = Let X be a sequence of n real numbers. (1) Sort the n real numbers in increasing order by Heap sort or Merge sort methods. Denote this increasing sequence of n real numbers as Y. (O(nlogn)) (2)Compute the longest common subsequence of X and Y using dynamic programming.(o(n 2 )) 4 (a) algorithm: Change (n) { Quarters=0; Dimes=0;

6 Nickels=0; While n>=25 Do { Quarters++; n=n-25 ;} While n>=10 Do { Dimes++; n=n-10 ;} While n>=5 Do { Nickels++; N=n-5 ;} Pennies=n;} (b) To prove this greedy choice yields an optimal solution, we must show optimal substructure and the greedy choice property. 1. Proof of Optimal Substructure: Let {C1, C2,, Cm} be the coins comprising an optimal solution to the coin-changing problem, where Ci is either a penny, nickel, dime or quarter, and the Ci.S sum to n, the change to be made. Putting aside the first coin choice C1, the remaining coins {C2,, Cm} represent a solution to the n-d(c1) coin-changing problem, where d(c) is the denomination of coin C. If {C2,, Cm} were not an optimal solution to the n-d(c1) change problem, then there exists another solution {a2,, ak}, where k<m; thus taking fewer coins. But if such a solution exists for n-d(c1), then combing it with C1 would yields a better solution to the n change problem. Since we started with an optimal solution, this is a contradiction, {C2,, Cm} must be an optimal solution to the subproblem n-d(c1), and the coin-changing problem exhibits optimal substructure. 2. Proof of the greedy choice property: Assume we have an optimal solution to the n-change problem {C1, C2,, Cm}. First, we know that the coins Ci add up to n no matter what order they are chosen, therefore, we can make any coin choice Cj swap with the first choice C1 and still yield an optimal solution. We have only to prove that greedy choice must reside somewhere in an optimal solution. Assume it does not. Then, one of the highest denomination coins less than n is not in the solution. But, that means that lower denomination coins must be used to obtain the amount of cents of the higher-denomination coin. Since it takes at least two lower-denomination coins to equal to the cents of a higherdenomination coin, we could always replace these coins with the greedy coin and obtain a better solution (fewer coins). Therefore, the greedy coin must be in the optimal solution. Thus, a greedy choice for the first coin will lead to an optimal solution. (c) The set {1, 20, and 50} will be the set. (Consider 60 cents)