The Bin Packing Problem with Precedence

The Bin Packing Problem with Precedence Constraints Mauro Dell’Amico‡ , Jos´e Carlos D´ıaz D´ıaz‡ and Manuel Iori‡ ‡ DISMI, University of Modena and Reggio Emilia, Via Amendola 2, 42100 Reggio Emilia, Italy E-mails: {mauro.dellamico, manuel.iori, jose.diaz}@unimore.it

Abstract Given a set of identical capacitated bins, a set of weighted items and a set of precedences among such items, we are interested in determining the minimum number of bins that can accommodate all items and can be ordered in such a way that all precedences are satisfied. The problem, denoted as the Bin Packing Problem with Precedence Constraints (BPP-P), has a very intriguing combinatorial structure and models many assembly and scheduling issues. According to our knowledge the BPP-P has received little attention in the literature, and in this paper we address it for the first time with exact solution methods. In particular, we develop reduction criteria, a large set of lower bounds, a Variable Neighborhood Search upper bounding technique and a branch-and-bound algorithm. We show the effectiveness of the proposed algorithms by means of extensive computational tests on benchmark instances and comparison with standard integer linear programming techniques. Keywords: Bin Packing Problem, Precedence Constraints, Branch-and-Bound

1

Introduction

Given n items each having non-negative weight wj (j = 1, 2, . . . , n) and m bins of identical capacity C, the Bin Packing Problem (BPP) asks for the minimum number of bins that can accommodate all the items. Given a set of precedences among the items, the Bin Packing Problem with Precedence Constraints (BPP-P) is a generalization of the BPP that requires to order the bins in such a way that all precedences are satisfied. Intuitively speaking, precedences impose that the successors of an item are packed in bins that follow the bin accommodating such item, so as to model technical requirements arising in real-world applications. More formally, let us consider an acyclic digraph G0 = (V0 , A0 ) where V0 = {1, 2, . . . , n} contains a vertex j for each item j of the BPP, and each arc (j, k) ∈ A0 1

represents a precedence between item j and item k. In a feasible solution to the BPPP, the index of the bin containing item j must be strictly lower than that of the bin containing item k, for all (j, k) ∈ A0 . When no confusion arises we use equivalently item k or vertex k (representing item k). The BPP-P is NP-hard in the strong sense because it generalizes the BPP. A simple example of a BPP-P instance is given in Figure 1(a). The instance consists of nine items and eleven precedence constraints. The weights are reported under the items. The bin capacity is set to C = 10. The minimum number of bins needed to accommodate all items is five. An optimal solution is the one in which items 1 and 2 are packed in bin 1, items 3 and 5 in bin 2, items 4 and 6 in bin 3, items 7 and 8 in bin 4 and item 9 in bin 5, see Figure 1(b). It is easy to check that the corresponding BPP problem has an optimal solution made by just four bins, see Figure 1(c). 1

4 5

2

7 3

5 4

4

6 2

4

5 1

3

6 3

8

8 2 9 2

(a)

2

3

6 4

8

4

9 7

5

1

3

9 7

8

(b)

(c)

Figure 1: (a) A simple BPP-P instance (C = 10). (b) An optimal BPP-P solution. (c) An optimal BPP solution. The BPP is one of the most known and studied problems in combinatorial optimization, because of its practical relevance and of its nice combinatorial nature. The interest reader is referred to the surveys by Coffman et al. (1999) (approximation algorithms), Val´erio de Carvalho (2002) (linear programming methods) and Clautiaux et al. (2010) (lower bounds). The BPP-P inherits from the BPP all its great theoretical interest in combinatorial optimization. An extension of the BPP-P is the Generalized Bin Packing Problem (G-BPP), that was introduced by Garey et al. (1976) and consists of a multidimensional version of the BPP-P where items and bins have s ≥ 1 dimensions. In the G-BPP each item j has weights wj1 , wj2 , . . . , wjs and each bin has capacities C 1 , C 2 , . . . , C s . The problem asks for a packing of all the items in the minimum number of bins, so that the bin capacities are not exceeded and the precedences are satisfied. In Garey et al. (1976) the authors presented simple heuristic algorithms and proved an asymptotic worst case performance of 2.7 for the BPP-P. However, no computational results were given. 2

Recently Augustine et al. (2009) considered an adaptation to the BPP-P of the well known Next Fit algorithm for the BPP and proved an absolute worst case performance of 3. They studied the BPP-P as a particular case of the Strip Packing Problem with Precedence Constraints (SPP-P). In the SPP-P a set of two-dimensional rectangles must be placed within a strip of given width, without overlapping and rotation, by minimizing the height used in the strip. When a precedence between two rectangles r and s exists, the top of r must be placed at a height smaller than or equal to the bottom of s. In the case of rectangles of identical height H the problem is equivalent to a “90◦ rotated” BPP-P: Each rectangle corresponds to an item and the bins are given by identical shelves of height H. Figure 1(b) can be seen as a solution of the SPP-P induced by Figure 1(a), in which 5 shelves of identical height are cut from a strip of width 10. Another combinatorial problem that is related to the BPP-P is the Simple Assembly Line Balancing Problem (SALBP). The SALBP is indeed a variation of the BPP-P in which the precedence constraints are not strict (i.e., the index of the bin containing item j must be lower than or equal to that of the bin containing item k, for all (j, k) ∈ A0 ). The SALBP has received a large attention in the literature. The interested reader is referred to the surveys by Becker and Scholl (2006) and Scholl and Becker (2006). Further problems related to the BPP-P are the Bin Packing Problem with Conflicts (BPPC) and the Ordered Open End Bin Packing Problem (OOEBPP). In the BPPC the precedence constraints are replaced by incompatibilities among items. This problem has been recently addressed by Gendreau et al. (2004), Khanafer et al. (2010) and Fernandes Muritiba et al. (2010). In the OOEBPP a total order among the items of a BPP instance is given in input. The last item among those packed in the same bin is allowed to exceed the bin capacity. The precedences among the items are thus important “inside the bin”. Effective lower and upper bounds for the OOEBPP have been proposed by Ceselli and Righini (2008). Concerning applications, following Garey et al. (1976), one can see that the BPP-P is a special case of a multiprocessor scheduling problem with a single resource constraint. The items are unit tasks to be executed respecting the precedence constraints and using no more than C units at a time, from a single renewable resource. The BPP-P solution minimizes the time schedule, with the items assigned to the same bin being simultaneously executed (it is assumed that there are sufficiently many processors to accommodate the tasks to be executed simultaneously). Another application derives from assembly line balancing problems where strict precedences must be kept, as in the Motorola case-study described by Tirpak (2008). In this problem some parts have to be placed before placing a metal shield that covers them, inducing strict precedences between the parts and the shield. Finally, in Augustine et al. (2009) it is shown that the BPP-P models the problem of dynamic reconfiguration 3

of FPGAs (Field-Programmable Gate Arrays) when image processing applications, as JPEG encoding, are implemented on modern devices such as Virtex Xilinx Series (www.xilinx.com). The main interest of this paper is to present for the first time algorithms for optimally solving the BPP-P. To this aim, we propose a series of techniques that exploit the combinatorial structure of the problem. The remaining of the paper is organized as follows. In Section 2 we introduce our notation, present some ways to lift item weights and reduce the size of the instance, and give an integer linear program that models the BPP-P. In Section 3 we propose a large set of lower bounds and analyze their worst case behavior. In Section 4 we give simple greedy upper bounds and extensions based on local search and Variable Neighborhood Search. In Section 5 we present branch-and-bound algorithms that make use of different branching schemes. Finally in Section 6 we evaluate the performance of the above techniques by means of extensive tests on a large number of benchmark instances originally proposed for the SALBP.

2

Notation and preliminary results

We first introduce some preliminary notation. We work on a digraph G = (V, A) generated from G0 = (V0 , A0 ) in the following way. We add to V0 a dummy start vertex 0 and a dummy end vertex n + 1. We connect 0 to each vertex j ∈ V0 having indegree equal to 0, and connect each vertex j ∈ V0 having outdegree equal to 0 to n + 1. Note that no item is associated to the dummy vertices, and only vertices in V0 correspond to items to be packed in bins. The new digraph G is weakly connected and acyclic. Following the common notation used in the literature we call G the precedence digraph. We create a matrix c, in which cjk is the length of the longest path, computed as number of arcs, from j to k in G. We set cjk = 0 if no such path exists. Since G is acyclic, we can compute any of such longest paths by applying the classical Critical Path Method (CPM), see, e.g., Kelley (1961). The CPM runs in O(|A|) time, and gives the length of the longest path from a given starting vertex to any other vertex in the digraph. Hence, we need O(|V ||A|) time to fill matrix c. Let us define headj = c0j as the length of the longest path from the dummy start vertex to item j, and note that this represents a lower bound on the minimum index of the bin that can contain item j. Let us also define tailj = cj,n+1 as the length of the longest path from item j to the dummy end vertex n + 1. The value tailj − 1 represents instead a lower bound on the difference between the optimal solution value and the index of the bin containing item j. In the following we suppose items are sorted by non-decreasing values of headj . 4

Given a lower bounding procedure we are interested in evaluating the performance that it can guarantee. Given an optimization problem P , let z(P ) denote the optimal solution value of an instance of P , and let L(P ) be the value produced by a lower bounding procedure L. The worst case approximation ratio of the lower bounding procedure L is the maximum real value ε ≤ 1 such that ε ≤ L(P )/z(P ) for all instances of problem P . We say that a worst case performance ratio ε is tight if for any ε0 < ε, there exists an instance I for which the performance of L is worse than ε0 .

2.1

Preprocessing

The following pre-processing procedure can be applied to lift the item weights and possibly reduce the size of the instance. For every item j we consider the set of items that can be packed in the same bin with j, i.e., those items k for which cjk = ckj = 0 and wj + wk ≤ C. Let us define γ(j) the resulting set (j = 1, 2, . . . , n). For every item j, we solve the following Subset Sum Problem (SSP): Given a bin of capacity C − wj and the set of items γ(j), determine the subset of items of largest total weight that can be packed in the bin. Let σ(j) be the solution value of the problem. The bin containing item j cannot contain more than wj + σ(j) total weight. Hence, we lift the weight of item j to wj + (C − σ(j)). After the weight of item j has been possibly updated, the procedure is re-executed for item j + 1, and so on for any item in order. If a set γ(j) is empty, the weight of item j is lifted to C, hence we simply erase j from the instance. In this case the precedence digraph is modified by deleting vertex j and all the arcs incident on j, and then creating new arcs between any predecessor and any successor of j. Matrix cjk and arrays headj and tailj are updated accordingly. Once the procedure has been applied to the last item, we check if at least one lifting has been produced. If this is the case, the procedure is re-started once again from the first item. The procedure terminates when no lifting is found for all items. This lifting procedure can be enhanced by solving a generalized SSP that takes into account the precedence constraints. Let us consider the SSP associated to item j, and let us note that two items k and ` with ck` > 0 or c`k > 0 cannot be packed together into the bin containing item j. Following a common notation we can say that these two items are in conflict (or incompatible). We can thus define the following Subset Sum Problem with Conflicts (SSPC): Given a bin of capacity C − wj , the set of items γ(j), and a set T of edges representing pairwise incompatibilities among the items in γ(j), determine the subset of items of largest total weight that can be packed in the bin without violating bin capacity and incompatibilities. The problem is strictly related to the knapsack problem with conflicts (also known as the disjunctively constrained knapsack problem), in which items have a profit that may be different from the weight. Such problem has been solved by Hifi and Michrafy (2007) through branch-and-bound 5

algorithms, and by Fernandes Muritiba et al. (2010) through a mathematical model. We use an approach similar to that used in Fernandes Muritiba et al. (2010) and solve the SSPC by means of the following simple mathematical model. Let xk be a binary variable taking value 1 if item k is packed and 0 otherwise, k ∈ γ(j). We obtain: X (SSPC) max w k xk (1) k∈γ(j)

s.t.

X

w k xk ≤ C − w j

(2)

k∈γ(j)

xk + x` ≤ 1 xk ∈ {0, 1}

∀(k, `) ∈ T ∀k ∈ γ(j).

(3) (4)

It is worth noting that the SSP is only weakly NP-hard, whereas the SSPC is strongly NP-hard (as it generalizes the problem of finding the stable set of maximum weight). To reduce the computational effort, the procedure based on the SPPC is applied just once for each item, without any re-start. We refer to Section 6 for details on the computational results obtained by using these two procedures.

2.2

A mathematical model

We model the BPP-P as an integer linear program (ILP) by defining two binary variables: yi takes value 1 if bin i is used, 0 otherwise (i = 1, 2, . . . , m); xij takes value 1 if item j is assigned to bin i, 0 otherwise (i = 1, 2, . . . , m, j = 1, 2, . . . , n). We obtain: m X (BPP-P) min yi (5) i=1

s.t.

n X

wj xij ≤ Cyi

i = 1, 2, . . . , m

(6)

j = 1, 2, . . . , n

(7)

i = 1, 2, . . . , m, (j, k) ∈ A0

(8)

j=1 m X

xij = 1

i=1

xik ≤

i−1 X

xhj

h=1

yi ∈ {0, 1} xij ∈ {0, 1}

i = 1, 2, . . . , m i = 1, 2, . . . , m, j = 1, 2, . . . , n.

(9) (10)

The objective function asks for the minimization of the number of bins, constraints (6) impose the capacity restriction and constraint (7) require that each item is assigned to 6

a bin. Constraints (8) impose the precedences between items: If k is assigned to bin i, then any predecessor j of k must be assigned to a bin in the range 1, 2, . . . , i−1. Model (5)–(7), (9)–(10) is the classical model for the BPP (see Martello and Toth (1990)). Constraints (8) are directly derived from those used to model loose precedences in the SALBP, with the only difference that in the SALBP the range is 1, 2, . . . , i (see Baybars (1986) and Scholl (1999)).

3

Lower bounds

We first produce some simple lower bounds by considering separately the BPP component and the precedence digraph component of the problem. We then combine together the considerations on these two components to obtain better lower bounds.

3.1

Lower bounds from the BPP

Given a BPP-P instance, an immediate relaxation can be obtained by removing the precedence constraints, thus obtaining a BPP instance. Any lower bound valid for the BPP instance gives also a valid lower bound for the BPP-P one. Unfortunately all these bounds have arbitrarily bad worst case performance ratio, as one can see by considering an instance of BPP-P with n items each of weight C/n, and precedence constraints forming a single path from item 1 to item n. The optimal solution of the BPP-P has trivial solution value z(BPP-P) = n, while the corresponding BPP instance has solution value z(BPP) = 1 (since all items can be packed into a single bin). When n tends to infinity, the ratio z(BPP)/z(BPP-P) tends to zero. Despite their worst case performance, these bounds can be useful on average. We consider in particular the simple lower bound obtained by rounding up the optimal solution of the continuous relaxation of the BPP instance: ' & Pn w j j=1 . (11) L1 = C

3.2

Lower bounds based on the longest path computation

Further lower bounds can be obtained by taking into account only the precedence constraints. We first note that given any item j, headj + tailj − 1, i.e., the length of the longest path from 0 to n + 1 going through j, is a valid lower bound. A better bound can be achieved by computing, through the CPM, the longest path from vertex 0 to vertex n + 1 in G. We obtain: L2 = c0,n+1 − 1. 7

(12)

Note that also L2 has an arbitrarily bad worst case performance, as can be easily verified by considering a BPP-P instance with no precedence constraints at all.

3.3

Better lower bounds

Better lower bounds can be obtained by combining together the BPP component and the precedence digraph component of the BPP-P. 3.3.1

Lower bound L3 .

An immediate improved bound is: L3 = max{L1 , L2 }. Theorem 1 The worst case performance ratio of lower bound L3 is is tight.

(13) 1 3

and the bound

Proof.Proof. We consider a BPP-P instance and construct a heuristic solution through a procedure whose first step is to assume infinite capacity for the bins. Indeed, let us call H the solution obtained by disregarding the bin capacity and assigning each item j to bin headj , and observe that H uses exactly L2 bins. We consider, in turn, each bin i of H, and define I(i) the set of items currently assigned to this bin. By construction there are no precedence constraints between any pair of items in I(i), so determining the minimum number of bins that can accommodate the items in I(i) denotes a pure BPP instance. We optimally solve this BPP instance obtaining the optimal value `i , and we replace bin i with the solution obtained (i.e., we modify our current BPP-P solution H by interposing `i bins between bins i − 1 and i + 1, so as to feasibly pack the items of I(i)). By reiterating this process for each bin of H whose total weight exceeds C, we obtain a feasible BPP-P solution. We now show that this solution has length not larger than 3L3 . One can prove that in any optimal BPP solution at most one bin may be loaded with a total weight smaller than C/2 (see Martello and Toth (1990)), hence X C (`i − 1) ≤ wj 2

for all i.

(14)

j∈I(i)

PL2 Let ` = i=1 (`i − 1) be the total number of bins added to the starting solution H. P Summing up both members of (14) and using (11) we immediately obtain ` ≤ 2 nj=1 wj /C ≤ 2L1 . Since the starting solution has L2 bins, the heuristic solution H uses a number of bins not larger than L2 + 2L1 ≤ 3L3 and we have just proved the first part of our thesis. 8

To prove that the performance ratio 13 is tight, it is enough to consider an instance with n = 3k items with weights   j = 1, 2, . . . , k; wj = (15) C/2 +  j = k + 1, k + 2, . . . , n. Items 1, 2, . . . , k are connected by precedences defining a unique chain from 1 to k. For each item j = k + 1, k + 2, . . . , n there is a precedence (k, j). One can see that in any optimal solution each item j = 1, 2, . . . , k is assigned to bin j, while the remaining items are assigned one for each bin, thus giving a solution with n = 3k bins. Lower bound L2 has value k + 1, whereas for  sufficiently small lower bound L1 has value ' &   k + 2k( C2 + ) 3k = k + 1. (16) =k+ L1 = C C It follows that the ratio (k + 1)/3k between the lower bound value and the optimal solution value is arbitrarily close to 1/3 when k tends to infinity.  

3.3.2

Lower bound L4 .

The next valid lower bound we developed takes inspiration from the constrained packing lower bound proposed by Gendreau et al. (2004) for the BPPC. For this new bound we will also assess the worst case performance (note that no discussion on worst case performances is given for the bound presented in Gendreau et al. (2004)). We start by partitioning the set of items into two subsets: P and Q = V0 \ P , where P is the set of items on a longest path. We initialize L2 = |P | bins by assigning an item of P to each bin. Then we pack the maximum quantity of the items of Q into these bins, by allowing to pack fractions of items. A max-flow problem is solved to find this optimal fractional packing. Let f be the resulting flow value and observe that the items that have not been packed in the first L2 bins must be assigned to additional bins. We thus obtain the lower bound:  P j∈Q wj − f . (17) L4 = L2 + C The max flow problem we solve is as follows. We create a bipartite digraph G = {Q∪P, A}, where each item defines a vertex of either layer. The arc set A contains an arc (j, k) for each item j ∈ Q and each item k ∈ P such that two necessary conditions for a feasible assignment of j and k to the same bin hold. The two conditions are: 9

Condition 1) cjk = ckj = 0 (no precedence constraint between the two items); Condition 2) wj + wk ≤ C (the total weight does not exceed the bin capacity). We then extend G by adding a source vertex s and a terminal vertex t. We connect s to every item j ∈ Q with arcs of capacity wj , and connect every item k ∈ P to t through arcs of capacity C − wk . The capacity of the arcs (j, k) from Q to P is set to wj . The maximum flow from s to t on this digraph gives the required flow f . In Figure 2 we report the digraph and a maximum flow solution obtained when applying L4 to the instance presented in Figure 1(a). The critical path is P = (1, 4, 7). The two numbers over the arcs give, respectively, the capacities and the flows on the arcs. Arcs (2,4), (2,7), (3,4), (3,7), (5,1), (8,1), (8,4) and (9,1) are not included in A because of condition 1, and arcs (9,4) and (9,7) because of condition 2. The resulting flow is f = 13, hence L4 = 3 + d(23 − 13)/10e = 4. 2

s

4,3 3,2 2,2 2,2 4,4 8,0

4,3 3,2

3

2,0 2,1

5

2,1 2,1 2,1 4,4

6 8 9

1

5,5 7,2

4 7

6,6

t

P

Q

Figure 2: Computation of L4 for the instance of Figure 1(a). It is clear that lower bound L4 dominates L2 . Moreover we can observe that X X wj . (18) (C − wj ) = C · L2 − f≤ j∈P

j∈P

Combining (17) and (18) we obtain P P P  P  j∈Q wj − (C · L2 − j∈P wj ) j∈Q wj + j∈P wj L4 ≥ L2 + = = L1 . C C Hence, L4 dominates both L1 and L2 , and thus also L3 . The worst case performance of L4 is assessed as follows. Theorem 2 The worst case performance ratio of lower bound L4 is is tight. 10

1 2

and the bound

Proof.Proof. We start as in the proof of Theorem 1 by building a solution H obtained by disregarding the bin capacity and assigning each item j to bin headj . We consider, in turn, each bin i of H, and define I(i) the set of items currently assigned to this bin. Let us call p(i) the item of the longest path assigned to bin i. We solve a SSP with item set I(i)\{p(i)} and bin capacity C − wp(i) . Let S(i) ⊆ I(i)\{√(i)} be the optimal SSP solution, let t(i) be the smallest item in I(i) \ {S(i) ∪ {p(i)}} and R(i) = I(i) \ {S(i) ∪ {p(i)} ∪ {t(i)}}. Note that in the optimal L4 max flow solution, the flow sent to any bin i is at most equal to the residual bin capacity C − wp(i) , which is smaller than or equal to the total weight of the items in S(i) ∪ {t(i)}. Summing up on all bins we have   L2 X X wt(i) + f≤ wj  . i=1

j∈S(i)

SL2

S 2 By recalling that Q = V0 \P and P = i=1 {p(i)}, we know that Q = Li=1 (S(i) ∪ {t(i)} ∪ R(i)). SL2 Let R = i=1 R(i) and compute the total weight of the items in R as   L2 X X X X X wt(i) + wj − f. (19) wj − wj  ≤ wj = j∈R

j∈Q

i=1

j∈Q

j∈S(i)

Now we obtain a feasible solution from H by replacing each bin i with a number of feasible bins as follows. We create a first bin with item p(i) and the items in S(i). We then solve a BPP for the items in R(i) obtaining `i bins. There are two cases: A) Item t(i) can be packed in the bin with smallest load in the BPP solution, “smallest bin” for short. In this case we add to H `i bins containing the items in R(i) ∪ {t(i)}. We have already observed, see (14), that in any BPP P solution all bins but one have load not smaller than C/2, hence C2 (`i − 1) ≤ j∈R(i) wj . Let δ(i) be the number of bins that we add to H. We have 2 X δ(i) = `i ≤ 1 + wj (20) C j∈R(i)

B) Item t(i) cannot be packed in the smallest bin. In this case all the `i bins in the BPP solution have load not smaller than P C/2 (remind that t(i) is the smallest bin in R(i) ∪ {t(i)}), hence C2 `i ≤ j∈R(i) wj . We pack t(i) alone in one additional bin and obtain 2 X δ(i) = 1 + `i ≤ 1 + wj (21) C j∈R(i)

11

By summing up on all bins and using (19), (20) and (21) we obtain: zH =

L2 X

P (1 + δ(i)) ≤ 2L2 + 2

j∈R

i=1

wj

C

P ≤ 2L2 + 2

wj − f ≤ 2L4 . C

j∈Q

To prove that the bound is tight it is enough to consider an instance with no precedence and n items, each of weight C2 + ε, with ε being a small positive number. In   this case L4 = L1 = n2 + 1, while the optimal solution uses n bins. We note that it is not difficult to modify the above proof to assess the worst case performance of 21 for the bound proposed by Gendreau et al. (2004) for the BPPC. 3.3.3

Lower bound L5 .

The last lower bound we present in this section exploits the head and tail values. Consider the set of items having head at least r and tail at least q, and compute a lower bound on the number of bins that can be used to pack such items. In a feasible BPP-P solution, at least r − 1 bins precede the bins used to pack this set of items, and at least q − 1 bins follow them. More formally, let Sr,q ⊆ V0 be the set of items j such that headj ≥ r and tailj ≥ q. A valid lower bound is computed as: L5 (Lα ) =

max

r, q = 1, 2, . . . , c0,n+1 − 1 r + q ≤ c0,n+1

{Lα (Sr,q ) + r + q} − 2,

(22)

where Lα is any valid BPP-P lower bound. Despite its simplicity, L5 (Lα ) achieves very good results, as shown in Section 6.1. Note that the worst case of L5 (Lα ) is not worse than that of Lα , because Sr,q ≡ V0 when r = q = 1.

3.4

Further improvements on the above lower bounds

Two kinds of improvements are discussed in this section. The first set of improvements that we consider is once again based on the BPP component of the problem. Indeed, we can improve most of the algorithms we produced in the previous sections by considering better BPP lower bounds. According to our knowledge, the most recent and comprehensive paper on this topic is the one by Crainic et al. (2007). According to the computational comparisons in this work, we decided to use the classical dual feasible functions (DFF). A function Pf : [0, 1] → [0, 1] Pis dual feasible if, for any finite set S of real numbers, the relation x∈S x ≤ 1 ⇒ x∈S f (x) ≤ 1 holds. In practice, these functions are 12

used to modify item weights so as to obtain valid lower bounds for a BPP instance. In the following we suppose that xj = wj /C. Some heuristic rules for determining valid DFF in short time have been presented in the literature. Among these we cite: DFF 1: Let k ∈ N, then uk (x) = x if (k + 1)x ∈ Z, uk (x) = b(k + 1)xc k1 otherwise is a DFF. The function was introduced by Fekete and Schepers (2001). Crainic et al. (2007) report that the best compromise between lower bound quality and computational effort is obtained by attempting all the values of k in the set {1, 2, . . . , 20}. DFF 2: Let  ∈ (0, 1/2], then U  (x) = 1 if x > 1 − , U  (x) = x if  ≤ x ≤ 1 − , U  (x) = 0 if x <  is a DFF. The function was introduced by Fekete and Schepers (2001). Haouari and Gharbi (2005) report that good values for  are those item weights that are lower than or equal to half the capacity of the bin, S including the half capacity value, i.e.,  ∈ Σ = {xj ∈ (0, 1/2]} {1/2}. −1

−1

c c if x > 1/2, η  (x) = bx DFF 3: Let  ∈ (0, 1/2], then η  (x) = 1 − b(1−x) b−1 c b−1 c if  ≤ x ≤ 1/2, η  (x) = 0 if x <  is a DFF. The function was introduced by Boschetti and Mingozzi (2003) and improves a previous one by Fekete and Schepers (2001). On the basis of our computational results, we empirically 2 1 , 1000 , . . . , 12 }. determined that good values for  are in the set { 1000

We use the above functions to produce valid lower bounds for the BPP-P. In particular we use the classical lower bound introduced by Fekete and Schepers (2001), which combines together DFF DFF basis of the notation used by the authors P  2. On theP P 1 and    k U (x) and η (I) = u (x) , U (I) = we define uk (I) = x∈I η (x) x∈I x∈I and we obtain:   k LF S = max Ldff 2 (I), max LF S (I) , (23) k=1,2,...,20

 P k  where Ldff 2 (I) = max∈Σ U  (I) and LkF S (I) = max∈Σ u (U (x)) . We provide x∈I another simpler but effective lower bound, obtained by computing:   k  Ldff = max Ldff 2 , max u (I), max η (I) . (24) k=1,2,...,20

∈(0,1/2]

The worst case performance of LF S and Ldff is yet arbitrarily bad, but in practice they can provide a help, both as a lower bounding technique for the BPP-P instance, and even more as a sub-procedure used to lift other BPP-P lower bounds, as shown below. The second idea that we use to improve our lower bounds is based on the precedence digraph component of the problem. One can note that new arcs can be added 13

to the precedence digraph whenever a certain distance between the indices of the bins accommodating two items can be estimated. This distance can be evaluated by studying the set of items that separates a given pair of items. More precisely, let us define Sep(j, k) as the set of items belonging to at least one path in G from j to k (separators set). We create a new digraph Gβ = (V, Aβ ) through the following steps: 1) we initialize Aβ = A and associate to each arc a cost equal to one; 2) we select a lower bounding procedure, say Lβ ; 3) we compute the value Lβ (Sep(j, k)) for each pair of items j and k not connected by an arc in G; 4) if this value is greater than 1, we add a new arc (j, k) to Aβ and set its cost to Lβ (Sep(j, k)) + 1. Finally we obtain a lifted matrix cβ by re-evaluating the longest paths between any pair of vertices in Gβ , with respect to the new costs of the arcs. By using this lifted digraph we obtain the following sets of lower bounds: Lβ2 , Lβ3 and Lβ5 (Lα ) with all combinations of Lα = {L1 , Ldff , LF S } and Lβ = {Ldff , LF S , L4 , L+ 4 , L5 (L1 ), L5 (Ldff ), L The lower bounding procedure denoted L+ starts by lifting G with L . Then, for each 4 4 arc (j, k) belonging to the longest path in Gβ and having cost at least 5, it tries to optimally solve the subproblem induced by Sep(j, k) by executing the branch-andbound procedure described in Section 5 with a time limit of 5 CPU seconds. The cost of arc (j, k) is then possibly updated with the optimal solution value, if any, and L2 is computed on the resulting digraph. We did not test lower bound L4 on the lifted digraphs, as the lifting does not affect the path P containing the largest number of arcs (used in L4 ). Considering instead in L4 the longest path (as sum of costs) in the lifted digraph could worsen the efficacy of the bound, as the number of bins created before the max flow execution could be smaller.

4

Upper bounds

We make use of some simple heuristic strategies to look for good quality solutions within small computational effort. We first invoke the classical First Fit Algorithm, whose adaptation to the BPP-P, originally proposed in Garey et al. (1976), simply requires to check not only the weight constraint but also the precedence constraints. It works as follows: Pack the first item in the first bin, then pack each subsequent item j in the first feasible (with respect to weight and precedence constraints) bin, if any, otherwise open a new bin and pack j in such bin. We improve the solution obtained by the greedy algorithm with a local search procedure, defined LS in the following, based on iterated executions of two inner procedures. The first inner procedure, called MOVE, works as follows. For any item j, in order, we check if it is convenient to remove j from its current bin i, and pack it into another bin h. We perform this move if 1) it is feasible with respect to precedence and weight constraints, and 2) it allows the solution to become more unbalanced in 14

the weight distribution, so as to facilitate further moves and hopefully make a bin empty. To evaluate the solution balance we define loadi as the total load of bin i and loadh as that of bin h. The move is performed if loadh > loadi − wj . The first feasible and profitable move, if any, is performed. Then, the procedure is re-executed starting from the first item. The process is re-iterated until the upper bound and the lower bound values are equal, or no more profitable move exists. The second inner procedure, called SWAP, works as MOVE, but tries to swap all pairs of items, say j1 and j2 , assigned to different bins, say i1 and i2 . The swap is performed if wj2 > wj1 and loadi1 − wj1 > loadi2 − wj2 . The overall procedure LS is re-iterated, by re-executing first MOVE and then SWAP, until the upper bound and the lower bound values are equal, or when no more profitable move of any of the two types exists. We extended the local search by means of a Variable Neighborhood Search (VNS) method, based on the classical template described, e.g., in Hansen et al. (2008). We use two versions of the VNS algorithm. The first version starts with the solution obtained by assigning each item j to bin headj . This solution is possibly infeasible because of weight excess, so it is optimized by a version of LS, denoted LS0 , that in case of an infeasible solution selects the first move that reduces the total weight excess. If instead the solution is feasible, LS0 operates as LS. At each iteration we modify the incumbent solution by means of a k-exchange neighborhood that works as follows. First, it removes k random items from the bins they are assigned to. Then, it reassigns each of these items according to their input order. Suppose item j has been picked up from bin i and now is being reassigned. The algorithm finds the first and last bin, say i1 and i2 , in which item j can be packed according to the precedence constraints. Note that we have i1 ≤ i ≤ i2 because of the precedence constraints. The algorithm scans the set of bins {i1 , i1 + 1, . . . , i2 } \ {i}, if any, in increasing order of index. As soon as it finds a bin that can accommodate item j without violating weight constraint, then it packs j in this bin and re-iterates with the next item. If no such bin exists, the algorithm inserts a new bin between bins i − 1 and i and packs j in it. The new solution is then improved by means of LS0 . As long as no feasible solution is found, the incumbent solution is equal to the starting solution, otherwise it is equal to the feasible solution using the smallest number of bins. The value of k is initially set to 1. If the use of the k-exchange neighborhood followed by the local search allows us to improve the incumbent solution, then we re-iterate with k = 1, otherwise we re-iterate by increasing the value of k by one unit. If at an iteration the value of k exceeds a certain threshold value kmax , then we set again k = 1. On the basis of computational outcome we set kmax = 7. This procedure is executed until a certain time limit is reached or whether the upper bound is equal to the lower bound. The second version of the VNS algorithm works as the first one, but starts with the solution obtained by the First Fit algorithm and then uses LS, so moves in the 15

space of feasible solutions.

5

Branch-and-bound algorithms

We implemented branch-and-bound schemes that make use of the above lower and upper bounding procedures at the nodes of an enumeration tree. We tested different options in order to achieve the best performance. We particularly focused on the use of different branching schemes. The first branching scheme we use follows the footsteps of the classical branch-andbound algorithm developed by Martello and Toth (1990) for the BPP, but additionally takes into consideration the precedence constraints. The enumeration tree has one level for each item, in the input order. The branching rule consists in packing item j (associated with level j) in any bin that can accommodate it. The second branching scheme we adopted is based on the idea by Mehrotra and Trick (1996) for the Vertex Coloring Problem and is aimed at improving the incumbent heuristic solution. At each node we select a pair (j, k) of items that can be packed in the same bin. Then, we create three children nodes and three corresponding modified instances: i) in the first node we impose that item j precedes item k; ii) in the second node we impose that item k precedes item j; iii) in the last node we impose that items j and k are packed in the same bin. The third branching scheme we attempted is derived from algorithm EUREKA, developed for the SALBP by Hoffman (1992). The algorithm operates in a recursive way. In its forward direction, at each iteration it first identifies the set, say V H, of items having head equal to 1. Then it computes all the maximal subsets of V H that can be feasibly packed into one bin. For each subset it creates a node of the enumeration tree, by packing the subset in the first bin, deleting the packed items and updating the precedence digraph accordingly. The enumeration tree constructed in this way is explored in a depth-first fashion. Each node is possibly fathomed by using a lower bounding technique. In its backward direction, the algorithm selects the set of items, say V T , having tail equal to 1 and operates in a similar way to the forward version. In this case a node is created by packing a maximal subset of V T in the last bin. In our implementation, at each iteration we compute both V H an V T . Then, if |V H| ≤ |V T | we continue in forward direction, otherwise in the backward one. We anticipate the fact, shown in Section 6, that the third branching scheme turned out to be much better performing than the first two.

16

6

Computational Results

We implemented all algorithms in C++ and run them on an Intel Pentium machine with 3 GHz CPU and 2 GB of RAM, running under Windows XP operating system. We tested the code on a large set of instances that has been built upon benchmarks from the SALBP. As discussed in Section 1, BPP-P and SALBP are similar from a combinatorial point of view as the only difference lies in the kind of precedence constraints. We used the 269 benchmark instances from SALBP that are available on the web site www.assembly-line-balancing.de. This set is made up of 25 seed instances, for which the precedence digraph and the item weights are given. From each seed instance, several instances are obtained by varying the capacity of the bin. We adopted these instances by replacing the weak precedence constraints of SALBP (i.e., the “≤” sign) with strict precedences (i.e., the “ m − tailj + 1. We applied the model to the instances lifted with SSPC. The columns corresponding to the model have the same meaning than the ones reported for the branch-and-bound. We can note that at the end of the root node all instances have a difference of one bin between Lroot and Uroot . The time required by the root node is mostly determined by that needed by the VNS algorithm. The branch-and-bound improves 18 times the value of the lower bound found at the root node. The value of the upper bound is improved 3 times. These improvements reduce the percentage gap to 0.33% and allow to prove the optimality of 21 out of 24 instances. The number of nodes explored by the branch-and-bound can be very high, even more than 17 millions in the two hours of time limit, and more than 1.6 millions on average. The time elapsed by the root node and the branch-and-bound is about 1500 seconds on average. Some instances, as Buxey and Gunther, are closed within a very small effort, but for others, as Warnecke with C=60, more than one hour is needed. For Warnecke with C=62 we proved 31 is the optimal value, with a different version of our algorithm and a longer CPU time. All but 3 instances out of the initial set of 269 instances have been solved to optimality, 245 at the root node and 21 by the successive branch-and-bound. This is done within a limited computational effort. Moreover, a very small gap characterizes the 3 unsolved instances. The comparison with model (5)–(10) solved with CPLEX 12 confirms the good behavior of our algorithm. Indeed CPLEX can close to proven optimality only the small instances with up to 35 items (Buxey, Gunther, Roszieg, Sawyer), but usually fails for the larger ones. The difference between lower and upper bound can be as large as four bins, and the percentage gap is more than 13 times higher than that obtained by our overall algorithm. In Table 5 we finally extend the comparison between our algorithm and model (5)–(10) by presenting aggregate results on the complete set of instances. For both algorithms we report percentage gap (%g), CPU seconds (sec) and number of instances not solved to proven optimality (#miss). Each line gives total/average values over the #I instances. Also for this larger benchmark the difference between the two algorithms is evident. The model is very fast in closing to optimality the easy instances, but usually fails for the difficult ones. In a much shorter average time our overall algorithm achieves a larger number of optimal solution (266 vs 188) and a much smaller gap (0.03% vs 4.98%). 22

7

Conclusions

We considered a generalization of the bin packing problem where additional precedence constraints between the items have to be satisfied. We proposed preprocessing procedures and several lower bounds exploiting the bin packing structure and/or the precedence constraints. For most of these lower bounds we assessed the worst case approximation performances. The lower bounds have been further improved by means of dual feasible functions or specialized graph lifting procedures. On the other hand we considered a greedy constructive heuristic, a local search procedure and a Variable Neighborhood Search method. Several branch-and-bound algorithms have been proposed and tested, by selecting different combinations of branching schemes, lower bounds and heuristics. The new contributions we presented and the ones we adapted from the literature are summarized in Table 6. A large set of computational experiments has been performed on 269 instances. The settings leading to the best algorithm have been clearly assessed and described. We can conclude that the resulting algorithm is very effective for the BPP-P, because it is able to solve all but 3 instances in reasonable CPU times and compares very well with standard ILP techniques.

Acknowledgments The authors are very indebted with three anonymous referees, whose comments greatly improved the quality of the paper.

References Augustine, J., S. Banerjee, S. Irani. 2009. Strip packing with precedence constraints and strip packing with release times. Theoretical Computer Science 410(38–40) 3792–3803. Baybars, I. 1986. A survey of exact algorithms for the simple assembly line balancing problem. Management Science 32(8) 909–932. Becker, C., A. Scholl. 2006. A survey on problems and methods in generalized assembly line balancing. European Journal of Operational Research 168(3) 694–715. Boschetti, M., A. Mingozzi. 2003. The two-dimensional finite bin packing problem. part I: new lower bounds for the oriented case. 4OR 1(1) 27–42. Ceselli, A., G. Righini. 2008. An optimisation algorithm for the orderded open-end binpacking problem. Operations Research 56(2) 425–436. Clautiaux, F., C. Alves, J. Val´erio de Carvalho. 2010. A survey of dual-feasible and superadditive functions. Annals of Operations Research 179(1) 317–342.

23

Coffman, E.G., G. Galambos, S. Martello, D. Vigo. 1999. Bin packing approximation algorithms: Combinatorial analysis. D.-Z. Du, P.M. Pardalos, eds., Handbook of Combinatorial Optimization. Kluwer Academic Publishers, 151–208. Crainic, T.G., G. Perboli, M. Pezzuto, R. Tadei. 2007. New bin packing fast lower bounds. Computers & Operations Research 34(11) 3439–3457. Fekete, S.P., J. Schepers. 2001. New classes of fast lower bounds for bin packing problems. Mathematical Programming 91(1) 11–31. Fernandes Muritiba, A.E., M. Iori, E. Malaguti, P. Toth. 2010. Algorithms for the bin packing problem with conflicts. INFORMS Journal on Computing 22(3) 401–415. Garey, M. R., R. L. Graham, D. S. Johnson, A. C.-C. Yao. 1976. Resource constrained scheduling as generalized bin packing. Journal of Combinatorial Theory, Series A 21(3) 257–298. Gendreau, M., G. Laporte, F. Semet. 2004. Heuristics and lower bounds for the bin packing problem with conflicts. Computers & Operations Research 31(3) 347–358. Hansen, P., N. Mladenovi´c, J.A. Moreno P´erez. 2008. Variable neighbourhood search: methods and applications. 4OR 6(4) 319–360. Haouari, M., A. Gharbi. 2005. Fast lifting procedures for the bin packing problem. Discrete Optimization 2(3) 201–218. Hifi, M., M. Michrafy. 2007. Reduction strategies and exact algorithms for the disjunctively constrained knapsack problem. Computers & Operations Research 34(9) 2657–2673. Hoffman, T.R. 1992. EUREKA: A hybrid system for assembly line balancing. Management Science 38(1) 39–47. Kelley, J. 1961. Critical path planning and scheduling: Mathematical basis. Operations Research 9(3) 296–320. Khanafer, A., F. Clautiaux, E.-J. Talbi. 2010. New lower bounds for bin packing problems with conflicts. European Journal of Operational Research 206(2) 281–288. Martello, S., P. Toth. 1990. Knapsack Problems: Algorithms and Computer Implementations (available on line at www.or.deis.unibo.it). John Wiley & Sons, Chichester. Mehrotra, A., M.A. Trick. 1996. A column generation approach for graph coloring. INFORMS Journal on Computing 8(4) 344–354. Scholl, A. 1999. Balancing and sequencing of assembly lines. Physica-Verlag, Heidelberg. Scholl, A., C. Becker. 2006. State-of-the-art exact and heuristic solution procedures for simple assembly line balancing. European Journal of Operational Research 168(3) 666–693. Tirpak, T.M. 2008. Developing and deploying electronics assembly line optimization tools: A motorola case study. Decision Making in Manufacturing and Services 2(1–2) 63–78. Val´erio de Carvalho, J.M. 2002. LP models for bin packing and cutting stock problems. European Journal of Operational Research 141(2) 253–273.

24

Table 1: Description of the instances and performance of the lifting procedures. Instances name Arcus1 Arcus2 Barthold Barthol2 Bowman Buxey Gunther Hahn Heskiaoff Jackson Jaeschke Kilbridge Lutz1 Lutz2 Lutz3 Mansoor Mertens Mitchell Mukherje Roszieg Sawyer Scholl Tonge Warnecke Wee-Mag

SSP

SSPC

n

|A0 |

#I

#lift

#del

%lift

sec

#lift

#del

%lift

sec

83 111 148 148 8 29 35 53 28 11 9 45 32 89 89 11 7 21 94 25 30 297 70 58 75

113 176 175 175 8 36 45 82 39 13 11 62 38 118 118 11 6 27 181 32 32 423 86 70 87

16 17 8 27 1 7 7 5 6 6 5 10 6 11 12 3 6 6 13 6 9 26 16 16 24

12.25 7.35 0.00 0.11 5.00 2.71 4.86 30.20 2.00 2.83 5.80 3.80 25.17 15.18 23.33 9.33 4.50 11.17 12.23 5.83 1.67 5.08 1.75 13.31 3.00

4.00 5.00 0.00 0.00 2.00 1.00 0.14 2.20 1.00 2.17 3.40 0.20 2.33 3.45 0.00 1.33 3.00 1.17 6.08 2.00 0.11 4.15 0.00 1.81 1.33

40.87 61.56 0.00 0.04 25.00 23.41 19.70 50.95 37.21 45.57 36.37 61.54 20.81 24.00 37.37 20.67 37.53 30.43 42.76 43.20 5.60 70.51 14.21 5.90 29.13

0.02 0.01 0.01 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.02 0.00 0.00 0.00

16.81 7.59 0.00 0.11 5.00 4.14 8.86 31.20 2.00 5.17 5.80 6.60 24.00 16.27 35.33 8.00 4.33 11.17 11.08 11.67 3.00 5.04 4.38 13.63 3.00

4.00 5.00 0.00 0.00 2.00 1.00 0.14 2.20 1.00 2.17 3.40 0.20 2.33 3.45 0.00 1.33 3.00 1.17 6.08 2.00 0.11 4.15 0.00 1.81 1.33

31.34 59.85 0.00 0.04 25.00 17.09 16.67 37.78 44.81 33.78 36.37 49.38 22.72 23.70 29.82 25.73 39.17 30.61 48.95 33.01 8.11 71.23 10.65 6.56 29.13

4.32 2.95 2.46 2.76 0.02 0.14 0.17 0.18 0.14 0.05 0.02 0.29 0.07 0.55 0.63 0.05 0.02 0.07 0.88 0.12 0.16 45.68 0.65 0.43 0.66

269

8.34

1.92

31.37

0.00

9.77

1.92

29.26

2.54

Totals/Averages

25

Table 2: Average percentage gaps of the lower bounds with respect to Uroot .

L L1 L2 L3 L4 L5 (L1 ) L5 (Ldff ) L5 (LF S )

graph lifting (Lβ ) L4 L+ L5 (L1 ) 4

L5 (Ldff )

L5 (LF S )

3.83

8.09

24.49

2.30 2.30

2.60 2.60

0.83 0.83

0.96 0.96

2.13 0.42 0.53

2.38 0.61 0.73

0.63 0.61 0.61

0.74 0.61 0.73

−

Ldff

LF S

sec

0.00

4.40

20.48

1.39

1.83

0.00 0.00 0.00 0.00 0.00 0.91 5.63

24.75 11.57 3.40 2.64 2.70 0.95 1.06

0.83 0.83

0.96 0.96

2.44 2.44

0.63 0.61 0.61

0.74 0.61 0.73

2.25 0.53 0.64

26

Table 3: Performance of the upper bounds on the complete set of instances. First Fit

LS

VNS

name

#I

%g

sec

#opt

%g

sec

#opt

%g

sec

#opt

Arcus1 Arcus2 Barthold Barthol2 Bowman Buxey Gunther Hahn Heskiaoff Jackson Jaeschke Kilbridge Lutz1 Lutz2 Lutz3 Mansoor Mertens Mitchell Mukherje Roszieg Sawyer Scholl Tonge Warnecke Wee-Mag

16 17 8 27 1 7 7 5 6 6 5 10 6 11 12 3 6 6 13 6 9 26 16 16 24

1.74 13.95 4.14 22.85 0.00 5.44 4.96 0.77 7.04 1.85 0.00 5.08 0.00 7.92 0.17 4.76 3.33 2.56 12.07 1.19 8.65 6.54 6.10 18.08 3.50

0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00

10 1 2 0 1 3 3 4 3 5 5 5 6 0 11 2 5 4 0 5 3 0 7 0 5

1.46 10.95 4.14 17.89 0.00 5.44 4.21 0.00 5.56 1.85 0.00 5.08 0.00 6.04 0.17 4.76 0.00 1.28 10.79 1.19 8.01 6.38 4.78 11.93 1.81

0.00 0.00 0.02 0.02 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.06 0.00 0.00 0.00

10 1 2 0 1 3 3 5 3 5 5 5 6 0 11 2 6 5 0 5 3 0 8 0 8

0.00 0.83 0.00 0.18 0.00 3.31 1.79 0.00 0.00 0.00 0.00 0.00 0.00 0.18 0.00 0.00 0.00 0.00 0.61 1.19 2.52 0.00 0.00 1.21 0.00

0.01 112.13 0.09 63.62 0.00 171.43 114.29 0.00 0.00 0.00 0.00 0.00 0.00 94.76 0.00 0.00 0.00 0.00 65.52 66.67 133.50 5.50 12.91 150.22 0.04

16 13 8 25 1 4 5 5 6 6 5 10 6 10 12 3 6 6 11 5 6 26 16 10 24

269

7.88

0.00

90

6.23

0.01

97

0.42

44.14

245

Totals/Averages

27

Table 4: Results of the overall algorithm on the set of 24 challenging instances (time limit = 2 CPU hours). Instance Name

n |A0 |

Arcus2 111 176 Arcus2 Arcus2 Arcus2 Barthol2 148 175 Barthol2 Buxey 29 36 Buxey Buxey Gunther 35 45 Gunther Lutz2 89 118 Mukherje 94 181 Mukherje Roszieg 25 32 Sawyer 30 32 Sawyer Sawyer Warnecke 58 70 Warnecke Warnecke Warnecke Warnecke Warnecke Averages

Root Node C Lroot Uroot 6267 6837 7520 7916 85 121 27 30 33 49 54 16 201 248 14 25 30 33 54 58 60 62 65 68

29 28 26 26 50 35 13 12 11 15 15 49 26 23 13 14 12 11 34 32 30 30 28 27

30 29 27 27 51 36 14 13 12 16 16 50 27 24 14 15 13 12 35 33 31 31 29 28

Branch-and-Bound sec L U

413.44 418.38 405.81 405.61 412.50 407.73 400.50 400.52 400.42 400.70 400.70 414.19 414.72 413.41 400.47 401.84 400.55 400.49 413.42 413.30 413.41 413.70 409.80 409.67 407.72

28

%g

#nodes

Model (5)–(10) sec

– 29 0.00 1890268 578.92 29 – 0.00 2349895 844.19 27 – 0.00 701 0.73 27 – 0.00 296146 106.50 – – 1.96 13840213 t. lim. – – 2.78 17708898 t. lim. 14 – 0.00 212 0.89 13 – 0.00 29 0.17 12 – 0.00 11 0.06 16 – 0.00 1 0.00 16 – 0.00 1 0.00 50 – 0.00 16 0.33 – 26 0.00 11283 25.11 – 23 0.00 458 4.50 14 – 0.00 11 0.03 15 – 0.00 990 3.31 13 – 0.00 85 0.39 12 – 0.00 19 0.09 35 – 0.00 2922 22.23 33 – 0.00 131016 547.78 31 – 0.00 783297 3661.83 – – 3.23 1707926 t. lim. 29 – 0.00 154 1.67 28 – 0.00 398 3.67 0.33

1613540 1090.35

L U 29 27 25 25 50 35 14 13 12 16 16 50 26 23 14 15 13 12 32 30 28 27 25 24

%g

sec

29 0.00 183.41 29 6.90 t. lim. 27 7.41 t. lim. 27 7.41 t. lim. 52 3.85 t. lim. 37 5.41 t. lim. 14 0.00 0.97 13 0.00 0.78 12 0.00 0.19 16 0.00 0.22 16 0.00 0.22 50 0.00 3048.41 27 3.70 t. lim. 24 4.17 t. lim. 14 0.00 0.17 15 0.00 28.39 13 0.00 17.40 12 0.00 1.28 35 8.57 t. lim. 33 9.09 t. lim. 31 9.68 t. lim. 31 12.90 t. lim. 29 13.79 t. lim. 28 14.29 t. lim. 4.46 4036.73

Table 5: Summary of the results obtained on the complete set of instances (time limit = 2 CPU hours). Branch-and-Bound

Model (5)–(10)

name

#I

%g

sec

#miss

%g

sec

#miss

Arcus1 Arcus2 Barthold Barthol2 Bowman Buxey Gunther Hahn Heskiaoff Jackson Jaeschke Kilbridge Lutz1 Lutz2 Lutz3 Mansoor Mertens Mitchell Mukherje Roszieg Sawyer Scholl Tonge Warnecke Wee-Mag

16 17 8 27 1 7 7 5 6 6 5 10 6 11 12 3 6 6 13 6 9 26 16 16 24

0.00 0.00 0.00 0.18 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.20 0.00

5.69 211.49 4.41 575.35 0.05 171.94 114.83 0.22 0.22 0.06 0.03 0.58 0.13 106.99 1.66 0.08 0.03 0.13 76.92 66.86 134.48 114.39 15.74 870.38 2.24

– – – 2 – – – – – – – – – – – – – – – – – – – 1 –

0.00 1.70 0.00 8.68 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 6.63 0.00 0.00 0.00 0.00 0.61 0.00 0.00 31.52 1.51 7.56 1.29

11.09 2192.00 80.66 t. lim. 0.04 0.40 0.54 0.20 0.20 0.05 0.03 1.15 0.11 3736.89 0.80 0.04 0.02 0.10 1154.17 0.13 5.41 6160.11 1426.45 5513.81 2337.76

– 5 – 27 – – – – – – – – – 5 – – – – 2 – – 21 3 12 6

269

0.03

157.20

3

4.98

2289.93

81

Totals/Averages

29

Table 6: Description of the adapted contributions and improvements. Contribution Techniques Used as it is First Fit by Garey et al. (1976) Adapted

SSP preprocessing by Boschetti and Mingozzi (2003); model (5)– (10) by Baybars (1986) and Scholl (1999); branching 1 by Martello and Toth (1990); branching 2 by Mehrotra and Trick (1996)

Non-trivial adaptation

SSPC preprocessing by Hifi and Michrafy (2007); L4 by Gendreau et al. (2004); dual feasible functions by Fekete and Schepers (2001), Boschetti and Mingozzi (2003), Haouari and Gharbi (2005) and Crainic et al. (2007); branching 3 by Hoffman (1992)

New

Worst case performance of L1 , L2 and L3 ; lower bounds L+ 4 and L5 ; graph lifting; local search; VNS; overall algorithm

30