In the classical vehicle-routing problem (VRP) the objective is to service some geographically scattered customers

TRANSPORTATION SCIENCE Vol. 38, No. 2, May 2004, pp. 197 209 issn 0041-1655 eissn 1526-5447 04 3802 0197 informs doi 10.1287/trsc.1030.0053 2004 INFORMS Scheduling Transportation of Live Animals to Avoid the Spread of Diseases Mikkel Sigurd, David Pisinger, Michael Sig Department of Computer Science, University of Copenhagen, Universitetsparken 1, DK-2100 Copenhagen, Denmark {sigurd@diku.dk, pisinger@diku.dk, michael@sig-post.dk} In the classical vehicle-routing problem (VRP) the objective is to service some geographically scattered customers with a given number of vehicles at the minimal cost. In the present paper, we consider a variant of the VRP where the vehicles should deliver some goods between groups of customers. The customers have an associated time window, a precedence number, and a quantity. Each vehicle should visit the customers within their time windows, in nondecreasing order of precedence respecting the capacity of the vehicle. The problem will be denoted the pickup-and-delivery problem with time windows and precedence constraints (PDPTWP). The PDPTWP has applications in the transportation of live animals where veterinary rules demand that the livestocks are visited in a given sequence in order not to spread specific diseases. We propose a tighter formulation of the PDPTWP based on Dantzig-Wolfe decomposition. The formulation splits the problem into a master problem, which is a kind of set-covering problem, and a subproblem that generates legal routes for a single vehicle. The LP-relaxation of the decomposed problem is solved through delayed column generation. Computational experiments show that the obtained bounds are less than 0.24% from optimum for the considered problems. As solving the pricing problems takes up the majority of the solution time, a reformulation of the problem is proposed that makes use of the precedence constraints. By merging customers having the same precedence number into super nodes, the pricing problem may be reformulated as a shortest-path problem defined on an acyclic layered graph. This makes it possible to solve the pricing problem in pseudopolynomial time through dynamic programming. The paper concludes with a comprehensive computational study involving real-life instances from the transportation of live pigs. It is demonstrated that instances with up to 580 nodes can be solved to optimality. Key words: freight transportation; precedence constraints; column generation; layered graph; dynamic programming History: Received: August 2001; revisions received: June 2002, November 2002; accepted: November 2002. Introduction The Specific Pathogene Free (SPF) Association in Vejen, Denmark (www.spf.dk) is responsible for planning transportation of live pigs in Denmark according to a number of veterinary restrictions. To avoid the spread of diseases, the transportation of animals must be carried out such that the health of each animal is no better than that of animals transported earlier in the day. Each livestock has an associated health level, with smaller health levels corresponding to the healthiest livestock. Therefore, the vehicles must visit the livestock according to a nondecreasing order of the health levels. At the end of each day, the vehicle is cleaned, and thus it is disease-free the following day. The SPF company schedules approximately 300 trips every day, using around 90 vehicles. This problem may be seen as a vehicle-routing problem with time windows (VRPTW) because we have m vehicles to service n geographically scattered customers. The vehicles start and end at the homes of the drivers; thus, there is a unique depot associated with each vehicle. It is assumed that the vehicles leave the depot with no cargo and arrive at the same depot without any cargo. Each vehicle has an associated capacity, which may not be exceeded at any given time. Each customer has an associated time window in which he should be visited. If a vehicle arrives before the customer s time window, the vehicle must wait until the time window begins. The objective of the problem is to satisfy a number of deliveries at the lowest possible transportation cost. Each delivery consists of a seller (of live animals) and a buyer. The seller/buyer pairs are given in advance; thus, the objective of the problem does not include pairing the sellers with buyers. Immediately after having picked up the animals at a seller, the vehicle should proceed to the corresponding buyer. Situations may, however, occur where a delivery consists of more than one seller to the same buyer. In this case, the vehicle can pick up the cargo from all the sellers before proceeding to the buyer. A compound delivery may also be carried out as a number of 197

198 Transportation Science 38(2), pp. 197 209, 2004 INFORMS individual deliveries. Due to veterinary constraints, a compound delivery consisting of one seller to several buyers must always be treated as a number of individual deliveries, because the risk of spreading diseases is considered greater when transporting animals between buyers. Because of these constraints on compound deliveries, the problem we consider is actually a pickup-and-delivery problem with time windows (PDPTW), whereas the problem would be a VRPTW without these deliveries. The last restriction relates to the health level of each livestock where the level indicates which diseases are present. A health level of zero indicates that the livestock is disease-free. In order not to spread diseases, a vehicle should visit the customers according to a nondecreasing order of the health levels. This restriction imposes a number of precedence constraints on the problem, which then becomes a pickup-and-delivery problem with time windows and precedence constraints (PDPTWP). Due to veterinary constraints, it may be assumed that the health level of the buyer is not smaller than the health level of the corresponding seller. A vehicle may only service a delivery if the seller of the present delivery has a health level not smaller than the health level of the previous buyer. To our knowledge, the PDPTWP has not previously been studied in the literature. Nevertheless, due to its similarity to the VRPTW and the PDPTW, several techniques from the latter problems may be used for its solution. The VRPTW and the PDPTW have been studied in the last two decades, and many techniques have been applied for their solution. Kohl (1995) gives an overview of exact solution methods for the VRPTW. As the problem is NP-hard, all solution methods are based on branch-and-bound techniques using some kind of relaxation for deriving the lower bounds. A number of decomposition techniques have been proposed, including Lagrangian relaxation, variable splitting, and Dantzig-Wolfe decomposition. Cutting-plane techniques are also frequently used to tighten the formulation. Dumas et al. (1991) solve a PDPTW through branch and bound and column generation. They describe how the associated graph can be reduced by some simple rules based on the time windows and capacity constraints. Moreover, a dynamic algorithm for generating routes is presented. Other algorithms for route generation are presented by Sol and Savelsbergh (1994), who describe two heuristic methods. The first heuristic is an insertion algorithm that greedily inserts a customer into the route as long as the associated reduced cost is decreased. The second heuristic aims at improving existing columns. Sol and Savelsbergh also propose two branching strategies for obtaining an integer solution. Ideally, the branching strategy should keep the search tree balanced so that the solution progresses equally on both subproblems. The first strategy divides the solution space according to whether a customer is serviced by a particular vehicle. The second strategy considers whether or not two customers are serviced by the same vehicle. In Savelsbergh and Sol (1995), the authors give an overview of the pickup-and-delivery problem (PDP) in a general formulation. Several variants of the PDP are discussed, and a number of exact and heuristic solution methods are presented. Recently, Desaulniers et al. (2002) surveyed many variants and solution methods of the PDP. Barnhart et al. (1998) discuss several aspects of using column generation with a branch-and-bound algorithm, including the solution of the pricing problem, branching strategies, and derivation of additional constraints. Kallehauge (2000) recently proposed the relaxation of the assignment constraints of the VRPTW in a Lagrangian way, thus obtaining a number of independent shortest-path problems. Although the bound from Lagrangian relaxation is not tighter than the bound from column generation, some computational effort may be saved as we get a valid lower bound for any choice of nonnegative Lagrangian multipliers. In this way, Kallehauge (2000) was able to find optimal solutions for some instances from the Solomon test library (Solomon 1987) with up to 200 customers. The multidepot vehicle-scheduling problem with time windows has been studied in Desaulniers et al. (1988). The authors solve the problem with a branchand-price algorithm and report optimal solutions of problems with up to 300 customers. The authors use the labeling algorithm by Desrochers and Soumis (1988) to solve the pricing problem. We use a similar algorithm. In the rest of this section, we formulate the PDPTWP as an ILP model. The problem is defined on an oriented graph = E, where the node set consists of customers and depots. Each customer is associated with a quantity q i. A positive value of q i means that the vehicle should pick up a load of q i, and thus the corresponding customer denotes a seller. A customer with a negative value of q i is denoted a buyer. To each customer, i is assigned a time window a i b i and a precedence level p i (the health level). A vehicle should visit the customers within their time window and according to nondecreasing precedence levels. The customers should be serviced by a set of vehicles. Each vehicle k has an associated capacity Q k, a start depot D + k, and an end depot D k. In the following, we will denote the set of start depots + = k D + k and the set of end depots = k D k. Every depot d = + has an associated time window a d b d within which it is accessible. It is

Transportation Science 38(2), pp. 197 209, 2004 INFORMS 199 implicitly assumed that the opening time of a depot is within a working day, and hence all routes generated will be within 24 hours. In the problem instances considered in this paper, the start and end depots are the homes of the drivers. The cost of traveling from node i to node j is denoted c ij, and the corresponding travel time is t ij > 0. A typical choice of the cost function is the actual expenses (based on time and distance) for driving from i to j. If no edge exists between two nodes i and j, the corresponding cost c ij and time t ij are set to infinity. If the number of vehicles used should be minimized, one may add a large constant to the cost of every edge leading from the start depot + k to a customer. To ensure that a delivery goes directly from seller i to the corresponding buyer j, we delete all edges e ik where k j and all edges e kj where k i. In the case where two or more sellers deliver to the same buyer, we maintain the edges between the sellers. Three types of decision variables appear in the model. The binary variable x ijk for i j, k is 1 iff vehicle k is driving from node i to node j. For a given vehicle k, s ik for i, k denotes the time of arrival at node i (which can be a customer or a depot). Moreover, y ik for i, k is the used capacity of vehicle k when arriving at node i. This leads to the following formulation: minimize subject to k j c ij x ijk k i j (1a) x ijk = 1 i (1b) x D + k jk = 1 k (1c) j x id k k = 1 k (1d) i x ihk x hjk = 0 h k (1e) i j y D + k k = y D k k = 0 k (1f) y jk Q k j k (1g) y ik + q i K 1 x ijk y jk s ik + t ij K 1 x ijk s jk i j k i j k (1h) (1i) a i s ik b i i k (1j) p i K 1 x ijk p j i j k (1k) y ik 0 y ik i k (1l) s ik 0 s ik i k (1m) x ijk 0 1 i j k (1n) Constraints (1b) ensure that each customer is visited exactly once. Constraints (1c) (1d) ensure that each vehicle departs from its start depot and arrives at its end depot. Constraints (1e) ensure that if a vehicle arrives at a node, then it must also depart from the node. Because the arrival times s ik of a given vehicle k are strictly increasing, no subtours will occur in the solution, and thus constraints (1c) (1e) guarantee that each vehicle follows a consecutive path from its start depot to its end depot. The capacity constraints are ensured by constraints (1f) (1h). Constraints (1f) ensure that each vehicle k is empty upon departure from its start depot D + k and upon arrival at its end depot D k. The next constraints (1g) ensure that the load does not exceed the capacity Q k at any time for vehicle k. Constraints (1h) and (1i) say that if vehicle k drives from node i to node j (i.e., x ijk = 1), then the used capacity at node j is y jk y ik + q i and the arrival time at node j is s jk s ik + t ij. Finally, the constraints on the time windows are ensured by inequalities (1j), and inequalities (1k) ensure that the nodes are visited according to the precedence levels. The constant K is a sufficiently large number that is used to model conditional constraints. The model can be seen as an edge formulation of the problem, because the decision variables x ijk are connected to the use of a single edge. The edge formulation of the problem has O n 2 m constraints and O n 2 m variables, where n = and m =. As binary variables are used to express conditional constraints in Equations (1h) (1k), an optimal solution to the LP-relaxation may be structurally far from an integer optimal solution, and hence the corresponding lower bound will also be weak. The precedence constraints may also be handled by deleting all edges from buyers to sellers where the edges violate the precedence constraints. With this preprocessing of the graph, the PDPTWP becomes an ordinary PDPTW. If we did not allow the compound deliveries, pairs of seller/buyers could be merged into a single node, thus reducing the problem to an ordinary VRPTW. Notice also that the capacity constraints in this case would be trivial to check, as we could simply remove all pairs of seller/buyer that exceed the capacity q k for each vehicle k. To improve performance, some obsolete edges may be removed from the graph. First, all edges entering a start depot + and all edges leaving an end depot can be deleted. Edges from a start depot + leading to a buyer may also be removed, and a similar observation holds for edges going from a seller to an end depot. Finally, we may remove all edges that cannot be part of any legal path because of time and capacity constraints. For each edge e, this is checked

200 Transportation Science 38(2), pp. 197 209, 2004 INFORMS by first generating a minimal path containing e and then checking whether this path is legal. For an edge e between a start depot D + and a seller s with corresponding buyer b, the path D + s b D is considered. If this path is illegal, e cannot be part of any legal path and can thus be removed from the graph. Edges between buyers and end depots are checked in a similar fashion. For edges that do not start or end in a depot, i.e., edges of the form seller buyer, seller seller, and buyer seller, a minimal path for each depot has to be checked. If all paths are illegal, the edge can be removed from the graph. If an edge between a seller and the corresponding buyer is removed, this demand cannot be served, and we may conclude that no feasible solution exists. Although the considered PDPTWP problem can be transformed into an ordinary PDPTW (and even a VRPTW if compound deliveries are not allowed) by eliminating the precedence constraints, we will exploit the precedence constraints in a constructive way in our solution. In 1, we introduce a different formulation of the PDPTWP based on Dantzig-Wolfe decomposition, where the corresponding LP-relaxation provides a tighter bound than that provided by the edge formulation. This formulation will be denoted the path formulation. As the path formulation may contain an exponential number of variables, we use delayed column generation to solve its LP-relaxation. Sections 2 and 3 present three algorithms for solving the pricing problem associated with the column generation. Due to the precedence constraints in the PDPTWP, the considered graph can be transformed into a layered network by combining orders at the same precedence level into super nodes; this approach is described in 3. As the transformed graph is loop-free, we may solve the pricing problem in pseudopolynomial time through dynamic programming. An exact branch-and-bound algorithm is finally developed in 4, which applies bounds from the LP-relaxation of the path formulation. Numerous computational experiments using real-life data are described in 5. The largest data set solved to optimality has more than 580 nodes and 41 000 edges, which is significantly larger than similar results for the VRP. Section 6 contains the conclusion. 1. Dantzig-Wolfe Decomposition Geometrically speaking, Dantzig-Wolfe decomposition attempts to express the solution space as a convex combination of subsolutions to a subset of the constraints. Let be the set of legal paths in the problem. A path is legal if it begins in the depot associated with a given vehicle, visits a number of customers within their time windows, respects the precedence and capacity rules, and returns back to the depot of the vehicle. For a single path p, let c p be the associated cost, and let i p = 1 iff customer i is contained in the path. Using the binary variable xp k to indicate whether path p for vehicle k is selected in the solution, we get the following path formulation: minimize p c p x k p (2a) subject to x k p i p 1 i (2b) p x k p p x k p 1 k (2c) 0 1 p (2d) The model will be denoted the master problem or MP for a given set of legal paths. Constraints (2b) ensure that each customer is visited, and constraints (2c) ensure that no vehicle is used more than once. The new formulation has the advantage that some complicated constraints may be checked as part of the generation of legal paths, resulting in a simpler master problem as compared to formulation (1). Moreover, the new formulation leads to tighter lower bounds by LP-relaxation because every LP-solution to formulation (2) corresponds to an LP-solution to formulation (1), while the opposite is not generally the case. Nevertheless, the path formulation may become very large, because the number of legal paths can be exponential in the input size. To get around this problem, we use delayed column generation to solve the LPrelaxation of formulation (2). In the delayed column generation we consider a restricted master problem defined on a subset of paths. Let i be the dual variables associated with constraints (2b) and k the dual variables associated with constraints (2c) when solving MP to LPoptimality. The reduced cost of a path p corresponding to vehicle k is given by c p k = c p i i p i k (3) where i p are defined as above. To extend the current set of paths according to the Dantzig rule of the simplex algorithm, we must find the path p with the smallest reduced cost c p k. This problem amounts to finding a shortest path between the start depot D + k and the end depot D k of a vehicle k, where the cost c ij associated with each edge i j equals the original edge cost c ij minus the dual variable j associated with node j. The chosen path must be legal; i.e., it must satisfy the constraints on the capacity, time windows, and precedences. With these additional constraints, the shortest-path problem becomes NP-hard.

Transportation Science 38(2), pp. 197 209, 2004 INFORMS 201 To ensure feasibility of MP, we insert a dummy path for each customer i visiting just i and using no vehicle. We assign a very large cost to the dummy paths to make sure that they are not part of an optimal feasible solution. In each of the following iterations we solve the restricted master problem MP to LP-optimality obtaining the dual variables. These are then used to find a new legal path, p, with the smallest reduced cost (3). We add this path p to and repeat the process until a legal path with negative reduced costs cannot be found. In this case, we get from Farkas Lemma (Chvátal 1983) that an optimal LP-solution to MP has been found. 2. Solving the Pricing Problem The pricing problem is the problem of finding a legal path p with smallest reduced cost c p k corresponding to the current restricted master problem MP. This problem must be solved in every iteration of the column generation. Due to the constraints on the legal paths, the problem is NP-hard, which means that solving the pricing problem for each column is time consuming. To get around this problem, we used the following strategy: Instead of finding the path with the smallest reduced cost, we simply attempt to find some path with a negative reduced cost. In many cases this can be done using a fast heuristic algorithm. Only if we are not able to find any paths with negative reduced cost by using the heuristic do we solve the pricing problem using an exact algorithm. Frequently, our heuristic and exact algorithms find several paths with negative reduced cost. Instead of adding just one path, we add up to l paths. This greatly reduces the number of times we need to solve the pricing problem. However, solving the LP-relaxation of a larger restricted master problem MP is more time consuming. We have implemented a heuristic and two exact pricing algorithms, which are described in 2.1, 2.2, and 3. 2.1. Construction Algorithm The construction algorithm is a heuristic proposed by Sol and Savelsbergh (1994). The algorithm starts out with an empty path and performs a number of greedy iterations. In each iteration, the customer yielding the largest decrease of the reduced cost is added to the path at the best location on the path. The running time of the algorithm is O nh 2, where n is the number of customers, and h is an upper bound (independent of n) on the number of customers visited in a single path. An upper limit h on the number of customers visited per day is reasonable in our context, because the loading and unloading of live animals is so time consuming that a vehicle can visit only a few customers within a day. Based on our data instances, we may assume h = 5. 2.2. State Algorithm The state algorithm was proposed by Dumas et al. (1991) for the PDPTW. This algorithm is a dynamic programming algorithm and was designed to solve a relaxed pricing problem in which the paths are not required to be loopless. We have adapted the algorithm to solve the elementary constrained shortest-path problem (see Desrosiers et al. 1995) by modifying the dominance criterion as described below. By allowing only elementary paths in the master problem, we improve the lower bound obtained by the LP-relaxation of the master problem. The state algorithm is based on the idea of Dijkstra s shortest-path algorithm; however, another dominance criterion is used because the constraints on the legal paths make Dijkstra s dominance criterion invalid. The state algorithm maintains a set of states S j M T R, each corresponding to a subpath from the start depot to node j, where M is the set of nodes previously visited on the path, T is the arrival time of the path to node j, and R is the reduced cost of the path. The set of states is initially just one state corresponding to the empty path starting in a start depot. In each iteration a state S j M T R is selected, and the corresponding route is extended to each of the neighbors of j, thus creating a number of new states that are added to the set of states. Only states corresponding to legal paths are added. A path is complete when it includes the end depot. At this point it can be added if the corresponding reduced cost c p k is negative. If we have two states S 1 j M 1 T 1 R 1 and S 2 j M 2, T 2 R 2 corresponding to the same node j, and if T 1 T 2, R 1 R 2, M 1 = M 2, we say that state S 1 dominates S 2. This is the case if the paths corresponding to the two states have visited the same customers in a different order, and if the path corresponding to S 1 has visited the customers in a way that results in a faster path with lower reduced cost than the path corresponding to S 2.IfS 1 dominates S 2, all paths that are extended from state S 2 will not be better than the similar paths extended from S 1, and thus we can delete S 2. In this way, we prune unpromising paths early and only spend time extending good paths. Proposition 1 shows that this dominance criterion is valid. Proposition 1 (Dominance). For two states S 1 j, M 1 T 1 R 1 and S 2 j M 2 T 2 R 2 corresponding to the same node j, the dominance criterion T 1 T 2 R 1 R 2, M 1 = M 2 is valid for the PDPTWP. Proof. Assume we have two states S 1 j M 1 T 1 R 1 and S 2 j M 2 T 2 R 2 in a node j and that T 1 T 2, R 1 R 2, M 1 = M 2. Let r 1 be the path corresponding to state

202 Transportation Science 38(2), pp. 197 209, 2004 INFORMS Table 1 Size of Equivalence Classes for Orders Where the Seller and Buyer Have the Same Precedence Number Size of equivalence class 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 Number of occurrences 3 2 1 1 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 Note. As an example,there is one equivalence class containing 22 orders. The observed results are for the SPF problem,monday,with 258 requests. S 1 and r 2 be the path corresponding to state S 2. Let i be a neighbor of j so that r 2 can be extended to i legally; i.e., i can be visited within its time window, i has higher or equal precedence level than j, and the capacity constraints are not violated. By extending r 2 to i we obtain a new state S2 i i M 2 i T 2 +t ji R 2 +r ji for the route r2 i obtained by extending r 2 to i. Obviously, r 1 can also be extended to i, and we thereby obtain another route r1 i and a new state S1 i i M 1 i T 1 + t ji R 1 + r ji corresponding to r1 i. Because T 1 + t ji T 2 + t ji, R 1 + r ji R 2 + r ji, and M 1 i = M 2 i, state S1 i dominates Si 2. This means that any extension of S 2 will always be dominated by the similar extension of S 1, and thus we can avoid further extending the S 2. In the worst case, the state algorithm will not be able to find any dominance, which means that all possible states will have to be considered. The state algorithm will then be similar to a complete search of the graph, which has complexity O n h if we assume that the length of any legal path is less than a constant h. Dumas et al. (1991) used a relaxed dominance criterion stating that S 1 j M 1 T 1 R 1 dominates S 2 j M 2 T 2 R 2 if T 1 T 2, R 1 R 2, and U M 1 U M 2, where U M is the set of undelivered deliveries on the vehicle at a given state. Using this dominance criterion, Dumas et al. solve the nonelementary constrained shortest-path problem. This dominance criterion is less restrictive than the criterion proposed here; thus, it will find more dominance, thereby reducing the number of states the state algorithm needs to consider. However, the dominance criterion is not valid for the elementary constrained shortest-path problem. Therefore, the lower bounds obtained by the linear relaxation of MP are weaker because the optimal LP solutions may contain nonelementary routes. In the next section, we show how we can use a transformed graph to obtain an even less restrictive dominance criterion that is valid for the elementary constrained shortest-path problem. 3. Layered Network The graph may be transformed to a layered network, where each layer consists of all customers with the same precedence level. All legal routes will then visit customers from layers in nondecreasing order of precedence level. In this way, we obtain an ordering of the requests. We will use this ordering to develop a faster dynamic programming algorithm for solving the elementary constrained shortest-path problem. However, we are not able to order the requests that start and end at customers on the same precedence level, as these requests may be served in any order. Fortunately, an analysis of the problem data shows that the number of requests where the precedence levels of both the buyer and the seller are equivalent is fairly small (see Table 1). In our case, the largest equivalence class is of size E max = 22. This means that we can construct all legal subroutes consisting of requests on the same precedence level for every precedence level. If we think of a subroute as a single super request, we obtain an ordering of the requests, as we do not allow a legal route to consist of more than one subroute for each precedence level. The transformation of the original graph representation to the layered graph representation is described in more detail below. The nice structure of the obtained layered graph enables us to apply a fast, simple dynamic programming pricing algorithm. This algorithm is described in more detail in 3.1. The transformation to a layered network is performed as follows: Construct equivalence classes C i for orders where the seller and buyer have the same precedence number i. Looking at one equivalence class at a time, construct all legal sequences of orders with respect to the time windows and capacity constraints present. Create a super node in the layered graph for each legal sequence of orders. Because we know that at most h orders may be carried out on one day by a vehicle, this means that at most E h max such sequences are considered for a single precedence class. With h = 5 and E max = 22, we get at most 5 million sequences at the worst level, although practical experience shows that this is a pessimistic bound. We call these nodes in the layered graph super nodes because they represent a path in the original graph. Normally, the number of legal paths visiting nodes in one precedence level will be much smaller due to time windows, travel times, and capacity constraints. The travel time and the driving distance between the individual orders of a super node will be added to the outgoing edge of the super node. If there are no time windows in the orders, then the new super node will also have no time windows. If one or more orders have time windows, then a time window for the super node is constructed according to the time windows

Transportation Science 38(2), pp. 197 209, 2004 INFORMS 203 and travel times of the implied orders. This is done by scanning the customers on the path represented by the super node to obtain the most restrictive start time and end time. Example 1. We are given a super node representing the path [] [12:00, 13:00] [] [10:00, 14:00] 90 min. 60 min. 45 min. with four customers, where the second and fourth customers have time windows [12:00, 13:00] and [10:00, 14:00], respectively, and the first and third do not have any time window constraints. The travel times are indicated below the edges. We construct the time window of the super node as follows. Initially, the time window for the super node is [00:00, 24:00]. The first customer has no time window, so the time window of the super node is not changed. The second customer has time window [12:00, 13:00]. Because we are 90 minutes into the path, this means that the super node cannot be visited before 10:30 (otherwise we would arrive too early for the second customer) or after 11:30 (otherwise we would arrive too late for the second customer). The time window of the super node is thus reduced to [10:30, 11:30]. The third customer has no time window and therefore does not change the time window of the super node. The fourth customer has time window [10:00, 14:00]. Because we are 195 minutes into the path, this means that we must enter the super node between 6:45 and 10:45. However, because we also require the super node be visited between 10:30 and 11:30, the time window of the super node becomes [10:30, 10:45]. The travel time corresponding to all edges leading from the super node is increased by 195 minutes. The following dominance criterion allows us to eliminate some of the super nodes on the same precedence level: Proposition 2 (Super Node Dominance). A super node A representing a legal path p A dominates a super node B representing a legal path p B iff p A and p B serve the same requests, p A starts and ends in the same node as p B, the travel time and the cost of p A are smaller or equal to the travel time and cost of p B, and if the time window of p A starts before and ends after the time window of p B. To represent orders between a seller and a buyer on different precedence levels in the layered graph, we create a super node for each such order with a path consisting of only that single order. To allow for compound deliveries in the layered graph, we create a super node in the layered graph for every legal compound delivery. The super nodes of different layers in the layered graph are not directly connected by edges, because the number of super nodes may be exponentially large in h. Thus, a huge number of edges would be introduced in the graph. Instead, we create a representative node in the layered graph for each seller and buyer of the original graph. We connect the super nodes to the representative node of the first seller on the super-node path and to the representative node of the last buyer of the super-node path. The representative nodes are connected to each other as in the original graph. Super nodes for paths starting and ending on the same precedence level are connected to special equal precedence representative buyer and seller nodes. These equal precedence representative nodes are not connected to other equal precedence representative nodes on the same precedence level, but are connected to representative nodes on other precedence levels as in the original graph. This way, we eliminate loops containing super nodes on the same precedence level in the layered graph. Finally, for each start and end depot of the original graph, we create a corresponding start and end depot in the layered graph. An example of the transformation from the original graph layout to the layered graph layout is shown in Figure 1. Following the above description, we obtain a layered network with the following attractive properties: The graph is layered, and thus loop-free. The precedence constraints are accounted for in the new graph, because edges only exist between orders that respect the precedence constraint. All nondominated legal paths of the original graph layout can be represented by exactly one path in the layered graph. The edges leaving super nodes have an associated cost and travel time corresponding to the subpath of the super node. When reduced prices are introduced, the costs may be negative. The nodes have time windows corresponding to the time windows on the subpath represented. Taking advantage of the nice structure of the layered graph, the pricing problem becomes a multidepot shortest-path problem with time windows (MDVSPPTW), which is still NP-hard due to the constraints on the time windows. However, due to the structure of the layered graph, we can create a simple, pseudopolynomial dynamic programming algorithm that solves the pricing problem on the layered graph. 3.1. A Dynamic Programming Algorithm on the Layered Graph The layered structure of the graph lends itself well to dynamic programming. For each vehicle, we search

204 Transportation Science 38(2), pp. 197 209, 2004 INFORMS D + S 1 P 100 D + S 1 B 1 S 1 P 100 S 2 S 3 B 1 P 140 B 1 P 140 B 2 B 3 S 2 S 3 S 2 B 2 S 2 B 2 S 3 B 3 S 3 B 3 S 2 B 2 S 3 B 3 D B 2 B 3 D Figure 1 Transformation into Layered Graph Note. The left figure shows an original graph layout of a problem with three orders S 1 B 1, S 2 B 2,and S 3 B 3,the start depot D +,and the end depot D. The precedence levels of the nodes are shown below the node labels. The right figure shows the corresponding layered network. The representatives for the depot nodes are nodes D + and D,the representatives for sellers and buyers are nodes S 1, S 2, S 3, B 1, B 2,and B 3. The four possible paths on precedence level 160 are represented by the super nodes S 2 B 2, S 1 B 1 S 2 B 2, S 2 B 2 S 1 B 1, S 3 B 3,and the single path for the order S 1 B 1 is represented by the super node S 1 B 1. Time windows are handled as in Example 1. through the graph from the corresponding start depot, considering each node exactly once. At every node v of the graph we maintain a table DPT v with arrived time and reduced cost T i R i of the paths through the node. As the graph is free of cycles, we may consider the nodes in increasing topological order. When the dynamic programming algorithm visits a node u, we know that all nodes from incoming edges have been handled, and thus we only need to merge the tables of nodes from incoming edges to obtain the table for u. The merging of the tables is done by extending all paths from the tables of nodes of the incoming edges to u. This way, we obtain a set of paths ending in u. For each path, we check whether it is feasible and not dominated by any other path. If so, we add it to the table of u. The function Merge(DPT 1 DPT 2 ) merges the two tables DPT 1 and DPT 2, removing dominated paths in linear time in the number of elements in the tables. An example of how the merging function works is shown in Figure 2. Because the graph is loop-free, we get a simpler dominance criterion than the state algorithm operating on the original graph layout, as we do not need to look at previously visited nodes when comparing two paths in the layered graph. If two paths p A and p B visit the same node in the layered graph and p A has spent less time than p B, then p A can be extended in all ways that p B can be extended. Using a notation similar to the one used in 2.2, the dominance criterion for the dynamic programming algorithm on the layered graph is thus: Proposition 3 (Dominance on the Layered Graph). A state S 1 j T 1 R 1 dominates a state S 2 j T 2 R 2 corresponding to the same node j in a layered graph iff T 1 T 2 R 1 R 2. By Proposition 3, if we sort the paths in a dynamic programming table by increasing values of T i, the reduced costs R i will be decreasing. The dynamic programming algorithm on the layered graph is shown in Figure 3. The better dominance criterion and the topological sorting of the graph make it possible to provide a faster dynamic programming algorithm for the layered graph layout than for the original graph

Transportation Science 38(2), pp. 197 209, 2004 INFORMS 205 DPT DPT Arrival Time Reduced Cost p 1 10:00 3.0 p 2 10:45 2.0 p 3 12:00 0.7 p 4 13:30-1.0 p 5 14:00-2.5 Arrival Time Reduced Cost p 1 9:45 3.0 p 2 10:45 2.0 p 3 12:30 1.0 p 4 13:00-3.0 Arrival Time Reduced Cost 9:45 3.0 p 1 10:45 2.0 p 2 12:00 0.7 p 3 13:00-3.0 p 4 DPT Figure 2 An Example of Merging Two Dynamic Programming Tables Note. We discard all dominated paths by the dominance criterion in Proposition 3. layout. If we assume that the arrival times are discrete, e.g., by rounding the arrival time to the nearest minute, the dynamic programming tables will contain at most T rows, where T is the number of different arrival times. The dynamic programming algorithm visits every node exactly once and tries to expand the paths along all edges leaving the nodes. Each edge results in a merge of two dynamic programming tables, which can be done in O T time. Thus, the complexity of the algorithm is O E T, where E is the number of edges in the layered graph. The number of edges in the layered graph may unfortunately be exponentially large in the input data, but our experimental results show that the size of the layered graph is fairly small, resulting in reasonable running times of the pricing algorithm. 4. Exact Solution Through Branch and Bound The solutions to the LP-relaxation of the MP found by column generation are not necessarily integral. To obtain integral solutions, we apply a branching rule that excludes the fractional solutions. When designing the branching scheme, we have made the following design goals: The branching scheme should divide the solution space evenly because doing so will exclude a large number of solutions in each of the subproblems. This will give us a good chance of decreasing the gap between the best fractional solution and the best integral solution in each node of the branching tree. The branching scheme should help the pricing problem; i.e., the pricing algorithms should be able to make use of the fact that they are working on a smaller solution space. This design goal is as much a design goal for the pricing algorithms as it is for the branching rule. 4.1. Branching on Assignment of Customers to Vehicles The chosen branching scheme divides the solution space into two subspaces such that in one subspace a customer i 0 must be visited by a vehicle k 0, and in the other subspace i 0 may not be visited by k 0. The branching is applied by adding the constraints p x k 0 p i 0 p = 1 and p x k 0 p i 0 p = 0, respectively, to the path formulation. Unfortunately, this branching scheme does not divide the solution space evenly because assigning a customer to a vehicle is more restrictive than forbidding a customer from being visited by a vehicle. In the case of assigning a customer i 0 to a vehicle k 0, all routes for k 0 without customer i 0 and all routes for other vehicles serving i 0 can be excluded from the solution space. In the case of forbidding a customer i 0 on a vehicle k 0, we can only exclude routes for k 0 serving customer i 0. We can compensate for the uneven division by branching on the vehicle and customer belonging to the highest fractional variable x k 0 p 0 < 1. This way, we branch on a vehicle and on the customer that is most likely to be served by this vehicle in an integral solution. This strengthens the branch where the customer Sort the nodes V in topological order For all nodes v V DPT v For all nodes u where (u, v) E Extend all legal routes in DPT u to v to create DPT uv DPT v Merge(DPT v,dpt uv ) Return the cheapest route among all DPT u where u is an end depot Figure 3 Pseudocode of the Dynamic Programming Algorithm on the Layered Graph

206 Transportation Science 38(2), pp. 197 209, 2004 INFORMS is not served by the vehicle because the fractional solution is changed the most possible, and thereby the lower bound of the weak branch is likely to improve. Our experiments show that branching on assignment of customers to vehicles, together with this selection strategy, results in a quite even distribution of the solution space. The pricing algorithms can make use of both constraints when generating routes. In the case of customer i 0 being assigned to vehicle k 0, we can cut off all routes for vehicle k 0 that do not visit i 0. This can be done for routes belonging to k 0 in the state algorithm during the route generation by checking in each step whether it is still possible to add i 0 to the route. If not, the route generation can cut off the further extension of this route. In the case of forbidding the assignment of customer i 0 to vehicle k 0, we can make use of this in the route-generation algorithms working on the original graph layout by cutting off routes belonging to k 0 if they visit i 0. This can be done during the route generation, which means that further extension of such routes is avoided. To make use of the branching constraints in the dynamic programming algorithm working on the layered graph layout, we change the layered graph for each driver involved in a branching constraint. If a customer i 0 must be visited by a specific driver k 0,we hide all edges in the graph for driver k 0 that jump over the precedence level of i 0. We also hide edges into super nodes on i 0 s precedence level that do not represent a path visiting i 0. On the other hand, if a customer i 0 may not be visited by a vehicle k 0, we simply hide all super nodes representing paths visiting customer i 0 in the graph for driver k 0. 5. Computational Experiments We have implemented the described branch-andprice algorithm to solve the PDPTWP, including the three route-generation algorithms and the branching scheme, using ABACUS (a branch-and-cut system) (Thienel 1995). ABACUS provides an interface to CPLEX (ILOG 2000), which we have used to solve the linear programs resulting from the column generation. All tests have been carried out on a 933 MHz Intel Pentium III with a time limit of three hours of CPU time. We have tested both the state algorithm working on the original graph layout and the dynamic programming algorithm working on the layered graph layout to compare the two pricing algorithms. In both cases, we started the column generation by using the construction algorithm, because this algorithm is very fast and generates paths of high quality. To test our algorithm, we have constructed a series of subproblems from the data set supplied by the SPF Association, which is a real-life data set of about 1,300 transportation requests to be handled by 90 vehicles in five days. The complete data set is illustrated in Figure 4. Table 2 shows the characteristics of the 10 smaller test problems we have used. Unfortunately, the data set provided by the SPF Association has only very few time windows (less Figure 4 Geographical Location of All Sellers and Buyers Serviced by the SPF Association in Week 50, 1999

Transportation Science 38(2), pp. 197 209, 2004 INFORMS 207 Table 2 10 Test Problems Problem 1 2 3 4 5 6 7 8 9 10 Requests 35 71 39 51 35 45 77 108 29 86 Vehicles 16 37 24 32 16 24 35 51 16 53 Nodes orig. graph 104 218 128 168 104 140 226 320 92 280 Edges orig. graph 1 382 5 663 2 025 3 496 1 402 2 346 6 271 11 030 1 066 7 873 Nodes layered graph 210 361 242 284 178 346 356 519 125 404 Edges layered graph 1 502 5 744 2 132 3 573 1 463 2 600 6 350 11 160 1 079 7 917 State algorithm B&B nodes 1 4 625 37 83 1 5 559 2 963 817 1 61 Col. gen. iter. 23 4 830 55 150 23 10 464 2 961 1 028 24 98 CPU 4 81 10 800 22 2 167 3 71 4 548 10 800 10 800 1 10 367 CPU LP 0 06 199 0 35 2 10 0 06 133 175 201 0 05 5 61 CPU pricing 4 64 10 556 21 62 164 3 59 4 355 10 606 10 514 0 94 360 Dyn. prog. algo. B&B nodes 1 15 417 29 221 1 4 947 2 561 4 089 1 151 Col. gen. iter. 24 15 833 84 425 26 9 969 5 236 5 955 26 285 CPU 3 64 10 800 14 4 140 1 87 2 224 4 853 9 768 0 99 297 CPU LP 0 05 312 0 45 4 48 0 10 95 264 424 0 05 13 7 CPU pricing 3 54 10 434 13 81 135 1 68 2 094 4 554 9 264 0 88 281 Note. The table shows the size of the 10 test problems,the size of the original representing graph,and the size of the derived layered graph. The table also shows the number of branch-and-bound nodes,the number of column generation iterations,the total CPU time in seconds,the CPU time used solving the linear programming problems,and the pricing problems when using the state algorithm on the original graph or the dynamic programming algorithm on the layered graph as the pricing algorithm. An asterisk indicates that the algorithm did not terminate within the given time limit. than 10% of the customers), and the time windows that are present are often very wide. The reason might be that the current system is not designed for dealing with tight time windows; hence, customers are encouraged not to provide any time restrictions. Time windows may, however, become an important issue in the future. To test the performance of the algorithm on problems with tighter time windows, we have created nine new problems with time windows by adding 2-hour time windows on, respectively, 25%, 50%, and 75% of the requests for Problems 6, 7, and 8. Our experiments on problems with time windows will be described in 5.2. 5.1. Comparing the Pricing Algorithms By using either the state algorithm on the original graph or the dynamic programming algorithm on the layered graph to solve the pricing problem, we obtain an exact algorithm. Table 2 shows the number of branch-and-bound nodes, the number of column generation iterations, the total CPU time in seconds, and the CPU time used for solving the linear programming problems and the pricing problems, respectively, for the two branch-andbound algorithms obtained by varying the pricing algorithm. The run times show that the branch-and-bound algorithm using the dynamic programming algorithm working on the layered graph is between one and two times faster than the configuration using the state algorithm. However, we see that the dynamic programming algorithm performs best for the largest problems. To test the two algorithms on larger problems, we consider the complete daily problems. The problem characteristics are shown in Table 3. Because the computation time needed to solve these large test instances can be very high, we limit the height of the branch-and-bound tree. The run times of the two configurations are also shown in Table 3. For Table 3 Comparison of Size of Instances and Solution Times Problem 1 2 3 4 Requests 148 205 214 204 Vehicles 88 88 88 88 Nodes orig. graph 474 588 606 586 Edges orig. graph 28 084 41 411 43 653 41 377 Nodes layered graph 1 244 1 661 6 745 2 621 Edges layered graph 29 159 43 014 54 850 44 770 Dyn. Prog. algo. Gap to lower bound 2 65% 0% CPU (sec.) 82 5 463 10 800 10 800 State algo. Gap to lower bound CPU (sec.) 10 800 10 800 10 800 10 800 Note. The table compares the size of the instances (using the original graph representation or the layered graph) and the solution times in seconds for the four largest test problems. Problem 2 was solved to optimality,while a feasible solution no more than 2.65% from an optimal solution was found for Problem 1. No feasible solutions were found for Problems 3 and 4 within the given time limit.

208 Transportation Science 38(2), pp. 197 209, 2004 INFORMS Table 4 Run Times of the Branch-and-Price Algorithm on Test Problems with Time Windows Problem 6 7 8 Time windows percentage 25 50 75 25 50 75 25 50 75 Requests 45 45 45 77 77 77 108 108 108 Vehicles 24 24 24 35 35 35 51 51 51 Nodes orig. graph 140 140 140 226 226 226 320 320 320 Edges orig. graph 2 551 2 076 2 442 5 240 4 987 5 457 12 406 11 953 11 637 Nodes layered graph 759 355 759 292 292 304 647 534 499 Edges layered graph 3 597 2 377 3 514 5 280 5 027 5 511 12 800 12 146 11 778 CPU time (seconds) 11 13 1 807 15 6 87 498 715 194 the large test problems, the dynamic programming algorithm on the layered graph is able to solve two of four problems, whereas the state algorithm is not able to obtain a feasible solution for any of the problems. 5.2. Time Window Problems As previously mentioned, the data set supplied by the SPF Association contained very few time windows. To test the performance of the branch-and-price algorithm on problems with time windows, we have added 2-hour time windows to 25%, 50%, and 75% of the requests to test Problems 6, 7, and 8, which were among the hardest problems to solve. This gives us nine new problems to solve. The CPU time needed to solve the nine test problems is shown in Table 4. We have chosen to present only the results for the dynamic programming algorithm on the layered graph, because the results for the state algorithm were inferior to these. The results show that the solution time is reduced in all cases compared to the corresponding instances without time windows. For most cases, the reduction is significant; i.e., the solution times for the time window problems are less than one percent of the solution time of the original problems. In a few cases, the solution times have only been slightly reduced. 5.3. Summary for the Computational Experiments When introducing the path formulation of the PDPTWP, we claimed that the LP-relaxation would provide tight bounds on the optimal integral solutions. Our experiments showed that the LP-solution to MP at the root node of the branch-and-bound tree is within 0.24% of the optimal solution on average. From our experiments, we have found that there is little difference between the performance of the two pricing algorithms on small test instances. However, on larger test instances the dynamic programming algorithm seems to outperform the state algorithm. We also observed that problems with time windows could be solved considerably faster than problems without time windows. We were able to solve a problem containing no time windows with 320 nodes and 11,030 edges in 2 hours and 50 minutes. The same problem containing 2-hour time windows on 25% of the nodes was solved in 1 minute and 42 seconds, which is exactly two orders of magnitude faster. 6. Conclusion We have presented a new variant of the classical VRP, which is motivated by the transportation of live animals according to some veterinary constraints. The VRPTWP deals with time windows, capacity constraints, and precedence constraints. Because the additional constraints may be difficult to express in an MIP model, a path formulation has been presented. The LP-relaxation of the path formulation is solved through delayed column generation, providing relatively tight lower bounds for an exact algorithm based on branch and bound. The computational experiments with real-life problems show that the smaller problems may be solved to optimality in reasonable time. The contributions of this paper can be summed up as follows: We have presented a new routing problem with applications in transportation of live animals and adapted existing techniques from the VRP and the PDP to develop an exact algorithm based on branch and price. In particular, the dynamic programming algorithm working on a layered graph for solving the pricing problem is new, and the corresponding solution times are promising. As the SPF Association is expected to introduce a more detailed health-level classification, the reduction to a layered graph will become more attractive. Also, our experiments indicate that additional time windows do not make the problem more difficult to solve; thus, the SPF Association may be able to offer more flexibility to the customers in this respect in the future. The largest problem solved to optimality involves more than 580 nodes and 41 000 edges, which even for problems without precedence constraints is a very difficult task. For comparison, it should be mentioned that state of the art in the VRPTW is the solution of Solomon test instances with up to 200 customers (Kallehauge 2000). We believe that the presented approach may also apply to other types of VRP. Quite