An Exact Algorithm for the Simplified Multiple Depot ... - Springer Link

Annals of Operations Research 127, 177–201, 2004  2004 Kluwer Academic Publishers. Manufactured in The Netherlands.

An Exact Algorithm for the Simplified Multiple Depot Crew Scheduling Problem M.A. BOSCHETTI and A. MINGOZZI

Department of Mathematics, University of Bologna, Bologna, Italy S. RICCIARDELLI

Department of Electrical Engineering, University “Tor Vergata”, Rome, Italy

Abstract. The Multiple Depot Crew Scheduling Problem (MD-CSP) appears in public transit systems (e.g., airline, bus and railway industry) and consists of determining the optimal duties for a set of crews (or vehicles) split among several depots in order to cover a set of timetabled trips satisfying a number of constraints. We consider the case in which every crew must return to the starting depot and limits are imposed on both the elapsed time and the working time of any duty. The MD-CSP is an extension of both the Multiple Depot Vehicle Scheduling Problem (MD-VSP) and the single depot Crew Scheduling Problem (CSP). The MD-CSP is formulated as a set partitioning problem with side constraints (SP), where each column corresponds to a feasible duty. In this paper we extend to the MD-CSP the exact method used by Bianco, Mingozzi and Ricciardelli (1994) for MD-VSP and that used by Mingozzi et al. (1999) for the CSP. We also introduce a new bounding procedure based on Lagrangian relaxation and column generation which can deal with the MD-CSP constraints. The computational results for both random and real-world test problems from the literature show that the new exact procedure outperforms, on the test problems used, other exact methods proposed in the literature for the MD-VSP and the CSP. Keywords: dual heuristics, set partitioning, personal scheduling

1.

Introduction

The Multiple Depot Crew Scheduling Problem (MD-CSP) considered in this paper is the problem of scheduling a set of crews (e.g., bus drivers) or vehicles (e.g., buses), split among different depots, so as to perform a number of transportation tasks, called trips. Each trip requires a crew from a fixed starting time to a fixed ending time. Each crew can perform a sequence of trips, called duty, satisfying the following constraints: (i) each crew must return to the starting depot, (ii) the total time between the start and the end of any duty (elapsed time) cannot exceed a given limit, (iii) the total duration of the trips assigned to a duty (working time) is limited, (iv) the number of crews available at each depot is limited.

178

BOSCHETTI, MINGOZZI AND RICCIARDELLI

The MD-CSP consists of grouping the set of trips in a number of disjoint feasible duties and in assigning each duty to a different crew in such a way that the total cost of the duties is minimised. The MD-CSP is a simplified version of a variety of real-world Crew Scheduling (CSP) and Multiple Depot Vehicle Scheduling (MD-VSP) problems arising in freight transport and mass transit industries (e.g., airline, bus and railway industry) that may differ in the objective function and the duty constraints (union contract, company regulation, etc.). In general, all these problems can be formulated as the problem of covering the vertices of an acyclic graph by means of a number of minimum cost vertex disjoint paths that satisfy a number of constraints. The graph is such that each vertex i corresponds to a trip and arc (i, j ) exists if trip j can be performed immediately after trip i by the same crew or vehicle. Papers in the literature dealing with the CSP and the MD-VSP are often industry oriented and the solution algorithms developed are designed to deal with the particular constraints and objective functions encountered in real life applications. The MD-CSP considered in this paper is NP-hard and is an extended model which includes as subproblems both the basic CSP and the basic MD-VSP which are simplified, but still NP-hard, versions of real-world situations. The basic CSP has been proposed by Beasley and Cao (1996) as a highly simplified problem which captures the basic structure of any crew scheduling situation: only one depot is given and the duty feasibility is limited to the elapsed time constraint. The Basic CSP has also been studied by Mingozzi et al. (1999) and Fischetti et al. (2001). The Basic MD-VSP was introduced by Carpaneto et al. (1989). Two or more depots are specified and the only duty feasibility constraint requires that a crew starts and ends at the same depot. The MD-VSP has also been studied by Ribeiro and Soumis (1994), Bianco, Mingozzi and Ricciardelli (1994), Forbes, Holt and Watts (1994), Fischetti et al. (2001) and Hadjar, Marcotte and Soumis (2001). A more constrained version of the MD-VSP for practical bus transit applications has been recently addressed by Löbel (1998a, 1998b). The exact methods for the CSP and MD-VSP described in the literature are based on three types of formulations. Carpaneto et al. (1989) present a method based on a “single-commodity” formulation for the MD-VSP. This was also used by Beasley and Cao (1996) to derive an exact branch and bound algorithm for the basic CSP based on Lagrangian relaxation, and by Beasley and Cao (1998) who describe a tree search procedure using a lower bound based on dynamic programming and Lagrangian relaxation. The “single commodity” model appears effective when only a few depots are involved and duty constraints are simple. Fischetti et al. (2001) describe a branch and cut algorithm for solving both the MD-VSP and the CSP. A branch and cut algorithm for solving the MD-VSP which combines column generation and cutting planes is described by Hadjar, Marcotte and Soumis (2001). Forbes, Holt and Watts (1994) and Löbel (1998a, 1998b) use a “multi-commodity” model for solving the MD-VSP. The main drawback of these two models is the difficulty of representing real-world constraints and costs. In particular, the cost of a duty can only be computed as the sum of the arc costs of the corresponding path in the acyclic graph.

EXACT ALGORITHM FOR A CREW SCHEDULING PROBLEM

179

The third model is based on the “Set Partitioning” (SP) formulation where each variable corresponds to a feasible duty. This model accommodates all constraints pertaining the feasibility of a single duty and allows the duty cost to depend on the duty, hence it appears more effective in representing real-world applications. This model involves a large number of variables (typically exponential), however it produces tight LP relaxations. Exact methods using column generation techniques are described in (Cranic and Rousseau, 1987; Lavoie, Minoux and Odier, 1988; Desrochers and Soumis, 1989; Ribeiro and Soumis, 1994). These methods are time-consuming as the LP relaxation of the master problem is usually highly degenerate. Degeneracy implies alternative optimal dual solutions and, consequently, the generation of new variables which might not affect the optimality of the master problem. The master problem tends to become large and the overall method may become slow. A different exact method based on the SP formulation, which avoids the drawbacks of the aforementioned column generation methods, is described in (Bianco, Mingozzi and Ricciardelli, 1994; Mingozzi et al., 1999) for the MD-VSP and the CSP, respectively. These two exact methods use the same strategy. First, an effective solution of the dual of the LP relaxation of SP, called DSP, is computed using a number of heuristic procedures which do not require the generation of the entire duty set. The exact procedure uses the dual solution to generate a limited subset of duties so that the resulting reduced problem SP can be solved by an integer programming solver and it is possible to check if the solution produced is an optimal SP solution. In case optimality is not achieved, then the procedure is iteratively repeated with a larger duty subset until either optimality is proved or the distance from optimality is below an a priori defined threshold level. The kernel of this exact procedure is a method for solving problem DSP which combines different bounding procedures, each one exploring a different structure of the problem. In this paper we extend to the MD-CSP the method presented by Bianco, Mingozzi and Ricciardelli (1994) and Mingozzi et al. (1999). The main contributions of this paper are a new bounding procedure, the extension to the MD-CSP of the duty generation procedure described in (Bianco, Mingozzi and Ricciardelli, 1994) for the MD-VSP, an exact method for the MD-CSP that can also solve efficiently both the MD-VSP and the CSP without requiring any specific adaptation, new results for both the MD-VSP and the CSP and a set of test problems and results for the MD-CSP. The new bounding procedure combines Lagrangian relaxation and column generation producing a lower bound of the same quality of the value of the LP relaxation of SP. This procedure is an effective alternative to the classical column generation methods as it is not affected by the typical degeneration drawbacks in solving the linear relaxation of the master problem with a LP solver. The new exact method has been evaluated on both random and real-world test problems derived from the literature for the CSP and the MD-VSP. The computational results show that the implementation of new proposed method outperforms, on the test problems used, the implementation of all other exact methods presented in the literature.

180

2.


The basic MD-CSP problem

The MD-CSP considered in this paper is as follows. A set of n trips T1 , . . . , Tn and a set of m 1 depots are given. Each trip Ti requires a crew/vehicle (henceforth crew) from a starting time si to an ending time ei > si and has a weight wi (usually wi = ei −si ). With each pair of trips (Ti , Tj ) is associated a cost dij and a travel time τij which are spent by a crew in performing Tj immediately after Ti . We allow for arc costs dij = +∞ so as to model problem-specific incompatibilities between trip pairs. For example, we can set dij = +∞ if Tj cannot be covered immediately after Ti by the same crew because ei + τij > sj . At each depot k = 1, . . . , m are located bk identical crews. We denote by d¯ki and τ¯ki (respectively d¯ik and τ¯ik ) the cost and the time spent by a crew travelling from the location of depot k (respectively from the ending location of trip Ti ) to the starting location of trip Ti (respectively to the location of depot k). We assume d¯ki = +∞ (respectively d¯ik = +∞) if it is not possible for any crew to travel from depot k (respectively from the ending location of trip Ti ) to the starting location of trip Ti (respectively to depot k). A duty for a crew of depot k is an ordered sequence of h trips (Tj1 , . . . , Tjh ) satisfying the following constraints (henceforth called duty constraints): (1) any two consecutive trips (Tjr , Tjr+1 ) in the sequence satisfies ejr + τjr jr+1 sjr+1 ; (2) the crew must return to the starting depot; (3) the elapsed time is limited, i.e. τ¯kj1 + (ejh − sj1 ) + τ¯jh k ET; (4) the working time is limited, i.e. hi=1 wji WT; ¯ (5) the cost of the duty given by d¯kj1 + h−1 i=1 dji ji+1 + djh k is finite. The MD-CSP is the problem of designing no more than bk duties for each depot k such that each trip is covered by exactly one duty and the sum of all duty costs is minimized. In the following we assume, without loss of generality, that the trips are numbered according to non decreasing value of the starting time, i.e. si sj , for each i < j . 3.

Mathematical formulation

The MD-CSP can be modelled by means of a digraph G = (V , A) defined as follows. V = V ∪ D, where V = {1, 2, . . . , n} and D = {n + 1, . . . , n + m}, is the set on n + m vertices and A is the set of directed arcs. Each vertex j ∈ V is associated with trip Tj (j = 1, . . . , n) and each vertex j ∈ D corresponds to depot k = j − n. We associate the weight wj of trip j with each vertex j ∈ V (we assume wk = 0, k ∈ D). The set A contains all arcs (i, j ) for every pair of trips (Ti , Tj ) with cost dij < ∞. Moreover, for each trip vertex j = 1, . . . , n and each depot k = 1, . . . , m the set A


181

contains (n + k, j ) with d¯kj < ∞ and (j, n + k) with d¯j k < ∞. A cost cij and a travel time tij are associated with arc (i, j ) ∈ A. They are defined as follows: cij = dij cij = d¯i−n,j cij = d¯i,j −n

and and and

tij = τij , ∀i, j ∈ V , tij = τ¯i−n,j , ∀i ∈ D and ∀j ∈ V , tij = τ¯i,j −n , ∀i ∈ V and ∀j ∈ D.

(1)

A duty (Tj1 , . . . , Tjh ) for a crew of depot k, corresponds to a circuit of G starting and ending in vertex n + k and visiting in sequence vertices j1 , . . . , jh . By construction, any circuit of G contains exactly one of the depot vertices of set D and satisfies conditions (1), (2) and (5). Hence, any circuit of G satisfying also conditions (3) and (4) represents a duty and it is called a feasible circuit. The MD-CSP is the problem of designing a minimum-cost set of feasible circuits so that every vertex i ∈ V is covered exactly once and the number of circuits passing through each vertex n + k does not exceed bk , k = 1, . . . , m. Let i−1 and i be the set of predecessors and the set of successors of vertex i, (S) to indicate the set of predecessors of the vertex subset respectively. We use −1 S ⊆ V (i.e. −1 (S) = i∈S i−1 ). In a similar way we define (S) to be the set of successors of the vertex subset S ⊆ V . The MD-CSP can be formulated as a set partitioning problem with additional constraints. Let R be the index set of all duties, Ri ⊂ R the index set of the duties covering trip i ∈ V and Bk the index set of duties passing through vertex k ∈ D (i.e. performed by a crew of depot k − n). We indicate by σ () the depot associated with duty ∈ R and we use R to represent both the sequence of vertices (i.e. R = (σ (), i1 , i2 , . . . , ih , σ ())) and the sequence of arcs (i.e. R = ((σ (), i1), (i1 , i2 ), . . . , (ih , σ ()))) of the circuit in G corresponding to duty ∈ R. Moreover, we also use R and R = R \{σ ()} to indicate , σ ()}) and of graph G\D the subset of vertices of graph G (i.e. R = {i1 , i2 , . . . , ih visited by duty ∈ R, respectively. We denote by c = (i,j )∈R cij the cost and by W = i∈R wi the working time of duty ∈ R. Define a (0–1) binary variable x equal to 1 if and only if duty ∈ R belongs to the optimal solution. The MD-CSP can be formulated as a Set Partitioning problem (SP) with additional constraints as follows: c x (2) (SP) min z(SP) = ∈R

subject to

x = 1,

i ∈ V ,

(3)

x bk−n ,

k ∈ D,

(4)

∈ R.

(5)

∈Ri

∈Bk

x ∈ {0, 1},

182


Constraints (3) specify that each task i ∈ V must be covered by one duty and constraints (4) ensure that the number of duties passing through vertex k ∈ D does not exceed the number bk−n of crews available at the depot k − n. Problem SP is impractical to solve, even for moderate size MD-CSP instances, since the number of variables of SP is as large as |R|, and |R| is typically exponential. In the following section we describe an exact method for solving SP which uses variable pricing in order to reduce the set R to solvable proportions. The pricing method is based on a bounding procedure for computing a near optimal solution of the dual problem of the LP-relaxation of SP (called DSP). Let u = (u1 , . . . , un , un+1 , . . . , un+m ) be the vector of the dual variables, where ui , i ∈ V , and uk , k ∈ D, are associated with constraints (3) and (4), respectively. Then, problem DSP becomes: ui + bk−n uk (6) (DSP) max z(DSP) = i∈V

subject to

ui + uσ () c ,

k∈D

∈ R,

(7)

i∈R

4.

ui unrestricted,

i ∈ V ,

uk 0,

k ∈ D.

(8)

An exact method for solving the MD-CSP

In solving the MD-CSP we use an exact method and a bounding procedure, called HDSP, which was introduced by Bianco, Mingozzi and Ricciardelli (1994) for the MD-VSP. Procedure HDSP was used for computing the lower bound to several routing and scheduling problems that can be formulated as set partitioning problems with additional constraints, such as the vehicle routing problem (Mingozzi, Christofides and Hadjiconstantinou, 1995), the vehicle routing problem with backhauls (Mingozzi, Baldacci and Giorgi, 1999), the crew scheduling problem (Mingozzi et al., 1999) and the capacitated p-median problem (Baldacci et al., 2002). 4.1. Description of the exact method We propose an iterative procedure for solving MD-CSP where at each iteration a reduced SP problem is solved. The procedure terminates when either an optimal SP solution is achieved or the distance of the solution cost of the reduced SP problem from the lower bound is less than a user defined value or a maximum number of iterations is reached. The scheme of the proposed exact method for solving SP is as follows. Step 1. Let u be the solution of DSP of cost z (DSP) obtained by the bounding procedure HSDP (described in the following section 4.2) and let c = c −


183

ui − uσ () be the reduced cost of duty ∈ R. Set z∗ (SP) = ∞ and iter = 0. i∈R

Step 2. Set iter = iter+1. Define a reduced problem SP derived from SP by considering that largest a subset F ⊂ R satisfying the following conditions: c < z∗ (SP) − z (DSP), max[c ] ∈F

min

∈R\F max

|F| $

,

∀ ∈ F,

[c ],

(9)

where $max is a user-defined parameter.

Step 3. Solve the integer program SP . Let z∗ (SP ) be the cost of an optimal SP solution x∗ . We assume z∗ (SP ) = ∞ if the set F contains no feasible solution of MD-CSP. Update z∗ (SP) = min[z∗ (SP), z∗ (SP )]. Step 4. Test if the SP solution obtained is an optimal MD-CSP solution. Let Newb be a lower bound to the cost of any solution involving one or more duties of the set R\F. Newb is given by: Newb = z (DSP) + max[c : ∈ F], if |F| = $max , while Newb = ∞, if |F| < $max . We have two cases: (a) z∗ (SP ) Newb, then Stop as x∗ is guaranteed to be an optimal MD-CSP solution. This follows directly from linear programming duality, which ensures that any SP solution involving a duty ∈ R\F costs at least z (DSP) + c Newb. (b) z∗ (SP ) > Newb, then x∗ is not guaranteed to be an optimal MD-CSP solution, but Newb is a valid lower bound to the optimal MD-CSP cost. Step 5. If iter itermax or (Newb −z∗ (SP ))/ Newb gapmax then Stop, otherwise increase the value of the parameter $max (according to a user defined strategy, for example, setting $max = β$max , where β > 1) and go to step 2. Parameter itermax and gapmax must be defined a priori. The effectiveness of the proposed exact method is related to the quality of the dual solution u : the better the DSP solution the smaller the reduced costs of the duties of an optimal MD-CSP solution and, hopefully, the smaller the size of subset F that must be generated to solve the MD-CSP. A method for computing the dual solution u is described in the following section. 4.2. Bounding procedure HDSP Procedure HDSP consists in solving a sequence of linear programs DSP1 , DSP2, . . . , DSPt by using t different heuristic procedures H1 , . . . , Ht . Each procedure Hr , r = 1, 2, . . . , t, finds a feasible solution ur of cost z(DSPr ) of problem DSPr defined as follows:

184


r max z DSPr = ui + bk−n urk

(DSPr )

i∈V

(10)

k∈D

subject to

uri + urσ () cr ,

∈ R,

(11)

i∈R

where cr = c −

uri unrestricted,

i ∈ V ,

urk 0,

k ∈ D,

(12)

0 u0i + u1i + · · · + ur−1 − uσ () + u1σ () + · · · + ur−1 i σ () i∈R

and u0 = 0 as DSP1 = DSP. It can be shown that u = u1 + u2 + · · · + ut is a feasible solution of DSP of cost z (DSP) = z(DSP1 ) + z(DSP2 ) + · · · + z(DSPt ). Moreover, the final lower bound z (DSP) is greater than or equal to each lower bound z(DSPr ) produced by each individual procedure Hr when applied to the original problem DSP. 5.

Computing the lower bound to the MD-CSP

In this section we describe three different bounding procedures H1 , H2 and H3 used in sequence by procedure HDSP. Procedure H1 does not require the generation of the duty set R and has been proposed by Bianco, Mingozzi and Ricciardelli (1994) for the MD-VSP. Procedure H2 is based on the one proposed by Mingozzi et al. (1999) for the CSP but it involves an effective column generation method to take into account all duty constraints of the MD-CSP. Our computational results show that the new procedure H2 , when applied to the CSP, is computationally more effective than the original version of H2 proposed by Mingozzi et al. (1999). Procedure H3 has been proposed by Bianco, Mingozzi and Ricciardelli (1994) and it is here adapted to the MD-CSP by implementing the new column generation procedure. 5.1. Procedure H 1 This bounding procedure can be applied to MD-CSP problems where the duty costs depend linearly on the arc costs. We relax the duty constraints (2)–(4), described in section 2, but we require that all vertices V are covered by vertex disjoint paths starting and ending at vertices of D. Moreover, we also require that the number of paths starting at depot k is equal to the number of paths ending at depot k. This relaxed problem, called RP1, can be formulated as follows. Let ξij be a (0–1) binary variable equal to 1 if and only if arc (i, j ) ∈ A is in the optimal solution and let


185

yk 0 be the number of unused crews located at depot k, k = 1, . . . , m. z(RP1) = min

(RP1)

cij ξij

(13)

(i,j )∈A

subject to

i ∈ V ,

(14)

j ∈ V ,

(15)

ξn+k,j + yk = bk ,

k = 1, . . . , m,

(16)

ξi,n+k + yk = bk ,

k = 1, . . . , m,

(17)

ξij ∈ {0, 1},

(i, j ) ∈ A,

(18)

yk 0,

k = 1, . . . , m.

(19)

ξij = 1,

j ∈i

ξij = 1,

i∈j−1

j ∈n+k

−1 i∈n+k

Problem RP1 corresponds to a min-cost transportation problem with (n + m) origins and (n + m) destinations. Bianco, Mingozzi and Ricciardelli (1994) obtained the following result. Let vi , i ∈ V , and ϕj , j ∈ V , be the values of optimal dual variables associated with constraints (14) and (15) and vn+k and ϕn+k , k = 1, . . . , m, the values of the optimal dual variables of constraints (16) and (17), respectively. Then, a solution u1 to DSP1 of cost z(DSP1 ) = z(RP1) is given by u1i = vi + ϕi , i ∈ V . 5.2. Procedure H 2 based on Lagrangian relaxation and column generation We denote by DSP2 the problem that, according to the HDSP scheme, is derived from {c2 } which are computed using soluDSP by replacing costs {c } with the reduced costs tion u1 obtained by procedure H1 , i.e. c2 = c − i∈R u1i − u1σ () , ∈ R. In bounding procedure H2 we relax in a Lagrangian fashion both SP constraints (3) and (4) and we require every duty to satisfy all the duty constraints (1) to (5) described in section 2. Consider a penalty vector λ = (λ1 , . . . , λn ), where λi is an unrestricted real associated with constraint (3) for vertex i ∈ V and a penalty vector µ = (µn+1 , . . . , µn+m ), where µn+k 0 is associated with constraint (4) for each depot k = 1, . . . , m.

186


Bianco, Mingozzi and Ricciardelli (1994) have shown that a feasible solution u2 of DSP can be obtained by means of vectors λ and µ as follows: (c2 − λ − µ ) σ () j ∈R j + λi , i ∈ V , u2i = wi · min ∈Ri (20) W 2

u2k = µk ,

k ∈ D.

We denote by z(DSP2 (λ, µ)) the cost of solution u2 computed according to expressions (20) for a given pair of vectors λ and µ. The optimal solution cost of the following problem (21) max z DSP2 (λ, µ) λ,µ

provides the best possible lower bound which can be computed by means of expressions (20). In practice, problem (21) cannot be solved even by means of subgradient optimization as the computation of solution u2i , i ∈ V , for a given pair of vectors λ and µ, requires the a priori generation of the duty set R. Bianco, Mingozzi and Ricciardelli (1994) and Mingozzi et al. (1999) proposed to solve the minimization problem required by expressions (20) using dynamic programming based algorithms specialised for the MD-VSP and the CSP, respectively. These two methods cannot be extended to the MD-CSP without either relaxing some of the duty constraints or the depot constraints thus producing a weak lower bound. The new procedure H2 that we propose for the MD-CSP is an iterative algorithm which computes the cost of a suboptimal solution of problem (21) using a limited subset R ⊂ R. At each iteration, H2 uses expressions (20) to find a solution u¯ of cost z¯ of the reduced problem DSP derived from DSP2 by replacing R with a subset R ⊂ R. A duty generation procedure, called GENDUTY, described in section 6, is used to identify the ¯ duty subset N ⊂ R\R whose DSP2 constraints are violated by the current solution u. In case N = ∅, then u¯ is not a feasible DSP2 solution and N is added to the current core problem R, while, if N = ∅, then u¯ is a feasible DSP2 solution and z(DSP1 ) + z¯ is a lower bound to the MD-CSP. At each iteration, a subgradient vector is computed and used to update vectors λ and µ in order to maximize the value of lower bound z(DSP2 ). Procedure H2 . Step 1. Use procedure GENDUTY to generate an initial subset R ⊂ R such that |Ri | $a , where Ri = R ∩ Ri , ∀i ∈ V , and $a is an a priori defined parameter. Set z(DSP2 ) = 0, u2 = 0, λ = 0, µ = 0 and iter = 1. Step 2. Use (20) to compute a feasible solution u¯ of cost z¯ (DSP)2 = expressions u ¯ + ¯ k of the reduced problem DSP derived from DSP by i i∈V k∈D bk−n u replacing R with R. If z¯ (DSP) z(DSP2 ) then go to step 4.


187

Step 3. Use procedure GENDUTY to generate the largest subset N of feasible duties having the largest negative reduced cost with respect to u¯ and such that |N | $, where $ is a given parameter. We have two cases: (i) N = ∅, then u¯ satisfies all DSP2 dual constraints, and z¯ is a valid lower bound. In case z¯ (DSP) > z(DSP2 ) then update z(DSP2 ) = z¯ (DSP) and set ¯ u = u. (ii) N = ∅, then u¯ is not a feasible DSP2 solution and z¯ (DSP) is not a valid lower bound. Update R = R ∪ N . If |R| $b , where $b is an a priori defined parameter, remove from R at most |R|−$b duties having the largest positive reduced cost. Step 4. Set iter = iter + 1. If iter > Maxt2, then stop (Maxt2 represents the maximum number of iterations and must be fixed a priori); otherwise compute a subgra¯ as described in section 5.2.1, and dient vector θ = (θ1 , . . . , θn+m ) related to u, update penalties λ and µ as follows: 0.1¯z λi = λi + α

θ, 2 i j ∈V θj

i ∈ V ,

and

0.1¯z µk = µk + α θ, 2 k j ∈V θj

k ∈ D,

where α is a positive constant. Return to step 2. The initial duty set R at step 1 and the subset N , at each iteration of step 3, are generated by means of the same procedure GENDUTY, described in section 6, using different input parameters. At the end of procedure H2 , the MD-CSP lower bound is given by the cost z (DSP) = z(DSP1 ) + z(DSP2 ) of the solution u = u1 + u2 of DSP. 5.2.1. Computing a subgradient Problem DSP, considered at step 2 of H2 , is the dual of problem SP which derives from the LP-relaxation of SP by replacing R with R. Step 4 of procedure H2 requires a subgradient θ = (θ1 , . . . , θn+m ) of the (concave) function z¯ (DSP) at (λ, µ). Since the penalty vectors λ and µ are associated with constraints (3) and (4) of SP, the subgradient vector is related to those constraints. To compute the value of θ, we associated with the DSP solution u¯ a not necessarily feasible solution x¯ of SP satisfying the following equality: 2 c x¯ + θi λi + θk µk , (22) z¯ DSP = ∈R

i∈V

k∈D

where the components of the subgradient vector θ are computed with respect to x¯ as x¯ , i ∈ V , and θk = bk−n − x¯ , k ∈ D. (23) θi = 1 − ∈Ri

∈R∩Bk

The method for computing a solution x¯ of SP satisfying equality (22) is as follows.

188


Using expressions (20), the cost z¯ (DSP) of the DSP solution u¯ computed at step 2, for given penalty vectors λ and µ, is given by wi h i + λi + bk−n µk , (24) z¯ DSP = i∈V

where hi = min

i∈V

(c2 −

r∈R

k∈D

λr − µσ () )

W

∈Ri

.

Denoting by i , i ∈ V , the index of the feasible duty of R producing hi , i ∈ V , we have 2 ci − r∈R i λr − µσ (i ) wi + λi + bk−n µk . (25) z¯ DSP = Wi k∈D i∈V

i∈V

Let L be the set of all distinct elements of {1, 2 , . . . , n } and let I = {i : i ∈ V , i = }, ∈ L. Using the sets L and I , ∈ L, expression (25) becomes

w 2 i∈I wi i∈I i c − λr + λi z¯ DSP = W W ∈L ∈L r∈R i∈V i∈I wi − µσ () + bk−n µk . (26) W k∈D ∈L

Define solution x¯ of SP as x¯ =

i∈I

wi

W

,

∈ L,

and

x¯ = 0,

∈ R\L.

(27)

Setting λ(R ) = r∈R λr , expression (26) becomes 2 c x¯ − λ R x¯ + λi − µσ () x¯ + bk−n µk . z¯ DSP = ∈R

Since

i∈V

∈R

λ R x¯ = x¯ λi i∈V

∈R

∈Ri

and

∈R

µσ () x¯ =

∈R

(28)

k∈D

x¯ µk ,

k∈D ∈R∩Bk

the expression (28) can be written as 2 c x¯ − x¯ − 1 λi − x¯ − bk−n µk z¯ DSP = ∈R

i∈V

∈Ri

k∈D

∈R∩Bk

which corresponds to expression (22) where the subgradient vector θ = (θ1 , . . . , θn , . . . , θn+m ) is computed according to expressions (23).


189

5.3. Procedure H 3 Let DSP3 be the problem that, according to the HDSP scheme, is derived from DSP by 3 replacing each cost c with the reduced cost c = c − i∈R ui − uσ () , ∈ R, where u = u1 + u2 and u1 and u2 are the dual solutions resulting from procedures H1 and H2 . Using procedure GENDUTY, compute the largest subset R of the duty set R so that max c3 min c3 , ∈R\R ∈R (29) R $c , where $c is a user-defined parameter. Consider the following linear program RSP obtained from SP by replacing the costs {c } with the reduced costs {c3 }, the set R with R and adding the artificial variable y to constraints (3) and to the objective function (2). Problem RSP is defined as follows: c3 x + Ui yi (30) (RSP) min z(RSP) = ∈R

subject to

i∈V

x + yi = 1,

i ∈ V ,

(31)

x bk−n ,

k ∈ D,

(32)

∈ R, i ∈ V ,

(33) (34)

∈Ri

∈Bk

x ∈ {0, 1}, yi 0,

where Ri = Ri ∩ R , i ∈ V , and Bk = Bk ∩ R , k = 1, . . . , m. Bianco, Mingozzi and Ricciardelli (1994) show that any dual feasible solution of 3 {Ui } of the artificial variables {yi } RSP is also a feasible solution of 3DSP if the costs satisfy inequalities i∈R Ui c , ∀ ∈ R\R . The values {Ui } can be set as Ui = max[c3 : ∈ Ri ]wi /Wimax , where Wimax corresponds to the maximum working time of any duty ∈ Ri , i ∈ V , which can be computed in polynomial time (see Bianco, Mingozzi and Ricciardelli (1994)). Any optimal solution (x∗ , y∗ ) of RSP of cost z∗ (RSP) such that x∗ is inte∗ a valid upper bound which is an optimal SP solution if ger and y ∗ = 0 provides 1 2 c x = z(DSP ) + z(DSP ) + z∗ (RSP). ∈R In case z∗ (RSP) > 0, the procedure can be repeated according to the following scheme: Step 1. Define u = u1 + u2 . Set u3 = 0, z(DSP3 ) = 0 and iter = 1. Step 2. Generate the subset R and the costs {Ui } as described above. Step 3. Find the optimal solution (x∗ , y∗ ) of RSP of cost z∗ (RSP) and the optimal dual variables u∗ .

190


1 2 ∗ Step 4. If x∗ is an optimal SP solution (i.e. ∈R c x = z(DSP ) + z(DSP ) + 3 ∗ ∗ ∗ z(DSP ) + z (RSP), x is integer and y = 0), then Stop; otherwise, update u3 = u3 + u∗ and z(DSP3 ) = z(DSP3 ) + z∗ (RSP). Step 5. Set iter = iter+1; if iter > Maxt3 or z∗ (RSP) = 0, then Stop (Maxt3 represents the maximum number of iterations and must be fixed a priori); otherwise, set u = u + u∗ and go to step 2. At the end of procedure H3 , the MD-CSP lower bound is given by the cost z (DSP) = z(DSP1 ) + z(DSP2 ) + z(DSP3 ) of the solution u = u1 + u2 + u3 of DSP.

6.

Procedure GENDUTY

In this section we describe a procedure, called GENDUTY, for computing the largest subset S of R which, for a given solution u of DSP and for given values of three userdefined parameters gap, $1 and $2 , satisfies the following conditions: (b)

c < gap, ∀ ∈ S, max c min c ,

(c)

|Si | $1 ,

(d)

|S| $2 ,

(a)

∈S

∈R\S

∀i ∈ V ,

(35)

where c = c − i∈R ui − uσ () , ∀ ∈ R, and Si = S ∩ Ri , ∀i ∈ V . GENDUTY iteratively appends to S the feasible path ∗ ∈ R\S of minimum reduced cost and terminates as soon as one of inequalities (a), (c) or (d) of conditions (35) is violated. The three parameters gap, $1 and $2 allow GENDUTY to generate the sets R and N used by procedure H2 , the set R used in procedure H3 and the set F required by the exact method described in section 4: • Generation of R at step 1 of H2 : define u = u1 and set gap = ∞, $1 = $a and $2 = ∞. • Generation of N at step 3 of H2 : define u = u1 + u¯ and set gap = 0, $1 = ∞ and $2 = $. • Generation of R at step 2 of H3 : define u = u1 + u2 + u3 and set gap = ∞ and $1 = $2 = $c . • Generation of F in the exact method of section 4: define u = u1 + u2 + u3 and set gap = z∗ (SP) − z (DSP) and $1 = $2 = $max . In the description of GENDUTY we will use the following additional definitions and notation. Let P = (σ (P ), i1 , i2 , . . . , ir ) be a path from depot σ (P ) to vertex ir ∈ V . We and the set of indicate by ϕ(P ) = ir and by S(P ) = {i1 , i2 , . . . , ir } the terminal vertex vertices visited by path P , respectively. Furthermore, we use W (P ) = i∈S(P )\{ir } wi


191

and E(P ) = tσ (P )i1 + (sir − si1 ) to represent the working time and the elapsed time of the path P before starting trip ir . Moreover, we assume that |S(P )| 1. Path P = (σ (P ), i1 , i2 , . . . , ir ) is called a feasible partial path if it satisfies both elapsed time and working time constraints (i.e. E(P ) ET and W (P ) WT). We denote by c (P ) the reduced cost of a path P with respect to a feasible DSP solution u . The value c (P ) corresponds to the cost of P in G when the arc cost cij is replaced by cij = cij − uj , (i, j ) ∈ A. We denote by LB(P ) = c (P ) + FB(P ) a lower bound to the reduced cost of any feasible duty which can be obtained expanding the feasible partial path P , where FB(P ) represents a lower bound to the completion of P . The lower bound FB(P ) can be computed using the following bounding functions h(k, i), f (q, k, i) and g(t, k, i), which are defined on graph G using arc costs {cij }. • Function h(k, i) allows us to consider the restriction that each duty must finish at the starting depot. Define h(k, i) to be the cost of the least cost path in G starting from i ∈ V and ending at depot vertex of k ∈ D. For each k ∈ D, the following dynamic programming recursion computes the values h(k, i), i ∈ V . Initialize h(k, k) = 0, then compute h(k, i) = min h(k, j ) + cij , i = n, n − 1, . . . , 1. j ∈i

• Function f (q, k, i) is used to consider both the duty working time and depot constraints. Let f (q, k, i) be the cost of the least cost path in G starting from i ∈ V , ending at depot vertex k ∈ D and such that the sum of the weights (i.e. working time) of the vertices traversed is less than or equal to q. For each k ∈ D, the values f (q, k, i), q = 1, . . . , WT, i ∈ V , can be computed by means of the following dynamic programming recursion. Initialize f (0, k, k) = 0 and f (q, k, k) = +∞, q = 1, . . . , WT; then compute

f (q, k, i) = min f (q − 1, k, i), min f (q − wi , k, j ) + cij , j ∈i

i = n, n − 1, . . . , 1 and q = wi , . . . , WT. • Function g(t, k, i) is used to consider both the duty elapsed time and depot constraints. Let g(t, k, i) be the cost of the least cost path in G starting from i ∈ V , ending at depot vertex k ∈ D and such that the elapsed time of the path is less than or equal to t. For each k ∈ D, the values g(t, k, i), t = 1, . . . , ET, i ∈ V , can be computed by means of the following dynamic programming recursion. if t = ei + tik − si , i ∈ V and t = 1, . . . , ET, c , Initialize g(t, k, i) = ik +∞, otherwise, then compute:

g(t, k, i) = min g(t − 1, k, i), min g(t − (sj − si ), k, j ) + cij , j ∈i \{k}

i = n, n − 1, . . . , 1, t = ei + tik − si + 1, . . . , ET.

192


FB(P ) can computed according to the constraints involved in the particular MD-CSP instance; we have the following cases: A. Depot constraints but no duty constraints (i.e. the MD-CSP corresponds to the MD-VSP). In this case we have FB(P ) = h σ (P ), ϕ(P ) . (36) B. Depot constraints with working and elapsed time constraints. We have FB(P ) = max f WT − W (P ), σ (P ), ϕ(P ) , g ET − E(P ), σ (P ), ϕ(P ) . (37) C. Depot constraints with either working time or elapsed time constraints. In case of working time constraints only, we have FB(P ) = f WT − W (P ), σ (P ), ϕ(P ) ; (38) while, in case of elapsed time constraints only, we have FB(P ) = g ET − E(P ), σ (P ), ϕ(P ) .

(39)

We indicate by P = (φ(P ), . . . , σ (P )) the path corresponding to the lower bound value FB(P ). For a given path P = (σ (P ), i1 , . . . , ih−1 , ϕ(P )), let R be the circuit passing through depot vertex σ (R) which is obtained by appending to P the path P obtained in computing FB(P ). Circuit R has cost c (R) = LB(P ) and might not satisfy all duty constraints. For this reason, the circuit R is called a partial feasible duty. GENDUTY is an iterative procedure, based on the method of Yen (1971) for finding the k-shortest path in a graph, which generates the sequence of the p-least cost partial feasible duties R 1 , R 2 , . . . , R p and extracts from this sequence those satisfying all duty constraints until the termination conditions required are reached. The procedure starts 1 2 mn ki by generating mn partial feasible duties R , R , . . . , R , where R is the least cost partial feasible duty passing through depot vertex n + k and trip i. This is obtained by appending the path P of value FP(P ) to the feasible partial path P = ((n + k), i). It is quite clear that the partial feasible duty of minimum cost among the mn partial feasible 1 2 mn duties R , R , . . . , R , is the least cost partial feasible duty R 1 . 1 2 mn The algorithm starts placing the mn partial feasible duties R , R , . . . , R into a temporary list called Temp. At each iteration k, the algorithm extracts from Temp the partial feasible duty of minimum cost, called R k , which is added to the set S in the case where R k satisfies all duty constraints. Then, the partial feasible duty R k = k k k (σ (R k ), i1 , i2 , . . . , ih , σ (R k )) is expanded by generating h deviations R 1 , R 2 , . . . , R h . k Deviation R r is the least cost partial feasible duty passing through depot σ (R k ) that cok = incides with R k from σ (R k ) up to vertex ir−1 following the same initial path Pr−1 k (σ (R ), i1 , i2 , . . . , ir−1 ) and then deviates to a vertex which is different from ir but it is also different from any of the vertices in the rth position of any other deviation (previk . ously generated) having the same initial path Pr−1


193

k

k For generating R r we proceed as follows. Let V (Pr−1 ) be the subset of vertices containing vertex ir and all other vertices in position r of all deviations having the same k k . The least cost deviation R r is generated by computing the lower bound initial path Pr−1 k ) as follows: LB(Pr−1 k k k LB Pr−1 ◦ (i) . (40) = c Pr−1 + min cir−1 i + FB Pr−1 k ) i∈ir−1 \V (Pr−1

k ◦ (i) to indicate the path obtained by appending vertex i In expression (40) we use Pr−1 k k k the path P to path Pr−1 . The partial feasible duty R r is obtained by appending to Pr−1 k

k

k

k ). All deviations R 1 , R 2 , . . . , R h given by expression (40) and setting c (P ) = LB(Pr−1 are then placed in the list T EMP.

Algorithm GENDUTY. 1

2

mn

Step 0. Place in T EMP the mn partial feasible duties R , R , . . . , R each one passing through a different depot vertex k ∈ D and a different trip i ∈ V as described above. Define S = ∅. Step 1. If T EMP = ∅ then S contains all duties of cost smaller than or equal to gap: Stop. Step 2. Let R ∗ ∈ T EMP be such that c (R ∗ ) = min[c (R) : R ∈ T EMP ]. If c (R ∗ ) > gap, then Stop, otherwise update T EMP = T EMP \{R ∗ }. If R ∗ satisfies all duty constraints, then update S = S ∪ {R ∗ } and if |Si | $1 , ∀i ∈ V , or |S| = $2 then Stop. Step 3. Let R ∗ = (σ (R ∗), i1 , i2 , . . . , ih , σ (R ∗)). For each r = 1, . . . , h execute step 4. ∗ be the initial path of R ∗ from depot vertex σ (R ∗ ) up to vertex ir−1 . Step 4. Let Pr−1 ∗ ∗ ) using expression (40) where V (Pr−1 ) is computed as deCompute LB(Pr−1 ∗ ∗ scribed above. If LB(Pr−1 ) < gap, then form the partial feasible duty R r by ∗ ∗ ∗ with path P given by expression (40), define c (R r ) = LB(Pr−1 ) joining Pr−1 ∗ and add R r to T EMP.

Notice that procedure GENDUTY can be adapted to deal with additional duty constraints such as minimum and maximum rest time, minimum and maximum driving time without rest, depot-trip objections, etc. This requires a change in step 2 of the algorithm in order to declare unfeasible any circuit R ∗ not satisfying the additional constraints. 7.

Computational results

In this section we present computational results in order to evaluate the performance of the new exact method, hereafter called BMR, on MD-VSP and CSP test problems from

194


the literature with respect to other published exact methods. Furthermore, we present computational results on a set of MD-CSP test problems. The algorithm has been implemented in FORTRAN 77 using Digital Visual Fortran 6.0 and run on a Pentium II 400 MHz using CPLEX 6.5 as the linear programming solver in procedure H2 and as the integer programming solver in the exact procedure described in section 4.1. The test problems we used in our computational experiments are as follows. MD-VSP test problems.

These problems are of two types:

• random MD-VSP instances originally proposed by Carpaneto et al. (1989); • real-world MD-VSP instances recently proposed by Fischetti et al. (2001). All these instances are available on the Web page http://www.or.deis. unibo.it/research_pages/ORinstances/MD-VSP.html. Basic CSP test problems.

Two classes of problems have been considered:

• Class A proposed by Beasley and Cao (1996) and available in the OR library at http://mscmga.ms.ic.ac.uk/jeb/orlib/cspinfo.html. • Class B proposed by Mingozzi et al. (1999). These instances are obtained from those of class A by increasing the elapsed time limit in order to almost double the average number of trips per duty. MD-CSP test problems. To our knowledge no test problems are available in the literature for the MD-CSP, therefore, we generated a set of 15 instances which correspond to the real world MD-VSP instances proposed by Fischetti et al. (2001) imposing on each duty both working time and elapsed time constraints with WT = 600 and ET = 800, respectively. The values of WT and ET were chosen to make infeasible 50% of the duties of the optimal solutions of the corresponding unconstrained MD-VSP instances. The computational results have been obtained using the following parameters in bounding procedures H2 and H3 and in the exact method described in section 4.1: (i) For MD-VSP and CSP instances, we used: $a = 2000, $b = 5000, $ = 25, Maxt2 = 2500 and α = 2.5 in H2 ; $c = max[2000,10n] and Maxt3 = 4 in H3 ; $max = max[2000,10n], itermax = 1 and gapmax = 0 in the exact method. (ii) For MD-CSP instances, we used: $a = 2000, $b = 10000, $ = 50, Maxt2 = 4000 and α = 1.5 in H2 ; $c = max[5000,20n] and Maxt3 = 4 in H3 ; $max = max[4000,10n], itermax = 1 and gapmax = 0 in the exact method. We note that one iteration was sufficient to the exact method to prove the optimality of the solution found for all MD-VSP, CSP and MD-CSP instances. The computational results are shown in five tables. Table 1 reports the results on random MD-VSP of the following methods:


195

Table 1 Random MD-VSP instances. FLMT(MD-VSP) t.sol(1)

New method BMR %G1

T1 (2)

%G2

T2 (2)

%G3

T3 (2)

t.lb(2)

t.sol(2)

m

n

%Gap

t.lb(1)

2

100 200 300 400 500

0.000 0.008 0.008 0.005 0.004

0.60 13.34 46.56 225.28 712.47

0.60 23.30 84.16 297.94 1160.73

1.001 0.692 0.616 0.708 0.605

0.00 0.00 0.00 0.00 0.00

0.146 0.106 0.061 0.058 0.045

0.23 0.78 1.88 4.39 8.30

0.000 0.008 0.008 0.005 0.003

0.39 2.87 6.90 11.24 19.96

0.62 3.65 8.78 15.63 28.26

0.62 4.58 10.81 18.60 32.63

3

100 200 300 400

0.010 0.021 0.012 0.016

2.30 39.80 213.68 1187.70

2.80 72.74 339.84 3177.63

1.735 1.327 1.137 0.950

0.00 0.00 0.00 0.00

0.360 0.159 0.119 0.077

0.29 0.83 2.12 4.75

0.011 0.020 0.012 0.016

0.51 2.88 8.12 13.86

0.80 3.71 10.24 18.61

1.04 5.26 13.87 30.27

5

100 200 300

0.084 0.045 0.028

9.31 189.98 1562.15

22.49 341.43 3130.49

2.866 2.323 1.974

0.00 0.00 0.00

0.339 0.223 0.176

0.28 1.01 2.87

0.086 0.044 0.029

0.68 4.12 11.19

0.96 5.13 14.06

1.87 7.30 24.87

(1) Seconds on a Digital Alpha 533 MHz. (2) Seconds on a Pentium II 400 MHz.

• BMR: the new exact algorithm proposed in this paper. • FLMT(MD-VSP): the branch and cut algorithm of Fischetti et al. (2001) specialised for the MD-VSP. We do not report in tables 1 and 2 the results of the exact method proposed by Bianco, Mingozzi and Ricciardelli (1994) for the following reasons: (i) the instances considered by Bianco, Mingozzi and Ricciardelli are not exactly the same used in table 1 and the average values are computed over 4 problems, (ii) we tested the exact method of Bianco, Mingozzi and Ricciardelli on both types of MD-VSP instances and in our computational experience our new exact algorithm BMR is on average five times faster. However, the exact method of Bianco, Mingozzi and Ricciardelli seems to be considerably faster than FLMT(MD-VSP). Each row of table 1 reports the average values over 10 problems for each pair (n, m) of trips and depots. In particular, for each of these pairs and for each method, we report the computing time to solve the problem to optimality (t.sol), the time spent HDSP to compute the lower bound (t.lb) and for method FLMT(MD-VSP) the percentage gap (%Gap) between the optimal solution value and the lower bound. Moreover, for method BMR we report the percentage gaps %G1 , %G2 and %G3 between the lower bounds and the optimal solution cost and the computing times T1 , T2 and T3 resulting from procedures H1 , H2 and H3 , respectively. Table 2 gives the results on a set of 15 real-life MD-VSP instances of methods BMR and FLMT(MD-VSP). Each row of table 2 refers to a single instance which is identified by (n, m) with n ∈ {184, 285, 325, 463, 580} and m ∈ {2, 3, 5}. Table 2 reports the same information as table 1. Tables 3 and 4 report the results on classes A and B of basic CSP problems, respectively. These tables show the comparison of the following exact methods:

196


Table 2 Real-world MD-VSP instances. FLMT(MD-VSP)

New method BMR

%Gap

t.lb(1)

t.sol(1)

%G1 T1 (2) %G2

2 184 0.000 3 184 0.000 5 184 0.043

6.0 28.2 135.6

6.0 28.2 209.3

0.247 1.112 1.788

0.00 0.061 0.00 0.122 0.00 0.212

2 285 0.000 3 285 0.013 5 285 0.016

38.4 153.1 536.3

38.4 258.5 1135.7

2 352 0.000 3 352 0.000 5 352 0.012

77.9 243.3 1189.8

2 463 0.000 3 463 0.002 5 463 0.003

574.3 1179.4 5719.9

m

n

2 580 0.000 3 580 0.000 5 580 0.021

%G3

T3 (2)

t.lb(2)

t.sol(2)

4.58 0.000 4.66 0.000 5.03 0.037

1.13 0.60 1.43

5.71 5.26 6.46

5.71 5.26 8.49

0.186 0.599 0.954

0.00 0.025 11.57 0.000 3.45 0.00 0.042 12.62 0.013 10.36 0.00 0.039 13.29 0.016 4.43

15.02 22.98 17.72

16.07 35.23 29.97

77.9 243.4 2138.8

0.108 0.319 0.688

0.00 0.003 12.32 0.000 0.00 0.003 21.78 0.000 0.00 0.014 23.88 0.012

18.66 28.39 30.79

18.66 30.12 39.66

920.9 1974.9 8874.9

0.042 0.126 0.269

0.00 0.002 35.07 0.000 7.02 0.00 0.002 57.46 0.001 13.82 0.00 0.007 57.38 0.003 16.60

924.6 924.8 0.020 1139.9 1140.0 0.027 10000.0(3) 10000.0(3) 0.121

T2 (2)

6.34 6.61 6.91

42.09 56.34 71.28 74.58 73.98 106.28

0.00 0.000 57.56 0.000 4.52 62.08 80.96 0.00 0.000 90.35 0.000 8.64 98.99 102.75 0.00 0.001 91.87 0.000 13.80 105.67 129.65

(1) Seconds on a Digital Alpha 533 MHz. (2) Seconds on a Pentium II 400 MHz. (3) Time limit: FLMT(MD-VSP) terminates without finding an optimal solution.

Table 3 Class A instances of the basic CSP. BC n

b1

%G

t.lb(0)

50

31 30 29 28 27

0.00 0.00