An Exact Algorithm for the Resource. Constrained Project Scheduling Problem. Based on a New Mathematical Formulation

Transcription

1 An Exact Algorithm for the Resource Constrained Project Scheduling Problem Based on a New Mathematical Formulation Aristide Mingozzi, Vittorio Maniezzo Department of Mathematics, University of Bologna, Bologna, Italy Salvatore Ricciardelli, Lucio Bianco Department of Electrical Engineering, University Tor Vergata, Rome, Italy October 1995 Abstract: In this paper we consider the Project Scheduling Problem with resource constraints, where the objective is to minimize the project makespan. We present a new 0-1 linear programming formulation of the problem that requires an exponential number of variables, corresponding to all feasible subsets of activities that can be simultaneously executed without violating resource or precedence constraints. Different relaxations of the above formulation are used to derive new lower bounds, which dominate the value of the longest path on the precedence graph and are tighter than the bound proposed by Stinson et al. (1978). A tree search algorithm based on the above formulation, that uses new lower bounds and dominance criteria is also presented. Computational results indicate that the exact algorithm can solve hard instances that cannot be solved by the best algorithms reported in the literature. Correspondence to: A. Mingozzi, Dept. of Mathematics, University of Bologna, via Sacchi 3, Cesena, Italy Fax , Tel , mingozzi@csr.unibo.it 0

2 1. Introduction The Resource Constrained Project Scheduling Problem (RCPSP) considered in this paper is the problem of determining the starting times for the activities of a project satisfying precedence and resource constraints in order to minimize the total project duration. The precedence constraints impose that an activity can start after the completion of all its predecessor activities. The execution of an activity cannot be interrupted and requires, for each period of its duration, constant amounts of a subset of renewable resources. A constant amount of each resource is available throughout the duration of the project and, therefore, the resource constraints limit the subset of activities that can be simultaneously executed at each period of the project duration. The problem is NP-hard (Blazewicz et al. 1983). Most of the exact algorithms for RCPSP are branch and bound procedures where the lower bound is obtained by relaxing the resource constraints and by computing the longest path of the precedence graph. Furthermore, most of the branch and bound algorithms make use of dominance rules to eliminate from the search tree the nodes that cannot lead to an optimal solution. Some of the exact algorithms are described by Pritsker et al. (1969), Balas (1970), Davis and Heidorn (1971), Schrage (1971), Gorenstein (1972), Fisher (1973), Patterson and Huber (1974), Patterson and Roth (1976), Stinson et al. (1978), Talbot and Patterson (1978), Christofides et al. (1987), Bell and Park (1990) and Demeulemeester and Herroelen (1992), respectively. Stinson et al.(1978) proposed a new lower bound based on the longest path of the precedence graph that takes into account some of the relaxed resource constraints. Fisher (1973) was the first to derive a lower bound based on a Lagrangean relaxation of resource constraints. A similar bound has been evaluated by Christofides et al. (1987); the results obtained show that this bound is better than the one based on the longest path, however, it is a hard problem to determine a good set of Lagrangean multipliers. 1

3 Christofides et al.(1987) also describe two new lower bounds. The first is based on the LP relaxation of an integer programming formulation of the RCPSP, with several types of valid inequalities to enforce the lower bound. The second is based on a disjunctive graph obtained from the precedence graph by adding disjunctive arcs to partially represent resource constraints. The branch and bound procedure based on this later approach is shown to perform better than Stinson's procedure for a number of problem instances with 25 activities and 3 resources. Demeulemeester and Herroelen (1992) describe a new effective branch and bound algorithm that outperforms all other exact methods, at least on the set of 110 test problems assembled by Patterson (1984). Kolisch et al. (1992) introduce a number of parameters to identify easy and hard RCPSP instances and generated a new set of test problems. The computational results provided show that Demeulemeester s procedure cannot solve hard instances to optimality, even with a large amount of computing time. Furthermore, the results demonstrate that the set of 110 Patterson problems belongs to the class of easy RCPSP problems. Davis and Heidorn (1971) propose a branch and bound algorithm that is significantly different from those mentioned so far and based on a method used by Gutjahr and Nemhauser (1964) for the Assembly Line Balancing Problem. Their approach consists in transforming a RCPSP instance into a problem of finding a shortest path in a directed graph where each vertex represents a feasible subset of activities that can be processed simultaneously at a given time. The algorithm can solve only small problems as the number of feasible sets can be huge even for moderate size problems. The main contribution of this paper consists in five new lower bounds for the RCPSP which dominate the value of the longest path of the precedence graph and are tighter than Stinson s bound. These bounds are derived from a new mathematical formulation of the problem. 2

4 Moreover, we present a branch and bound algorithm that optimally solves also the hard RCPSP instances provided by Kolisch et al. (1992). The paper is organized as follows: in Section 2 we describe the RCPSP problem and a wellknown mathematical formulation. The new mathematical formulation is given in Section 3 while, in Section 4, we present two different relaxations that are used to derive the new lower bounds. In Section 5 we describe a branch and bound algorithm and, in Section 6, computational results are presented. 2. Problem description The RCPSP problem can be formulated as follows. A set X={1,, n} of activities (jobs) and a set of m resources are given, where each resource k has a total availability b k at each time interval of the scheduling period. Every activity i has a processing time (duration) d i, its execution requires a constant amount r ik of resource k for each time interval. All quantities d i, r ik and b k are assumed to be non negative integers, no pre-emption is allowed and setup times are supposed to -1 be included in the processing times. With each activity j is associated a set Γ j X\{j} of immediate predecessors: activities that must be completed before starting the execution of j. The precedence constraints can be represented by an acyclic digraph G=(X, H) where H={(i,j) : i Γ - j 1, j X}. Let cij =d j be the cost associated with arc (i,j) H. We assume, without loss of generality, that activities are topologically ordered, i.e., each predecessor of activity j has a smaller activity number than j. Activities 1 and n are used to represent the beginning and the end of the whole project: activity 1 must be completed before starting activities X\{1} and activity n can start after the completion of activities X\{n}; let X =X\{1,n}. We assume d 1 =d n =0. The cost of a feasible solution is given by the project completion time (project makespan). The 3

5 objective is to find a feasible starting time for each activity, such that precedence and resource constraints are satisfied and the solution cost is minimized. Let T max denote an upper bound to the project completion time. T max can be computed as T max = Σ d i or by means of any of the heuristics mentioned in Section 1. i X A time window [es i, ls i ] of earliest and latest start times for each activity i X can be computed by performing a forward and backward recursion on the graph G, by setting es 1 =0 and ls n = T max (see Elmaghraby, 1977). Figure 1 shows an example of a RCPSP instance. The activities can utilize three different resources, where b 1 = b 2 = b 3 = 4. A valid upper bound to the completion time is T max =15. The duration of an activity is given by the number above the corresponding node, its resource consumptions and time window by the numbers below. The boldface arcs are those of the longest path. 4

6 d r 21, r 22,r 23 2,2,2 3,2,0 [es 2, ls 2 ] [0,10] 1 [4,13] 5 2,2,2 0 3 [3,12] ,0,0 3,1,1 1,1,0 0,0,0 [0,7] [0,7] 2 [3,14] [8,15] 6 4,0,1 1 [3,10] ,0,1 2,2,3 [0,11] 3 [5,12] 7 1,2,2 [0,12] Figure 1 - Example of a RCPSP instance with n=11 and m=3 In the following we present a well-known (0-1) integer programming formulation of the RCPSP that has been used to derive all existing lower bounds described in the literature. Let ξ it be a (0-1) binary variable that is equal to 1 if and only if activity i starts at the beginning of period t (we assume that time period t corresponds to the time interval [t, t+1]). RCPSP can be formulated as follows: lsn Min z P = t ξ nt (1) t= es n s.t. ls i ξ it = 1 i X (2) t= es i ls j ls i t. ξ jt - tξ it d i (i,j) H (3) t= es j t= es i 5

7 Σ i X t r ik Σ τ= σ( t, i) ξiτ b k t=0,..., T max ; k=1,..., m (4) ξ it {0,1} i X, t=es i,..., ls i (5) where σ(t,i) = max(0, t-d i +1). Equalities (2) represent the non-preemption constraints, while inequalities (3) and (4) represent precedence and resource constraints, respectively. Lower Bounds LB0 and LBS The relaxed problem obtained by dropping resource constraints (4) can be simply solved by computing the longest path in the graph G from vertex 1 to vertex n; this is the most commonly used lower bound for RCPSP and will be denoted by LB0 throughout this paper. Stinson et al. (1978) proposed a bound based on the above relaxation that partially considers resource constraints. Denote with X the subset of activities which are not part of the longest path and, for each activity i X, let es i and lf i (= ls i +d i -1) be respectively the early start and the late finish times computed according to the precedence constraints. Denote with e i d i the longest time interval contained in [es i, lf i ] during which it is possible to execute activity i X together with the activities of the longest path without violating resource constraints. Then Stinson s lower bound is given by LBS=LB0 + max{d i - e i }, i X. In the case of the problem instance of Figure 1, bound LB0 yields a value of 8, as indicated by the boldface arcs, Stinson s bound LBS a value of 11 because of the contribution of activity 2, while the optimal solution is A new integer programming formulation In this Section we describe a new integer programming formulation of the problem that is used to derive new lower bounds to RCPSP that dominate bound LB0 and are tighter than LBS, as shown 6

8 in the computational tests in Section 6. Any feasible RCPSP solution can be represented by a sequence S={R l1, R l2,..., R lt* } where t* is the completion time and where each R lt S corresponds to a subset of activities, in progress at time t, that satisfies the following two conditions: i) resource constraints are satisfied: rik b i Rl t k k = 1,, m; ii) no precedence constraint exists between each pair i,j R lt with i<j (i.e., no path exists in G from vertex i to vertex j). We call a feasible subset every subset of activities R X that satisfies conditions i) and ii). A sequence S of feasible subsets represents a RCPSP solution if it satisfies the conditions: 1) every activity is executed without interruptions; 2) the activity starting times satisfy the precedence constraints. Let R = {1, 2,..., r } be the index set of all feasible subsets of X that satisfy conditions i) and ii), and let R i R be the index set of all feasible subsets that contain activity i. Let y lt be a (0-1) binary variable equal to 1 if and only if all activities of the feasible subset R l are in execution at time period t. Define a (0-1) binary variable ξ it equal to 1 if and only if activity i starts at the beginning of time period t. The mathematical formulation (P) of RCPSP is as follows: ls n (P) Min z P = Σ t = es n t. ξ nt (6) lsi s.t. y t d O = l R t = es i i i i X (7) 7

9 y tl 1, t = 1,,T max (8) R l y y ξ it l t l t l Ri l Ri ls i Σ t = esi 1, i X, t = es i,,ls i (9) ξ it = 1, i X (10) ls j ls i t. ξ jt - tξ it d i, (i,j) H (11) t= es j t= es i yot {0,1}, O R, t = 1,,T max (12) ξ it {0,1}. i X, t = es i,,ls i (13) Constraints (7) force the solution to have in progress feasible subsets contained in R i for exactly d i time periods for each activity i X. Constraints (8) ensure that at each time period t at most one feasible subset is in progress. Constraints (9) force the variable ξ it to be 1 if the activity i is contained in the feasible subset in execution at time period t but is not contained in the feasible subset in execution at time period t-1. Constraints (10) and (11) correspond to constraints (3) and (4) of the RCPSP formulation given in Section 2. Notice that a given feasible subset R l is allowed to be in progress at different times and, Tmax consequently, the term Σ t =0 yot represents the time spent in progress by it. It follows that the objective function (6) can be alternatively written as follows: Min z P = Tmax y l t l R t=0 (6') This formulation requires r x T max variables y Ot and Σ (ls i-es i +1) variables ξ it ; it involves (n- i X' 8

10 2)+ (T max +1) + Σ (ls i -es i +1) + n + H constraints, therefore it can be directly solved only for i X' small instances. Example The problem presented in Figure 1 can be used as an example of our formulation. The feasible subsets of activities in this case are r =28 and correspond to the following set R: R = {R 1,, R 28 } = {{2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {2, 4}, {2, 5}, {2, 7}, {2, 9}, {3, 4}, {3, 7}, {4, 5}, {4, 7}, {4, 8}, {4, 9}, {5, 7}, {5, 9}, {7, 8}, {7, 9}, {8, 9}, {9, 10}, {2, 4, 9}, {4, 5, 9}, {4, 7, 9}} The number of ξ it variables in this case is 165, while the number of y lt variables is 420. We have 9 constraints of type (7), 16 constraints of type (8), 92 constraints of type (9), 11 constraints of type (10) and 15 constraints of type (11). The optimal solution, of cost 13, corresponds to the following non-zero variables y 5,6 = y 5,7 = y 7,11 = y 7,12 = y 9,8 = y 9,9 = y 9,10 = y 11,5 = y 12,3 = y 13,4 = y 14,0 = y 15,1 = y 15,2 = 1, ξ 1,0 = ξ 2,3 = ξ 3,0 = ξ 4,0 = ξ 5,5 = ξ 6,6 = ξ 7,1 = ξ 8,11 = ξ 9,4 = ξ 10,8 = ξ 11,13 = New lower bounds Problem P can be relaxed in different ways, thus providing different lower bounds to RCPSP. It is easy to see that the relaxed problem obtained by ignoring constraints (7), (8), (9) and (12) corresponds to the lower bound LB0 described in Section Lower Bound LB1 Lower bound LB1 is obtained from problem P by dropping precedence and non-preemption constraints. It corresponds to the relaxed problem RP1, obtained from P as follows: 9

11 1) remove constraints (8) to (13); 2) use objective function (6') instead of (6); 3) substitute in the objective function (6') and in the inequalities (7) the term Σ whose value represents the execution time of the feasible subset Rl, l R. Problem RP1 becomes the following LP problem: Tmax t =0 yot with xl RP1 = l l R (RP1) min z x (14) s.t. x l = d i, i X (15) l Ri xl 0 l R (16) Constraints (15) ensure that the overall execution time of the feasible subsets that are in the solution and that contain activity i is equal to d i. Let z RP1 be the optimal solution of RP1, then LB1 = z RP1 is a valid lower bound to RCPSP. Example When we compute LB1 on the RCPSP problem of Figure 1, we obtain a value of 13. The corresponding solution of RP1 is the following: x 1 =2; x 5 =2; x 7 =1; x 9 =2; x 11 =1; x 15 =3; x 18 =1; x 25 = Lower Bound LB2 Let RP2 be the problem derived from RP1 relaxing equations (15) by replacing "=" with " " to give a system of inequalities. A direct result of this relaxation is the following Theorem 1, that allows to reduce of the set R without changing the optimal solution cost of RP2. Theorem 1. Let l R and l R be the indices of two different feasible subsets such that R l R l. The optimal solution cost of problem RP2 does not change if the set R is replaced by 10

12 R \ {l }. Proof: Let x* be an optimal RP2 solution of cost z* RP2 such that x* l >0. Consider a new solution x obtained from x* by setting: (i) x l = x* l, l R \{l, l }; (ii) x l = x* l + x* l ; and (iii) x l =0. l R i l l R i l Since R l R l, we have x x d, i X, that shows that x is a feasible RP2 solution. Furthermore, from the definition of x given above, we have x l = x l R l R shows that z RP2 = z* RP2. i l, which By means of Theorem 1 we can remove from R any feasible subset l such that R l R l for some l R\{l}, without changing the optimal RP2 cost. Let M R be the index set of the "undominated feasible subsets" defined as follows: M = { l : l R, R l R l, l R\{l} } (17) The relaxed problem RP2 is the following: RP2 = l l M (RP2) min z x (14 ) s.t. x d i, i X (15 ) l Mi l x l 0, l M (16 ) where M i = M R i Lower bound LB2 corresponds to the optimal solution cost z RP2 of problem RP2. Since RP2 is a relaxation of RP1, it is obvious that LB1 LB2. The computational results of Section 6 show that LB2 is superior to LBS in all test problems. Moreover, we can prove that LB2 can never be worse than LB0. 11

13 Theorem 2: The following inequality holds: LB2 LB0. Proof: Let π =(1, i 0, i 1,..., i k, n) be a longest path in G from vertex 1 to vertex n, let π=π \{1,n}. According to the definitions of arc costs of G given in Section 2 and of π, we have LB0 = d i i π (18) The dual of RP2, called DRP2, is as follows: (DRP2) max z DRP2 = d u i X' i i (19) s.t. i R u i l 1 l M (20) u i 0 i X (21) Since every feasible subset R l satisfies condition ii) described in Section 3, we have that every subset R l, l M ir, for some i r π, does not contain any activity i s π\{i r }, therefore, M ir M is = for each pair i r, i s π. We can accordingly partition M as M = M i1 M i2... M ik M where M =M \ U M i r π i r The dual constraints (20) can be rewritten as u i r + u 1, O, i π i i R \ i r { } ui 1, O M Rl i l M i r r (20 ) A straightforward feasible solution u of DRP2 is given by: u = 1 if i π i 0 otherwise 12

14 Observe that solution u has a cost z DRP2 = d i (=LB0); from linear programming duality we i π conclude that LB2 z DRP2 = LB0 Example: For the problem of Figure 1, the set M of undominated feasible subsets is M = {{6}, {2, 5}, {2, 7}, {3, 4}, {3, 7}, {4, 8}, {5, 7}, {7, 8}, {8, 9}, {9, 10}, {2, 4, 9}, {4, 5, 9}, {4, 7, 9}}. When we compute LB2 we obtain a value of 13, that corresponds to the following solution of RP2: x 1 =2; x 2 =3; x 4 =1; x 5 =2; x 8 =1; x 9 =1; x 10 = Lower Bounds LBP, LBX and LB3 The lower bounds LBP, LBX and LB3 correspond to the costs of three different heuristic solutions of problem DRP2 and, therefore, from linear programming duality we have that LB2 LBP, LB2 LBX and LB2 LB3. These three lower bounds are derived by finding the costs of three different a feasible solutions of the following (0-1) integer problem, called IDRP2, that is obtained from DRP2 by forcing the variables u i, i X, to be (0-1) integer variables. Problem IDRP2 is as follows: (IDRP2) max z IDRP2 = d u i X' i i (19) s.t. u i 1 i R l l M (20) u i {0,1} i X (21 ) Obviously LB2 = z* RP2 = z* DRP2 z* IDRP2, where z* DRP2 and z* IDRP2 are the optimal values of the objective functions of DRP2 and IDRP2, respectively. Problem IDRP2 is known as set packing problem, (Pardalos, Xue, 1992); it can be transformed into a weighted node packing problem (Nemhauser, Trotter, 1975), as follows. 13

15 Consider the intersection graph ~ G =(X,E), where (i,j) E if and only if a feasible subset Rl exists, l M, containing both activity i and j. Consider each d i as a weight associated to node i of G ~. The Weighted Node Packing Problem (WNP) on graph G ~ consists of finding an independent set of G ~ of maximum total weight. Let u i be a (0-1) binary variable, whose value is 1 if and only if node i is in the maximum weight independent set of G ~. Problem WNP is as follows. (WNP) max z WNP = d i u i (22) i X s.t. u i + u j 1, (i,j) E (23) u i {0,1}, i X (24) It is well known that the two problems WNP and IDRP2 have the same set of feasible solutions (Nemhauser, Trotter, 1975), therefore, they have the same optimal solution cost, which can be used as a lower bound to DRP2. Problem WNP, like problem IDRP2, is known to be NP-hard (Nemhauser and Wolsey, 1988). However, it is easy to compute a heuristic solution of WNP, thereby providing a new lower bound to problem DRP2. Moreover, the graph ~ G =(X,E) can be generated without knowing the set M. Generation of graph ~ G =(X,E) Remind that each edge (i,j) E indicates that the two activities i and j can be simultaneously in progress (i.e., i,j R l for some l M). The edge set E can be produced, without knowing M, observing that (i,j) E if and only if the pair of activities i and j satisfies the following conditions: i) the precedence graph G does not contain any path from vertex i to vertex j if i<j, or from vertex j to vertex i if j<i; 14

16 ii) the two activities i and j satisfy resource constraints: r ik + r jk b k, k = 1,, m Figure 2 - Graph ~ G for the problem of Figure 1. We denote by ~ Γ i the subset of vertices of ~ G adjacent to vertex i. In Figure 2 we present the graph ~ G for the problem of Figure 1. Lower bound LBP We denote by LBP= z* IDRP2 the value of an exact solution of problem WNP, as can be obtained by means of the exact algorithm proposed by Carraghan and Pardalos (1990). Lower bound LBX We denote by LBX ( LBP) the cost of the feasible solution of problem WNP obtained by means of the heuristic algorithm proposed by Xue (1994). Lower bound LB3 Lower bound LBX may result smaller than LB0 (see Section 6), therefore we have investigated an alternative heuristic algorithm, called HWNP, for solving problem WNP that produces a lower 15

17 bound LB3 (LB3 LBP) not smaller than LB0. Algorithm HWNP is as follows: Consider a list L = (i 1, i 2,..., i k, i k+1,..., i n ) whose first k elements are the vertices of π and whose other elements, {i k+1,..., i n }, are the vertices X \π ordered for nondecreasing values of their degree in the graph G ~. The list L is a circular list in that its last element points to the first. An independent set I of G ~ can be constructed as follows. set I = π. (Notice that from the definition of ~ G we have that π is an independent set of ~ G ) for each r = k+1,..., n, append vertex i r to I if the edge set E of ~ G does not contain any edge (i i r ) with i I. Let LB3 = d i. It is easy to see that LB3 LB0, since π I. i I A different independent set I can be obtained by initializing I in a different way; for example by forcing I to contain some vertex i r L. Therefore, the procedure can be repeated n times, each time forcing I to contain a different element of L. Heuristic Algorithm HWNP step 0: step 1: Set LB3=0 and k=1. Set S k = and r=k. step 2: Let i s be the first element of L with s r such that ~ Γ i S k =. If no such i s exists, go to step 3, else set r=s+1, set S k = S k {i s } and repeat step 2. step 3: Let δ k = Σ d i. If δ k > LB3 then set LB3 = δ k and set I = S k. i S k Set k = k+1. If k>n then Stop, else go to step 1. For example, when we compute LB3 on the problem instance of Figure 1, we obtain a value of 13. The corresponding solution of WNP is: u 2 = u 3 = u 6 = u 8 = u 10 = 1. In fact, when we run 16

18 HWNP, we get the following execution trace: k = 1, I = (3, 6, 10, 4, 7, 9, 2, 5, 8); S 1 = {2, 3, 6, 8, 10}, δ 1 = 13 k = 2, I = (6, 10, 4, 7, 9, 2, 5, 8, 3); S 2 = {4, 6, 10}, δ 2 = 6 k = 3, I = (10, 4, 7, 9, 2, 5, 8, 3, 6); S 3 = {4, 6, 10}, δ 3 = 6 k = 4, I = (4, 7, 9, 2, 5, 8, 3, 6, 10); S 4 = {4, 6, 10}, δ 4 = 6 k = 5, I = (7, 9, 2, 5, 8, 3, 6, 10, 4); S 5 = {6, 7, 10}, δ 5 = 8 k = 6, I = (9, 2, 5, 8, 3, 6, 10, 4, 7); S 6 = {3, 6, 9}, δ 6 = 6 k = 7, I = (2, 5, 8, 3, 6, 10, 4, 7, 9); S 7 = {2, 3, 6, 8, 10}, δ 7 = 13 k = 8, I = (5, 8, 3, 6, 10, 4, 7, 9, 2); S 8 = {3, 5, 6, 8, 10}, δ 8 = 11 k = 9, I = (8, 3, 6, 10, 4, 7, 9, 2, 5); S 9 = {2, 3, 6, 8, 10}, δ 9 = The Branch and Bound algorithm The optimal RCPSP solution is obtained by means of the following branch and bound algorithm based on formulation P of Section 3. Each node of the search tree corresponds to add to an emerging partial schedule of duration t a feasible subset R l R (i.e., to set y l =1). The state of t+1 a node α at level h(α) of the tree is represented by two ordered lists, L(α) = (R l 1, R l2,..., R lh(α) ) and T(α) = (τ 1, τ 2,..., τ h(α) ), where R l is the feasible set of activities processed from time period 1 1 to time period τ 1-1, R l 2 is the feasible set of activities processed from τ 1 to τ 1 +τ 2-1 and so on. We denote with t(α) = node α. Σ τ T( α) τ the total execution time of the partial schedule represented by The value τ h(α) is computed as the minimum time for completing at least one of the activities in R l h(α) We denote with: 17

19 W(α) the subset of distinct activities (W(α) X ) belonging to the emerging partial schedule associated with node α, i.e., the set of activities contained in the list L h (α) (W(α)=R l 1 R l2... R lh(α) ). We use s i(α) to indicate the starting time of activity i W(α) U(α) the subset of activities (U(α) W(α) ) whose execution is not completed before time period t(α) (i.e., s i (α) + d i > t(α), i U h (α) ) E(α) the subset of activities (E(α) X\W(α) ) that could start at time period t(α) satisfying the precedence constraints (i.e., Γ i 1 W(α) \ U(α), i E(α) ) Observe that a feasible subset R l, l R, can start at time period t(α) if it satisfies the two following conditions: i) U(α) R l : it contains all activities that are still in progress at time period t h (α); ii) R l \U(α) E(α): an activity i Rl\U h (α) can start at time period t(α) if all activities in Γ i 1 have been completed before time period t(α). Let N(α) R be the index set of those feasible subsets that satisfy conditions (i) and (ii) above. A forward branching, from node α at level h(α), involves the generation of N(α) descendent nodes, one for each R l, l N(α). A node of the search tree can be eliminated either if the lower bound becomes greater or equal to the cost of the incumbent solution or if it possible to prove, by means of some dominance rule, that such node cannot lead to the optimal solution. In the branch and bound procedure, we have implemented the following dominance rules. Dominance rule 1: reduction of the set N(α) Let β and β be two nodes at level h(α)+1, descending from node α at level h(α) and 18

20 corresponding to the feasible subsets R l and R l of N h (α), respectively. Let τ h(α)+1 and τ h(α)+1 be the execution times of the two sets R l and R l ; we have: τ h(α)+1 = min [s i i (β ) + d i ] - t(α); Rl' τ h(α)+1 = min [s i i (β ) + d i ] - t(α). Rl' Theorem 3: if R l R l and d i τ h(α)+1, i R l \R l, then node β cannot lead to a better RCPSP solution than the best one obtainable from β. Proof: Clearly, we have s i (β ) = s i (β ), i R l and s i (β ) = t h(α)+1 (β )+1 i R l \ R l. From the definition of τ h(α)+1 it derives that τ h(α)+1 = min [d i ] i R l' \ R l' Since R l R l, we have τ h(α)+1 τ h(α)+1, i R l \ R l. In any feasible solution obtained from node β, every activity i R l \ R l starts at a time greater or equal to t h(α)+1 (β ) + 1. Any solution from node β can be transformed in a better one, where every activity i R l \ R l starts at time t(α)+1 without affecting the starting times of the remaining activities (starting after time t h(α)+1 (β ) ), this is possible since R l is a feasible subset and d i τ h(α)+1, i R l \ R l. This transformation corresponds to the execution at node β of the same activities R l executed at node β, therefore τ h(α)+1 = τ h(α)+1. Therefore, every solution descending from node β can be transformed into a solution descending from node β having a smaller or equal completion time. Dominance rule 2 (Left shift) This is a dominance rule proposed by Stinson et al. (1978). A node α at level h(α) cannot lead to an optimal solution if there exists an activity i U(α) starting at time s i (α) that could have started 19

21 before (say at time s i (α)-1) satisfying both precedence and resource constraints. Dominance rule 3 This dominance rule has been proposed by Demeulemeester and Herroelen (1992). Consider two nodes α and α, respectively at level h(α) and h(α ) of two different paths of the search tree. The node α is dominated by the node α if the following conditions hold: (1) E(α) = E(α ); (2) t(α ) t(α), (3) s i (α ) + d i -1 max [s i (α) + d i -1, t(α)], i U(α ) (every activity i in progress at node α does not finish later than the maximum time between t(α) and the finishing time of the corresponding finishing time at node α). In the following we give the outline of a tree search algorithm, called BBLB3, which makes use of the dominance rules 1, 2 and 3 and the lower bounds LB0 and LB3. We denote by LB3(α) the value of the lower bound LB3 computed at node α of the tree search. Tree Search Algorithm BBLB3 Step 0: [Initialization] Set ZUB=, α=0, W(α)=0 and OPEN={α} Compute the index set R of all feasible subsets Step 1: [Choice of node α for branching] If else OPEN = then Stop let α be such that W(α) = Max [ W(β) : β OPEN] 20

22 Remove α from OPEN Compute bound LB0(α); If LB0(α) ZUB then goto Step 1 If the solution corresponding to LB0(α) is feasible, then update ZUB=LB0(α) Compute bound LB3(α); If LB3(α) ZUB then goto Step 1 Apply dominance rule 3 to node α; If node α is dominated then goto Step 1 Step 2: [Expansion of node α] Extract from R the subset N(α) and reduce N(α) using dominance rules 1 and 2 For each feasible subset R l, l N(α), a new node of the tree search is generated and appended to OPEN Goto Step 1 Notice that before computing LB0(α) and LB3(α) in Step 1, the graph G (and consequently G ~ ) must be updated to take into account the new precedences induced by the starting times s i (α), i W(α). 6. Computational results The algorithm presented in this paper was coded in Fortran 77 and tested on a IBM PS/2 55 sx (80386sx processor, 15 MHz) running under DOS. Bound LB1 was computed using the XMP linear programming package (Marsten, 1981). Our computational study was conducted on two sets of test problems. Our objective was the evaluation of the performance both of the new lower bounds (LB1, LB2, LB3, LBP and LBX) with respect to LB0 and LBS and of the new exact algorithm BBLB3 with respect to the exact algorithm of Demeulemeester and Herroelen (1992), hereafter called DH. 21

23 The first set of test problems used correspond to the 110 problems assembled by Patterson (1984). The second set of problems, hereafter called KSD, has been generated by Kolisch at al. (1992) with the objective to show that the Patterson problems can no longer be considered a benchmark, since it is possible to construct instances with the same number of activities, which are much more difficult to solve. Kolisch at al. in fact show that among 480 instances they generated, 52 hard instances could not be solved optimally by algorithm DH within a time limit of 3600 seconds on the same machine that we used. Table 1 presents the comparison of the different lower bounds for the Patterson problems where, following Demeulemeester and Herroelen, the problems have been categorized into 5 groups: 8 problems with less than 22 activities, 46 problems with 22 activities, 47 problems with 27 activities, 10 problems with 51 activities and 3 remaining problems with 23, 35 and 35 activities, respectively. Tables 2 and 3 present the lower bound comparison for the KSD problems, which is a problem test set composed of groups of 10 problems each, all defined over 32 activities, where all the problems of a group have been generated by Kolisch et al. (1992) using the same values for the hardness control parameter they identified. Table 2 presents the results for all groups (15) containing at least one problem instance which could not be solved to optimality by the DH code (these are the difficult instances), while table 3 presents 8 randomly chosen out of 53 problem groups whose instances can be solved to optimality by DH. Tables 1, 2 and 3 show the following columns: Group:identifier of problem subset, and number of activities of the relative projects (in parentheses); np: number of problems in the group; 22

24 LB0,, LB1: average and maximal (in parentheses) percentage distance from the optimum of bounds LB0, LBS, LBX, LBP, LB3, LB2, LB1 computed at the root node of the tree search; R M average and maximum (in parentheses) number of feasible subsets used to compute LB1; average and maximum (in parentheses) number of undominated feasible subsets used to compute LB2. TABLE 1 - Bounds for the Patterson problems. Group np LB0 LBS LBX LBP LB3 LB2 LB1 R M (<22) (27.3) (27.3) (9.1) (9.1) (9.1) (5.3) (5.3) (211) (58) (22) (46.0) (46.0) (28.0) (28.0) (28.0) (12.5) (12.5) (707) (303) (27) (51.6) (51.6) (31.7) (20.7) (20.7) (14.6) (14.6) (501) (255) (51) (5.3) (5.3) (5.3) (5.3) (5.3) (5.0) (5.0) (1294) (577) (23-35) (23.1) (23.1) (15.4) (15.4) (15.4) (7.7) (7.7) (1907) (280) avg avg. max. (30.6) (30.6) (17.9) (15.7) (15.7) (9.0) (9.0) Tables 1, 2 and 3 show that each of the new lower bounds, LB1, LB2, LB3, LBX and LBP, is better than Stinson s bound LBS on almost all problem groups. Bound LB0 is the worst of all, LB1 is the best lower bound on all problems groups, while LB2 is the second best and dominates the three lower bounds LB3, LBX and LBP. LBP is better than LB3 and LBX, while LB3 is almost equal to LBX, even though much faster to compute. In fact, in our computational experience we have that LB3 is on average 2.2 times faster than LBX and 13.2 times faster than LBP. 23

25 TABLE 2 - Bounds comparison on the difficult KSD problems (10 problems per group). Group LB0 LBS LBX LBP LB3 LB2 LB1 R M j30_ (43.4) (43.4) (36.5) (23.2) (23.2) (23.2) (23.2) (2905) (413) j30_ (51.09) (51.1) (34.9) (25.4) (28.6) (15.9) (15.9) (1065) (263) j30_ (54.7) (54.7) (36.8) (23.6) (23.6) (11.1) (11.1) (691) (355) j30_ (17.0) (17.0) (17.0) (14.0) (14.0) (14.0) (12.0) (8036) (2529) j30_ (8.0) (8.0) (8.0) (8.0) (8.0) (4.0) (4.0) (19375) (3743) j30_ (44.9) (43.5) (23.7) (20.8) (23.6) (13.8) (13.8) (460) (180) j30_ (53.3) (52.2) (39.1) (26.1) (26.1) (13.0) (13.0) (341) (213) j30_ (44.9) (44.9) (17.0) (17.0) (26.1) (11.4) (11.4) (237) (95) j30_ (49.6) (44.8) (22.6) (22.6) (25.0) (9.3) (9.3) (190) (113) j30_ (20.3) (20.3) (20.3) (16.9) (16.9) (7.3) (7.3) (889) (388) r30_ (11.3) (11.3) (11.3) (11.32) (11.3) (11.3) (11.3) (16312) (1465) s30_ (40.0) (40.0) (25.7) (22.5) (26.2) (18.7) (18.7) (1437) (245) s30_ (27.3) (27.3) (15.9) (15.9) (21.8) (15.9) (15.9) (6497) (543) s30_ (14.7) (14.7) (13.3) (13.3) (14.7) (13.3) (13.3) (4895) (686) v30_ (13.8) (13.8) (13.8) (13.8) (13.8) (13.8) (13.8) (131070) (10414) avg avg. max (33.0) (32.5) (22.9) (18.3) (20.2) (13.1) (12.9) TABLE 3 - Bounds comparison on easier KSD problems (10 problems per group). Group LB0 LBS LBX LBP LB3 LB2 LB1 R M j30_ (14.9) (14.3) (15.7) (14.3) (14.3) (11.9) (11.9) (10153) (1134) j30_ (12.2) (12.2) (11.4) (8.2) (8.2) (8.2) (8.2) (23679) (1375) j30_ (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (0.0) (44749) (1141) j30_ (9.8) (9.8) (9.8) (9.8) (9.8) (9.8) (9.8) (11461) (1644) j30_ (37.7) (33.3) (19.3) (14.5) (19.7) (13.0) (13.0) (846) (147) 24

26 j30_ (13.5) (13.5) (13.5) (13.5) (13.5) (11.5) (11.5) (4698) (466) j30_ (18.9) (18.9) (18.9) (17.0) (18.9) (10.9) (10.9) (3152) (1009) j30_ (41.8) (41.8) (15.8) (15.8) (20.6) (14.5) (14.5) (598) (120) avg avg. max (18.6) (18.0) (13.0) (11.7) (13.0) (10.0) (10.0) A second set of tests has been carried out to evaluate the efficiency of the branch-and-bound procedure BBLB3 described in Section 5. BBLB3 has been able to solve to optimality all the Patterson problems. However, BBLB3 was in average 5 times slower on the Patterson problems than the DH code, despite their use of lower bound LBS. In our opinion this is due to two main reasons: the first is that in several instances of this set LBS is not much worse than LB3 while it is computationally less expensive; the second is the very good quality of the implementation of the DH code made by Demeulemeester and Herroelen. Tables 4 and 5 present the comparison of four different branch and bound algorithms: DH, BBLB3, BBLBX and BBLB3_ND1 on the KSD instances. BBLBX is the branch and bound procedure presented in Section 5, using LBX instead of LB3, and BBLB3_ND1 is the same as BBLB3, but without dominance rule 1. We do not report the computational results obtained by using the lower bounds LB1, LB2 and LBP in the tree search algorithm of Section 5 since, even though these bounds are of a quality superior to that of LB3 and LBX, they are expensive to compute and the resulting tree search procedures were slower than BBLB3 or BBLBX on all test problems. TABLE 4- Performance of algorithms DH and BBLB3 on the difficult KSD problems. DH BB LB3 BB LBX BBLB3 _ND1 Time NOPT DH Time Nodes Time Nodes Time Nodes j30_ (3600.1) (1.3) (924.9) (36665) (2731.8) (40476) (2440.2) (132840) j30_ (3600.0) (11.8) (2686.4) (91188) ( ) (126587) (4309.2) (185661) 25

27 j30_ n.a. n.a. (3600.0) (6.6) ( ) (561823) ( ) (689136) n.a. n.a. j30_ (3600.0) (2.2) (4732.2) (169308) ( ) (207790) (7014.7) (287145) j30_ (3600.0) (0.0) (1233.2) (44517) (3152.4) (47853) (1988.5) (80275) j30_ (3600.0) (7.2) (1135.3) (44875) (4844.5) (47320) (1799.7) (79587) j30_ (3600.0) (6.2) ( ) (447654) ( ) (539819) ( ) (630662) j30_ (3600.0) (3.0) (105.2) (4064) (337.0) (3576) (153.0) (7090) j30_ (3600.0) (4.8) (310.7) (11141) (944.1) (9715) (446.9) (16314) j30_ (3600.0) (3.4) (327.4) (13148) (1156.8) (17649) (449.3) (24112) r30_ (3600.0) (2.4) (1295.4) (64125) (5164.8) (88724) (2715.0) (97579) s30_ (3600.0) (37.3) (329.8) (38427) (1087.5) (12551) (568.8) (28653) s30_ (3600.0) (18.2) (435.0) (13572) (1199.8) (19929) (939.3) (44956) s30_ (3600.0) (0.0) (255.7) (16376) (614.2) (15530) (580.8) (32592) v30_ (3600.1) (0.0) (2502.3) (10785) (5616.5) (62552) (6436.3) (192611) n.a.: not available because of exceeded memory limit Tables 4 and 5 show the following columns: Time: average and maximum CPU time in seconds; NOPT:number of problems, over 10, solved to optimality by DH; DH: average and maximum percentage distance from optimality of the best DH solutions; Nodes:number of nodes of the search tree to find the optimal solution. Table 4 shows that BBLB3 is capable of solving each of the hard problem instances, while DH can solve completely none of these groups of problems. Table 4 shows that on most hard instances BBLB3 outperforms DH. BBLBX has been slower than BBLB3 on all problem groups, even though some problems have been solved after expanding a smaller number of nodes. BBLB3_ND1 obviously expanded more nodes and has been much slower than BBLB3, thus 26

28 testifying the effectiveness of our new dominance rule 1. TABLE 5 - Performance of algorithms DH and BBLB3 on the easier KSD problems. DH BB LB3 BB LBX BBLB3 _ND1 Time NOPT DH Time Nodes Time Nodes Time Nodes j30_ (99.6) (0) (186.4) (7135) (470.8) (11080) (523.4) (24017) j30_ (9.6) (0) (164.9) (5766) (365.7) (7293) ( ) (22378) j30_ (0.1) (0) (16.4) (54) (16.7) (66) (14.3) (64) j30_ ( ) (0) (991.8) (39776) (2452.1) (51702) (1687.3) (85982) j30_ (1907.1) (0) (114.7) (4622) (487.6) (5337) (236.6) (11811) j30_ (211.1) (0) (236.6) (8873) (702.7) (10451) (506.7) (22737) j30_ (1257.0) (0) (523.4) (19051) (2313.5) (40055) (781.5) (33918) j30_ (219.7) (0) (55.0) (2122) (210.3) (2141) (1123.3) (4370) Table 5 shows that on the easier problems, none of the DH or BBLB3 algorithms dominates the other one. Algorithm BBLB3 is better than DH for problems where LB3 is better than LBS (see groups j30_37 and j30_53) and also for some problems (groups j30_26 and j30_46) where the bounds at the root node are identical. This is due to the fact that, even though the bounds at the root node are the same, LB3 is able to fathom a larger number of nodes than LBS during the search process. In all problems where DH outperforms BBLB3, we have that the two bounds are identical at the root node and, during the search, LB3 is not significantly better than LBS. BBLBX has been again consistently slower than BBLB3; the same is true for algorithm BBLB3_ND1 except for problem group j30_24 which was too simple to justify the extra computational cost derived by the dominance rule. 27

29 7. Conclusions In this paper we have described a new formulation for the Resource Constrained Project Scheduling Problem. The new formulation has been used to derive five new lower bounds, respectively called LB1, LB2, LB3, LBX and LBP, and an exact tree search procedure, called BBLB3. LB1 is obtained by finding an exact solution of a linear programming relaxation of the new formulation, called RP1, where a variable corresponds to a feasible subset of activities that can be simultaneously in progress. LB2 is the optimal value of the objective function of problem RP2, a relaxation of RP1, whose variables are a small subset of the variables of RP1. Finally, a weighted node packing problem WNP is derived from RP2: the value of its exact solution corresponds to bound LBP, while the feasible solutions obtained by two heuristic algorithms, one due to Xue (1994) and one (called HWNP) proposed in this paper, produce bounds LBX and LB3, respectively. We proved that LB1 LB2 LB3 LB0, where LB0 is the value of the longest path on the precedence graph. Moreover, the computational results carried out over two standard sets of test problems, respectively proposed by Patterson (1984) and by Kolisch et al. (1992), show that, on hard problem instances, the new bounds are much better than the bound proposed by Stinson et al. (1978). The exact algorithm, BBLB3, is a tree search procedure which uses LB3 as a lower bound. Computational results show that BBLB3 is competitive with the best exact algorithm so far proposed in the literature (algorithm DH, presented by Demeulemeester and Herroelen in 1992) on difficult cases, where LB3 is greater than LBS; however, BBLB3 does not dominate DH on easier problems, where LB3 LBS. 28

30 References Balas E., "Project Scheduling with Resource Constraints", in E.M.L.Beale (ed.), Application of Mathematical Programming Techniques, American Elsevier, (1970). Blazewicz J., Lenstra J.K., Rinnooy Kan A.H.G., "Scheduling Projects Subject to Resource Constraints: Classification and Complexity", Discrete Applied Mathematics, 5, (1983), Carraghan R., Pardalos P.M., An Exact Algorithm for the Maximum Clique Problem, Operations Research Letters, 9, (1990), Christofides N., Alvarez-Valdes R., Tamarit J.M., "Project Scheduling with Resource Constraints: a Branch and Bound Approach", Eur. J. of Operations Research, 29, (1987), Davies E.W., Heidorn G.E., "An Algorithm for Optimal Project Scheduling under Multiple Resource Constraints", Management Science, 17, (1971), Demeulemeester E., Herroelen W., "A Branch and Bound Procedure for the Multiple Resource- Constrained Project Scheduling Problem", Management Science, 38, 12, (1992), Elmaghraby S.E., Activity Networks: Project Planning and Control by network Models, J.Wiley, (1977). Fisher M., "Optimal Solution of Scheduling Problems Using Lagrange Multipliers. Part I", Operations Research, 21, 5, (1973), Gorenstein S., "An Algorithm for Project Sequencing with Resource Constraints", Operations Research, 20, 4, (1972), Kolisch R., Sprecher A., Drexl A., "Characterization and Generation of a General Class of Resource-Constrained Project Scheduling Problems: Easy and Hard Instances", Tech. Rep. 29

31 n.301, Institut für Betriebswirtschaftslehre, Christians-Albrechts-Universität, Kiel, (1992) (to appear in Management Science). Marsten R., The Design of the XMP Linear Programming Library, ACM Trans. on Mathematical Software, 9, (1981), Nemhauser G.L., Trotter L.E., "Vertex Packings: Structural Properties and Algorithms", Mathematical Programming, 8, (1975), Nemhauser G.L., Wolsey L.A.., Integer and Combinatorial Optimization, Wiley Interscience, (1988). Pardalos P.M., Xue J., "The Maximum Clique Problem", Technical Report, University of Florida, (1992). Patterson J.H., Huber W.D., "A Horizon-Varying, Zero-One Approach to Project Scheduling", Management Science, 20, (1974), Patterson J.H., Roth G.W., "Scheduling a Project under Multiple Resource Constraints: a Zero- One Programming Approach", AIIE Transactions, 8, (1976), Patterson J.H., "A Comparison of Exact Approaches for Solving the Multiple Constrained Resource, Project Scheduling Problem", Management Science, 30, (1984), Pritsker A.A.B., Watters W.D., Wolfe P.M., "Multiproject Scheduling with limited Resources: a Zero-One Programming Approach", Management Science, 16, (1969), Schrage L., "Solving Resource-Constrained Network Problems by Implicit Enumeration - Nonpreemptive Case", Operations Research, 18, (1971), Stinson J.P., Davis E.W., Khumawala B.M., "Multiple Resource-Constrained Scheduling Using Branch and Bound", AIIE Transactions, 10, (1978),

32 Talbot F.B., Patterson J.H., "An Efficient Integer Programming Algorithm with Network Cuts for Solving Resource-Constrained Scheduling Problems", Management Science, 24, (1978), Xue J., Edge-Maximal Triangulated Subgraphs and Heuristics for the Maximum Clique Problem, Networks, 24, (1994),