This observation leads to the following algorithm.

Transcription

1 126 Andreas Jakoby A Bounding-Function for the Knapsack Problem Finding a useful bounding-function is for most problems a difficult task. Let us consider the Knapsack Problem: Let us consider the version of the Knapsack Problem where also fractions of an item can be added to the knapsack. In this case the fraction ε, 0 ε 1, of an item j has weight ε w j and value ε v j. We call this version the rational Knapsack Problem. To solve the rationale Knapsack Problem we choose the item i that maximize the quotint v i /w i. It holds: For a weight ε wi with ε 1 we can get at most the value ε v i. This observation leads to the following algorithm.

2 Algorithm RationalKnapsack(n, V, W, M) Input: instance (V, W, M) with n items Output: optimal solution (x 0,..., x n 1 ) [0; 1] n for the rational Knapsack Problem, where x i is the fraction of item i in the solution. 1: sort the items according to the quotients v i /w i 2: let i 0,..., i n 1 be the resulting sequence of items 3: for j := 0 to n 1 do x j := 0 end for 4: let j := 0; V := 0; W := 0 5: while W M and j < n do 6: if W + w wij M then 7: x ij := 1; W := W + w ij ; V := V + v ij ; j := j + 1 8: else 9: x ij := M W w ij ; W := M; V := V + x ij v ij ; j := j : end if 11: end while 12: Return((x 0,..., x n 1 )) 127

3 Algorithm BoundingKnapsack(l, X akt, V akt, W akt ) Input: instance I = (V, W, M), best solution X opt found so far, value V opt of X opt (globally given) X akt = (x akt,0,..., x akt,n 1 ) with value V akt and weight W akt Output: new optimal solution X opt with value V opt (given globally) 1: if l = n then 2: if V akt > V opt then V opt := V akt ; X opt := X akt end if 3: else 4: if W akt + w l M then C l := {0, 1} else C l := {0} end if 5: for all x C l do 6: x akt,l := x 128

4 129 Andreas Jakoby 7: let I = (V, W, M W akt x w l ) be the instance I 8: restricted to items i > l 9: (x l+1,..., x n 1 ) :=RationalKnapsack(n l 1, 10: V, W, M W akt x w l ) 11: B := V akt + x w l + n 1 i:=l+1 x i w i 12: if B > V opt then 13: BoundingKnapsack(l + 1, X akt, V akt + x v l, W akt + x v l ) 14: end if 15: end for 16: end if

5 5.4 The Traveling Salesperson Problem Definition 12 [Traveling Salesperson Problem (TSP)] Given an undirected graph G = (V, E) and a weight matrix M = (m i,j ) i,j V where m i,j = if {i, j} E. 1 A Hamiltonian cycle is a sequence v 0, v 1,..., v n of nodes with v 0 = v n that visits each node exactly once. The weight of a cycle v 0,..., v n is defined as follows: cost(v 0,..., v n 1 ) := n 1 m vi,v (i+1) mod n. i:=0 Problem: Find a Hamiltonian cycle of minimum weight. 1 For easier notation we denote nodes by integers. 130

6 Algorithm TSP-Backtrack(l, C l 1, X akt, X opt, V opt ) Input: subset of node C l 1 not added to the actual cycle, prefix of a new trail X akt = x akt,0,..., x akt,l 1, optimal solution (found so far) X opt of value V opt Output: new optimal solution X opt of value V opt 1: if l = n then 2: V akt := cost(x akt ) 3: if V akt < V opt then V opt := V akt ; X opt := X akt end if 4: else 5: if l = 0 then C l := {0} end if 6: if l = 1 then C l := {1,..., n 1} end if 7: if l > 1 then C l := C l 1 \ {x akt,l 1 } end if 8: for each x akt,l C l do 9: (X opt, V opt ) := TSP-Backtrack(l + 1, C l, X akt x akt,l, X opt, V opt ) 10: end for 11: end if 12: Return(X opt, V opt ) 131

7 132 Andreas Jakoby 1. Bounding-Function For a set of nodes W V and a node x V let b(x, W ) := min w W m x,w be the minimum cost for a connection between x and a node of W. For a path X := x 0,..., x l 1 in G let X := V \ X and define the bounding function l 2 b(x l 1, X ) + X {x 0 }) for l < n BTSP(X ) := m xi,x i+1 + v Xb(v, i=0 m xl 1,x 0 for l = n. Note that every node of X {x l 1 } has to have a successor on the Hamiltonian cycle. Thus BTSP is a bounding-function that gives a lower bound for the length of every Hamiltonian cycle that contains X as a subpath.

8 Algorithm TSP-Bounding(l, C l 1, X akt, X opt, V opt ) Input: subset of node C l 1 not added to the actual cycle, prefix of a new trail X akt = x akt,0,..., x akt,l 1, optimal solution (found so far) X opt of value V opt Output: new optimal solution X opt of value V opt 1: if l = n then 2: V akt := cost(x akt ) 3: if V akt < V opt then V opt := V akt ; X opt := X akt end if 4: else 5: if l = 0 then C l := {0} end if 6: if l = 1 then C l := {1,..., n 1} end if 7: if l > 1 then C l := C l 1 \ {x akt,l 1 } end if 8: for each x akt,l C l with V opt BTSP(X akt x akt,l ) do 9: (X opt, V opt ) := TSP-Bounding(l + 1, C l, X akt x akt,l, X opt, V opt ) 10: end for 11: end if 12: Return(X opt, V opt ) 133

9 2. Bounding-Function To find a second bounding-function we modify the weight matrix as follows: 1. For each column of the weight matrix determine its minimum value and reduce the values of the matrix each by the corresponding minimum column value. 2. Than for each row of the modified weight matrix determine its minimum value and reduce the values of the matrix each by the corresponding minimum row value. Let redval be the sum of these minimum values. All entries of the resulting matrix have still positive values. But at least one entry of each column and of each row has value

10 Algorithm Redval(M) Input: k k-weight matrix Output: value of redval 1: redval:= 0 2: for i := 0 do k 1 do 3: row:= min j [0..k 1] m i,j 4: for j := 0 to k 1 do m i,j := m i,j row end for 5: redval:=redval+row 6: end for 7: for j := 0 do k 1 do 8: col:= min i [0..k 1] m i,j 9: for i := 0 to k 1 do m i,j := m i,j col end for 10: redval:=redval+col 11: end for 12: Return(redval) 135

11 Lemma 8 Redval(M) is a lower bound for the weight of every Hamiltonian cycle of a graph G with weight matrix M. Proof of Lemma 8: If we mark all edges of a Hamiltonian cycle in the weight matrix one can see that there is a marked entry m i,j in every row and every column. It can be shown, that the sum of these values is bounded (from below) by Redval(M). To compute the bounding-function we have to modify the weight matrix by using the actual path. 136

12 For a path X := x 0,..., x l 1 let X := V \ X. Let M X be the submatrix of the weight matrix M whose entries are subscribed by the nodes of X. We subscribe the columns and rows of M X by the nodes of X. M X M X X 137

13 138 Andreas Jakoby Now we add one column and one row to M X. E.g. at the column and row originally subscribed by x 0. At the positions of the new row we add the edge weight of the edge from the corresponding node of X to x 0. At the positions of the new column we add the edge weight of the edge from x l 1 to the corresponding node of X. The position where the new row and the new column intersect we insert the weight. Let M be the resulting matrix then we choose { l 2 Redval(M ) for l < n BTSP2(X ) := m xi,x i+1 + m xl 1,x 0 for l = n. i=0

14 139 Andreas Jakoby Algorithm BTSP2(X ) Input: a path X = x 0,..., x l 1 in G Output: a bounding-value 1: if l = n then 2: Return(cost(X )) 3: else 4: let M = (m i,j ) i,j [0..n l] be a n l + 1 n l + 1-matrix 5: let m 0,0 := ; j := 1; i := 1 6: for all v X do m 0,j := m x l 1,v ; j := j + 1 end for 7: for all v X do m i,0 := m v,x 0 ; i := i + 1 end for 8: i := 0 9: for all u X do 10: j := 1; i := i : for all v X do m i,j := m u,v ; j := j + 1 end for 12: end for 13: Return( l 2 i=0 m x i,x i+1 + Redval(M )) 14: end if

15 5.5 The MAXCLIQUE Problem Let us now consider the problem to determine the size of the maximum clique of a graph. This problem is again N P-hard. Based on the algorithm Clique-Backtrack we will now develop a new algorithm. 140

16 Algorithm MAXCLIQUE(l, X akt, C l 1, G, V opt ) Input: instance G, maximum size V opt of all cliques found so far, node set C l 1, and new trail to construct a clique X akt = x 0,..., x l 1 Output: maximum size of a clique 1: if l = 0 then C l := V else C l := C l 1 Γ(x l 1 ) B(x l 1 ) end if 2: if C l = then 3: if l > V opt then Return(l) else Return(V opt ) end if 4: else 5: for all x C l do 6: V opt :=MAXCLIQUE(l + 1, X akt x, C l, G, V opt ) 7: end for 8: end if 9: Return(V opt ) 141

17 We will now discuss a bounding-function for the MAXCLIQUE problem that is based on a coloring problem. We investigate the node coloring problem of the subgraph with node set C l : Find a color for every node of the graph such that no two adjacent nodes have the same color and a minimum number of colors are used. If we can color a graph G by k colors, then G has no clique of size k + 1! The coloring problem is N P-hard. Therefore we try to find a greedy algorithm that gives a good approximation for the coloring problem. 142

18 Greedy algorithm for the coloring problem: Let V = {0,..., n 1} be a set of nodes for the coloring problem. By N resp. [0..k 1] we denote the set of all colors. For a color h let CClass[h] denote the set of nodes that are colored by h. For a node v let Color[v] denote the color of v. 143

19 Algorithm Greedy-Color(G) Input: graph G Output: upper bound for the number of colors k 1: k := 0 2: for v = 0 to n 1 do 3: h := 0 4: while h < k and CClass[h] Γ(v) do h := h + 1 end while 5: if h = k then k := k + 1; CClass[h] := end if 6: CClass[h] :=CClass[h] {v} 7: Color[v] := h 8: end for 9: Return(k) 144

20 There are instances for the coloring problem, where Greedy-Color does not find an optimal solution. If the maximum degree of G is d, i.e. Γ(v) d for all nodes of the graph, then our algorithm finds a coloring of d + 1 colors. Using our algorithm Greedy-Color we determine an upper bound for the number of needed colors for every subgraph G l = (C l, E 2 C l ) reached by MAXCLIQUE. Thus we get also an upper bound for the maximum size of a clique of G l. The maximum size of a clique that includes X akt is bounded by X akt + Greedy-Color(G l ). 145

21 5.6 Branch-and-Bound Schema Using the bounding-function we try to find an order to traverse the backtracking-tree such that we can eliminate some additional candidates resp. subtrees. For a maximization problem we sort C l in decreasing order with respect to the value of the bounding-function. We consider the elements of C l according to the determined order. If we get a value of a solution for an element of C l that is close to the value of the bounding-function then we can eliminate all elements of C l whose bounding-value is smaller than the actual found optimal value i.e. these candidates cannot lead to an optimal solutions. 146

22 Algorithm BranchAndBound(l, X, X opt, V opt, I ) Input: depth l N, partial solution X := (x 1,..., x l 1 ), best solution X opt found so far with value V opt, instance I Output: optimal solution in comp(x ) {X opt } 1: if X is a valid solution then 2: V := val(i, X ) 3: if V > V opt then V opt := V ; X opt := X end if 4: end if 5: determine C l and F l = {(x, bound(i, X x)) x C l } 6: sort F l in decreasing order according to the second coordinate 7: let F l [1],..., F l [k] be the sorted sequence 8: for i = 1 to k do 9: let (x, B) := F l [i] 10: if B V opt then Return(X opt, V opt ) end if 11: (X opt, V opt ) := BranchAndBound(l + 1, X x, X opt, V opt, I ) 12: end for 13: Return(X opt, V opt ) 147

23 148 Andreas Jakoby 6 2-Party-Games 6.1 Types of 2-Party-Games A second category of optimization problem are 2-party-games: A game where 2 parties alternate to choose there move out of a finite set of possible alternative moves can be described as a tree. Each node of the tree represents a configuration of the game. The edges starting from node represent alternative moves. The game-tree of a 2-party-game is a generalization of the backtracking-tree (solution tree) of an optimization problem.

24 149 Andreas Jakoby For 2-Party-Games we distinguish between the following types of games randomized games, e.g. play dice or intermixing cards, and deterministic players, players with hidden information, e.g. games with closed cards, and players with complete knowledge, e.g. chess, checkers, or go. In a zero-sum-situation the winning situation of one party is the losing situation of the other party. The finale state of a game can be rated by a numeric value that determines the amount one player has to pay the second player. In a game with simple ginning or loosing conditions we can choose these values as +1 for winning and 1 for loosing. We choose 0 if we cannot find out how has won the game (e.g. for tie game).

25 150 Andreas Jakoby 6.2 Alpha-Beta-Search for 2-Party-Games Since the size of the game-tree is exponential for many games, we cannot completely search the game-tree. Thus we are looking for appropriate heuristics to determine uninteresting subtrees which can be skipped. This strategy correlates to the operation of the bounding-function in backtracking. For 2-party-games we consider two values: a α-bound, for the maximum profit, player 1 can achieve in the actual situation, and a β-bound, for the maximum profit, player 2 can achieve in the actual situation. In a zero-sum-situation the maximum profit of one party is the maximum loss of the second party.

26 The α- and β-bound of a node can be compute from the values of the predecessors by maximization or minimization depending on the party how is choosing the next move. We define a α-cut as follows: We do not continue to consider a configuration where player 1 has to choose his move because player 2 will never enter this configuration since an alternative move will lead to better bounds. A β-cut is defined simultaneously. 151