Column Generation for the Pickup and Delivery Problem with Time Windows

Transcription

1 Column Generation for the Pickup and Delivery Problem with Time Windows Kombinatorisk optimering 1. april 2005 Stefan Røpke Joint work with Jean-François Cordeau Work in progress! Literature, homework assignments and slides on homepage after lecture. Kombinatorisk Optimering, April

2 The Pickup and Delivery Problem with Time Windows (PDPTW) The PDPTW is a model of a transportation problem that often occurs in real life. Assume that you own a fleet of vehicles. Your customers want goods to be transported between locations in Denmark. Examples 3x34 Transportation of lifestocks (for example pigs) Transportation of raw material and goods between production facilities and warehouses Kombinatorisk Optimering, April

3 The pickup and delivery problem with time windows More formally, we are given: A set of n requests. Each request consists of a pickup and a delivery. A request involves transporting an amount of goods. Vehicles have a certain maximum capacity. The pickup and delivery of a request are performed by the same vehicle. A time window is associated with both the pickup and the delivery. We usually want to either 1. minimize travelled distance (number of vehicles to use is free) or 2. minimize number of vehicles used. Kombinatorisk Optimering, April

4 Introduction to DARP Door-to-door transportation of elderly and disabled persons (the users). Several users are transported in the same vehicle (think of a mini-bus). The users specify when they wish to be picked up and when the they have to be at their destination (a request). The users do not specify an exact time of day, but a time window. Example: Instead of requesting a pickup at 9:11 the users request a pickup between 9:00 and 9:30. Often the user only specify either the pickup or delivery time window. An operator would assign the other time window. Kombinatorisk Optimering, April

5 Introduction to DARP Users don t like to be taken on long detours even if it helps the overall performance of the transportation system. Consequently a maximum ride time constraint is specified for each request. P2 D1 D2 P1 Time windows are not enough for ensuring that the maximum ride time constraint is enforced. Example: pickup [8:00; 8:15], delivery [8:45; 9:00], max ride time 45 minutes. Pickup at 8:00 and delivery at 9:00 violates max ride time constraint. Pickup time window could be shrunk to [8:15; 8:15]. This would ensure that ride time constraint is enforced, but it rules out perfectly good solutions like pickup at 8:05 and delivery at 8:45. Each vehicle has a certain capacity (only a limited amount of seats). The vehicles have to start and end their tours at a given start and end terminal. Objective: minimize driving cost subject to the constraints mentioned above. Problem is NP-Hard. Kombinatorisk Optimering, April

6 IP model Notation: n P = {1,..., n} D = {n + 1,..., 2n} Number of requests. Pickup locations Delivery locations N= P D {0, 2n + 1} The set of all nodes in the graph. 0 and 2n + 1 are the start and end terminal respectively. Request i consist of pickup i and delivery n + i. K Set of vehicles G= (N, A) Directed graph on which the problem is defined. A is the set of edges. Q Capacity of a vehicle q i Amount loaded onto vehicle at node i. q i = q n+i. [e i, l i ] time window of node i d i > 0 L duration of service at node i Max ride time of a request. c ij Cost of traveling from node i to node j. It is Assumed that c ij satisfies the triangle inequality. t ij Time needed for going from node i to node j. It is assumed that t ij satisfies the triangle inequality and that t ij >0. Kombinatorisk Optimering, April

7 Decision variables IP model Binary variables x k ij 1 iff the kth vehicle goes straight from node i to node j. Fractional variables Bi k When vehicle k starts visiting node i Q k i The load of vehicle k after visiting node i. L k i The ride time of request i on vehicle k. Kombinatorisk Optimering, April

8 IP model (3-index) Objective: min k K i N j N c k ij xk ij Every request is served exactly once: k K j N x k ij = 1 i P Same vehicle services pickup and delivery: j N x k ij j N x k n+i,j = 0 i P, k K Every vehicle leaves the start terminal: j N x k 0j = 1 k K The same vehicle that enters a node leaves the node: j N x k ji j N x k ij = 0 i P D, k K Every vehicle enters the end terminal: i N x k i,2n+1 = 1 k K Kombinatorisk Optimering, April

9 Standard model (3-index) Setting and checking visit time: B k j (Bk i + d i + t ij )x k ij e i B k i l i i N, j N, k K i N, k K Linearization of first equation (M k ij B k j Bk i + d i + t ij M k ij (1 xk ij ) is a large constant): i N, j N, k K Setting and checking vehicle load: Q k j (Qk i + q j)x k ij Q k i Q i N, j N, k K i N, k K Binary variables: x k ij {0, 1} i N, j N, k K If DARP: Setting and checking ride time: L k i = Bk n+i (Bk i + d i) L k i L i P, k K i N, k K Kombinatorisk Optimering, April

10 Overview of recent literature From my point of view: methods and heuristics Two main branches - exact PDPTW heuristics: Li & Lim, 2001, tabu search + simulated annealing, up to 50 requests, seconds on a i686. Bent & Van Hentenryck, 2003, LNS, up to 500 requests, Largest problems was solved in 135 minutes on 1.2 Ghz AMD. Ropke & Pisinger, 2005, ALNS, up to 500 requests, avg. time to solve largest problems was 90 minutes, but some of the problems took up to eight hours to solve (on a Pentium IV, 1.5 Ghz). Generally the later methods dominate the earlier in terms of solution quality. Xu, Chen, Rajagopal, 2003, column generation heuristic, up to 500 requests, largest problems was solved in hours on PIII, 450 Mhz. Problem was different from the problem solved in the three previous papers so a direct comparison is not possible. State of the art heuristics seems quite robust and yields high quality solutions. Kombinatorisk Optimering, April

11 Overview of recent literature PDPTW exact methods IP Column generation: Branch and bound algorithm with linear programming (LP) lower bound based on a model with an exponential number of variables. Branch & Cut: Branch and bound algorithm with (LP) lower bound based on a model with an exponential number of constraints. Dumas, Desrosiers, Soumis, 1991, column generation, up to 55 requests, largest problem was solved (*) in 313 seconds on a Cyber 855 computer (whatever that is). Savelsbergh, Sol, 1998, column generation, up to 30 requests, 5 seconds - 15 hours IBM/RS6000. Lu, Dessouky, Branch & Cut, 2003, up to 15 requests, 4.3 seconds hours on 900Mhz Sun computer. Without time windows, slightly larger problems could be solved. Sigurd, Pisinger, Sig, 2004, column generation, upto 205 requests, largest problem solved in 1.5 hours, 933Mhz PIII. Ropke, Cordeau, Laporte, 2005 (work in progress), branch and cut, up to 20 requests in 2 hours on 2.5 Ghz Pentium IV. Kombinatorisk Optimering, April

12 Ropke, Cordeau, 2005 (work in progress), column generation, up to 500 requests. Largest problem solved in 350 seconds on 2.5 Ghz Pentium IV. Only very nice problems of these sizes can be solved though. The last method is the topic of this talk. It s hard to compare algorithms. No standard benchmark instances + small variations in the problem solved. Kombinatorisk Optimering, April

13 DARP literature Heuristics, for an overview see: Jean-François Cordeau, Gilbert Laporte, The Dial-a- Ride Problem: Variants, Modelling issues and Algorithms, Technical Report, University of Montreal, G It s hard to compare heuristics due to lack of common test instances. Exact methods Several single vehicle algorithms from the eighties. Cordeau, 2004, Branch & Cut, instances with up to 30 requests are solved within 4 hours on 2.5Ghz Pentium IV. Ropke & Cordeau, 2005 (work in progress), Branch & Cut, instances with up to 50 requests are solved within 4 hours on 2.5Ghz Pentium IV. Kombinatorisk Optimering, April

14 PDPTW, Set Partitioning Problem (SPP) Enumerate all feasible routes. Construct an IP model where each decision variable x j corresponds to a feasible route. If x j = 1 then route j is used in the solution. c j gives the cost of the j th route. a ij indicates if request i is served on the j th route. min q j=1 c j x j (1) Subject to: q j=1 a ij x j = 1 i V 0 (2) x j {0, 1} j {0, 1} (3) Each column corresponds to a feasible path from node 0 to node n + 1. It can be proven that the LP-relaxation of the set partitioning formulation dominates the LP-relaxation of the 3-index formulation. Kombinatorisk Optimering, April

15 Set partitioning example 1 n+1 2 n+4 n n+3 Feasible routes (requests in the feasible routes): {1}, {2}, {3}, {4}, {1,2}, {1,4}, {2,3}, {3,4}, {1,2,4}. min 15x1 + 8x2 + 14x3 + 13x x6 + 20x7 + 19x8 + 27x9 st x x6 + x9 = 1 x x7 + x9 = 1 x x7 + x8 = 1 x x6 x8 + x9 = 1 Kombinatorisk Optimering, April

16 Solving the set partitioning problem When the number of feasible routes is rather small we can use the set partitioning model directly, and solve the problem using an IP-solver. The number of feasible routes can be small if the problem only contains a few customers, or if the problem is very constrained. Usually the number of feasible routes grows very rapidly as the number of customers increase. In a problem with 40 requests, where all routes with up to 7 requests are valid we would get about 4.6 million columns. Such a set partitioning problem is impossible to solve with the IP solvers of today, as the set partitioning problem is NP-hard. We could try to solve the LP relaxation of the problem, but even though we have polynomial time algorithms for the linear programming problem, this approach would also be futile if we apply linear programming directly. What we can do, is applying column generation techniques. Kombinatorisk Optimering, April

17 Delayed Column Generation for VRPTW Basic idea: 1. Solve the LP-relaxation using only a subset of all the columns. 2. Use the theory from the Simplex algorithm to determine if the LP solution to the reduced problem also is the optimal LP solution to the complete problem with all the columns. 3. If so, then we are done (we have a LP relaxation to the complete set partition problem). If not, then we use the theory of the Simplex algorithm to add one (or more) columns to our reduced problem. Step 1-3 is repeated until we are done. In practice step 2 and 3 are performed together. Kombinatorisk Optimering, April

18 Column Generation - details The initial set of columns should be chosen such that a feasible solution to the LP-problem exists. This can for example be done by creating n columns, each representing a route with one request. When the reduced LP-problem has been solved we should determine if our LP-solution also is optimal for the complete LP, or if more columns must be added to the problem. This is done by looking at how the simplex algorithm works. In each iteration of the simplex algorithm we have a basic solution. In order to progress we have to choose a new variable to enter the basis. In a minimization problem like ours we have to chose a variable with negative reduced cost. min cx (4) s.t. Ax= b (5) x 0 (6) Reduced cost: c r j = c j πa j where c j is the j th coefficient in the objective, π is the vector of dual variables and A j is the j th column in the matrix A. Kombinatorisk Optimering, April

19 Column Generation cont. In our problem the reduced cost of a column (variable) is: c r j = c j n π i a ij i=1 Thus we can generate all feasible columns one by one and check their reduced cost. In the end we can pick the column with lowest reduced cost. If that value is negative the column should be added to our problem, while if it is nonnegative the simplex algorithm is done and our solution is the optimal LP-solution to the complete LP-relaxation of the set-partitioning problem. In practice it is not possible to go through all columns one by one. Instead we define an IP-problem whose solution identifies the column with smallest reduced cost. We denote such a problem the pricing problem or the sub-problem. Recall that each column in our set partitioning problem corresponds to a feasible path from node 0 to node 2n+1. That is, a path that respects time windows and capacities. Thus we should look for these paths. Kombinatorisk Optimering, April

20 Column Generation cont. We are looking for a path from node 0 to 2n + 1. The path should respect the constraints of the PDPTW / DARP. This problem can be expressed as an IP problem with a binary decision variables x pq for each edge (p, q) in the graph. We would also need some fractional variables, but let us forget about them for now. The binary decision variable is 1 if the edge is used in the path. We have the following problem: min f(x) s.t. Bx = b x {0, 1} (2n+1)(2n+1) Kombinatorisk Optimering, April

21 How should f(x) look like? Recall from last slide: Reduced cost of a variable / column: c r j = c j n π i a ij i=1 a ij indicated if request i was used in route j. Given a solution to the IP above we can find the ith entry in its column a i as follows: a i = 2n+1 q=0 x iq Thus we can write the reduced cost of a column: c r = c = 2n+1 p=0 n π i a i i=1 2n+1 q=0 c pq x pq n π i 2n+1 x iq i=1 q=0 = 2n+1 p=0 2n+1 q=0 (c pq π p)x pq where π p = { πp if p {1,..., n} 0 otherwise Kombinatorisk Optimering, April

22 Column Generation cont. Our shortest path problem becomes min 2n+1 p=0 2n+1 q=0 (c pq π p)x pq s.t. Bx = b x {0, 1} (2n+1)(2n+1) This is an elementary shortest path problem with pickup and deliveries, time windows, capacity constraints and negative edge weights (ESPPPDTWCC). Such a problem is NP-hard. A problem that is slightly easier is the shortest path problem with pickup and deliveries, with time windows, capacity constraints and negative edge weights (SPPPDTWCC). In this problem, we are allowed to visit each customer several times, and our paths can consequently contain cycles. The problem is still NP-hard though. Most column generation algorithms for the PDPTW have done this, but we aim at solving the ESPPPDTWCC. Kombinatorisk Optimering, April

23 Shortest path example 1 n n+1 3 n+2 4 n+3 n+4 All edges have length 1. Dual variables: π 1 = 3, π 2 = 4, π 3 = 2, π 4 = 1 Notice: Cycling! When (i, j) E t ij > 0 or i V d i > 0 infinite cycling is imposible. Kombinatorisk Optimering, April

24 Solving the SPPPDTWCC Solution approach: labeling algorithm. Brute force: Enumerate all paths: Labels are associated with each node i in the graph. A label indentifies a path from 0 to node i. Various info can be stored in the label, like the cost of the path, the sequence of nodes visited in the path, the time node i is visited in the path. We start out with only one label. This label is associated with node 0 and has cost zero. concept - extending labels: Consider one specific label in node i and extend the path corresponding to the label to all nodes that can be reached directly from i. For each of the constructed paths, check if it is feasible. If it is, create a new label in the end node corresponding to the new path. Kombinatorisk Optimering, April

25 The brute force algorithm works as follows: While labels in nodes 0,..., 2n exists: Select a label l, do not select labels in node 2n + 1. Extend the label to all nodes that can be reached directly from the label and erase the label. Find the cheapest label in node 2n + 1. Return the path stored in the label, this is the shortest path. Every time a label is extended the childs of the label will have a later start time because of assumptions so process will end. But... the running time is exponential and we get nonelementary paths. We can get rid of nonelementary paths by keeping track of the nodes visited in the label/path. We should not extend labels to already visited nodes. Kombinatorisk Optimering, April

26 Solving the ESPPPDTWCC Example again: 1 n n+1 3 n+2 4 n+3 n+4 Kombinatorisk Optimering, April

27 Solving the ESPPPDTWCC Speeding up labeling algorithm: Dominance. Is it possible to discard some labels during the excecution of the algorithm? Assume that the labels x and y both corresponds to node i. We say that x dominates y if the cheapest feasible path to node 2n + 1 that can be created from label y is more expensive than the cheapest feasible path to node 2n + 1 that can be created from label x. If x dominates y then y can be discarded (the paths we get from y will be more expensive than the best path we get from x). How can we know if x dominates y? Kombinatorisk Optimering, April

28 First try: x dominates y if cost of path in x is cheaper than cost of path in y. Doesn t work: If label x visits node i later than label y then we might visit some edges with high negative reduced cost that can t be visited from label x because of time windows. Second try: x dominates y if cost of path in x is cheaper than cost of path in y and node i is visited at least as early in label x as in label y. Getting better. Problem above solved, but still not good enough. If x has visited some requests that y hasn t visited then the best path extended from y might end up being better than the best path extended from x. The path extended from y might visit some of the nodes that x already has visited and thereby use some negative cost edges that paths extended from x can t reach. Third try... Kombinatorisk Optimering, April

29 Final solution: x dominates y if x.cost y.cost x.time y.time x.nodesv isited y.nodesv isited x.openrequests y.openrequests openrequests are the requests that the path in the label has started serving (pickup serviced) but hasn t finished (delivery not done yet). This dominance relation works if visiting deliveries never lowers the the cost of the paths. This can be achieved by moving the dual values from the edges leaving the pickups to the edges entering the pickups. Several tricks can be used to speed up the computation more. Kombinatorisk Optimering, April

30 Hard and Easy ESPPPDTWCC Several properties of a SPPTWCC problem influences the practical hardness of the problem when solved by the algorithm described above. The table below summarizes these properties. Easier Harder Small problems Large problems Sparse graph Dense graph Tight time windows Large time windows few open requests at the same time Many open requests at the same time Few edges with negative cost Many edges with negative cost It is hard to do much about the first four properties, allthough the preprocessing described at the end of this lecture can help a bit. The number of edges with negative cost and the magnitude of the negative costs are determined by the dual variables (recall that cˆ pq = (c pq π p)). Let s see how the dual variables and the edge cost behave as our column generation algorithm progresses. Kombinatorisk Optimering, April

31 Column generation R101, 100 cust. (VRPTW examples) n i=1 π i/n: 500 avgdual.plot Average edge cost in graph for shortest path problem: 200 avgedgecost.plot Kombinatorisk Optimering, April

32 Column generation R101, 100 cust. Percent negative edges in shortest path graph. 80 percentnegedges.plot Number of labels processed in shortest path algorithm proclabels.plot Kombinatorisk Optimering, April

33 Column generation R102, 100 cust. Percent negative edges in shortest path graph. 80 percentnegedges.plot Number of labels processed in shortest path algorithm proclabels.plot Kombinatorisk Optimering, April

34 Column generation R103, 100 cust. Percent negative edges in shortest path graph. 80 percentnegedges.plot Number of labels processed in shortest path algorithm proclabels.plot Lesson learned: The shortest path problem should be solved with a heuristic initially. Only when the heuristic Kombinatorisk Optimering, April

35 no longer can produce columns with reduced cost is it neceassary to switch to the exact method. We must always solve the last pricing problem to optimality to prove that the lower bound is valid. Kombinatorisk Optimering, April

36 Adding more inequalities to the model It would be nice to be able to add inequalities to our set partitioning problem. This would allow us to add valid inequalities in a cutting plane fashion. Furthermore it can make it easy to implement a branch and bound method. In general this is not easy though as the addition of a new inequality can change the structure of our subproblem. We will now see how inequalities in the x k ij variables in the original 3-index formulation can be used in the column generation. Define flow variables: f ij = x k ij i, j V k K Given a solution (x p ) to the LP relaxation of our SPP we can find the flow variables as follows: f ij = q y p ij x p i, j V p=1 where y p ij indicates the number of times that path p uses edge (i, j). <TEGN> Kombinatorisk Optimering, April

37 Adding more inequalities to the model Any valid inequality in the x k ij variables can be written as: k V i V j V ρ ijk xk ij τ Since the vehicles are identical this can be rewritten using flow variables: ρ ij f ij τ i V j V In the column generation context the left hand side becomes ρ ij q (y p ij x p) = q (ρ ij y p ij x p) i V j V p=1 p=1 i V j V Thus the coefficient of the p th column is i V j V (ρ ij y p ij ) If the dual variable corresponding to the constraint is named θ then the cost of an edge in our subproblem becomes:ĉ ij = c ij π j θp ij, and we can solve this shortest path problem using the algorithms discussed previously. Kombinatorisk Optimering, April

38 Method for solving DARP Now that we can add inequaties to the master problem, we can use the PDPTW pricing problem when solving DARP problems. We don t have to make a specific pricing algorithm. Infeasible path iinequality: For all paths i 1 i 2... i α that are infeasible because of ride time constraints, add the following constraints to the master problem: α 1 j=1 x ij i j+1 α 2 <TEGN> There are an exponential amount of these constraints, but they can be generated on the fly. They can even be separated in polynomial time. Kombinatorisk Optimering, April

39 Additional cuts Even though our LP relaxation is composed of elementary shortest paths we might get some ugly LP solutions as the example below illustrate. The following slides introduces some valid inequalities from Branch and Cuts algorithms for the PDPTW. It is not known if these inequalities will be useful for the column generation algorithm. Kombinatorisk Optimering, April

40 Valid inequalities - some examples Subtour elimination constraints j i k x ij + x ji + x jk + x kj + x ki + x ik 2 Lifting for directed case: i 2 j k Lifting for PDPTW case: x ij + 2x ji + x jk + x ki 2 n+j i 2 j n+k k x ij + 2x ji + x jk + x ki + x n+j,i + x n+k,i 2 General expression and more liftings described in paper. Separation algorithms? Kombinatorisk Optimering, April

41 Generalized order constraints i j k n+j n+k n+i x i,n+j + x n+j,i + x j,n+k + x n+k,j + x k,n+i + x n+i,k 2 Lifting for directed case: i j k n+j n+k n+i x i,n+j +x n+j,i +x j,n+k +x n+k,j +x k,n+i +x n+i,k +x ij +x i,n+k 2 Separation algorithms? Kombinatorisk Optimering, April

42 Capacity constraints i S j N\S x ij q(s) Q S P D q(s) = i S q i +1 Max. vehicle capacity = S +3 Separation algorithms? Kombinatorisk Optimering, April

43 Branching Many branching schemes have been proposed in the literature, here we will only look at two (and only one that actually works!). The most obvious branching scheme is to branch on the fractional x j variables in the SPP, this corresponds to saying that the j th route must be used in one subproblem and must not be used in the other subproblem. Unfortunately this branching scheme does not work very well with the column generation method: The x j = 1 branch is easy. Here we can remove the requests served by the j th route from the problem and add the cost of the route to the objective function. The x j = 0 branch is harder. In this case we must ensure that our column generation does not return the column we have forbidden. This can only(?) be done by making a shortest path algorithm that not only can return the shortest path but also the second shortest path. And this is a bit more tricky than it seems (see exercise). When p columns have been fixed to zero the shortest path algorithm must be able to return the p th shortest path. Kombinatorisk Optimering, April

44 Branching cont. The second branching scheme branch on the f ij variables (remember that f ij indicates if an arc is used in the solution or not). In this case it is easy to handle both the f ij = 1 and f ij = 0 branches. Fixing f ij to zero is simply done by removing the edge (i, j) from the graph. Fixing f ij to one is done by removing all edges originating in i unless i=0 and all edges ending in j unless j = n + 1 from the graph. The only edge originating in i and ending in j left in the graph is (i, j). <TEGN> The problem with this branching scheme is that it creates unballanced sub problems. Kombinatorisk Optimering, April

45 Preprocessing General idea: Reduce the size or complexity of a problem before applying a time consuming method like branch and bound. <TEGN> Kombinatorisk Optimering, April

46 PDPTW Results Branch & Cut results (Ropke, Cordeau & Laporte, Work in progress): name n time init UB best IP Opt root LB best LB B&B nodes a a a a a a a a b b x b b x b b b b x b b b b Kombinatorisk Optimering, April

47 Column Generation (Ropke & Cordeau, Work in progress): name n Opt LB root best IP time nodes LP-time a X X a X X a X X a X X a X X a X X a X X a X X a X X a X X a X a X b X X b X X b X X b X X b X X b X X b X X b X X b X X b X X b X X b X X Kombinatorisk Optimering, April

48 Column Generation (Ropke & Cordeau, Work in progress): #Req Opt LB Opt best IP time nodes LP-time LC X X LR X X LRC X X LC X X LR X X LRC X LC X X LR X X LRC X LC X X LR LRC LC X X LR LRC Kombinatorisk Optimering, April

49 Conclusion Hard problems! Interesting problem. Lot of stuff to do! Column generation seems better suited than branch & cut for the PDPTW at the moment. It s going to be interesting to see the results for the DARP. Kombinatorisk Optimering, April