Combining Constraint Programming and Tabu Search to Solve Vehicle Routing Problem with Time

Windows

Nguyen Huu Bao Quoc and Duong Tuan Anh Faculty of Computer Science and Engineering Ho Chi Minh City University of Technology

dtanh@cse.hcmut.edu.vn

Abstract—This paper presents a new two-stage approach to solve Vehicle Routing Problem with Time Windows. The first stage aims to minimize the number of routes and the second stage is to minimize the travel distance. The approach is also based on a combination of Tabu search method and constraint programming technology. The main idea is to apply the power of constraint propagation in constraint programming to reduce the computational cost when Tabu search needs to scan the whole neighborhood to find the best non-tabu moves at each iteration.

I. INTRODUCTION

Vehicle routing problems (VRP) are important components of many distribution and transportation systems, including such examples as bank deliveries, postal deliveries, waste collection, and security patrol services. They have received considerable attention in the past decades. This paper considers the vehicle routing problem with time windows (VRPTW). Given a number of customers with known demands and a fleet of identical vehicles with known capacities, the problem consists of finding a set of routes originating and terminating at a central depot and servicing all the customers exactly once. The routes cannot violate the capacity constraints on the vehicles and, in addition, must meet the time windows of the customers, which specify the earliest and latest times for the start of service at a customer site. A number of exact and approximated algorithms exist that have been developed to solve the VRPTW problem([2]). While exact algorithms can only solve relatively small size problems, several metaheuristic for the problem have proved very successful.

In this work, we propose a two-stage approach to solve VRPTW. The first stage aims to minimize the number of vehicles or routes, and the second stage is to minimize the total travel cost performed by the vehicles. The approach is based on a combination of Tabu search method and constraint programming technology. The main idea is to apply the power of constraint propagation in constraint programming to reduce the computational cost when Tabu search needs to scan the whole neighborhood to find the best non-tabu moves at each iteration.

There have been a few works that use a two-stage local search algorithm for the VRPTW. Homberger et al., 1999 ([5]) first proposed a two-stage algorithm which use evolutionary metaheuristic with two evaluation functions. Bent et al., 2001 ([1]) proposed a two-stage hybrid algorithm for the VRPTW. The algorithm first minimizes the number of vehicles using simulated annealing and then minimizes travel cost using a Large Neighborhood Search which may relocate a large number of customers. Csiszar, 2007 ([3]) also used a two-stage hybrid algorithm for the VRPTW: the minimization of number of

vehicles is achieved in the first phase by a specialized procedure called Guided Route Elimination, and the travel cost minimization is achieved in the second phase by Tabu Search.

Some hybrid algorithms which combine constraint programming and local search have already proven the efficiency of the paradigm on the VRP. De Baker and Furnon, 1997 ([4]) have proposed to use constraint programming to validate solutions generated by some local search heuristics, and Shaw, 1998 ([6]) proposed to use constraint programming to evaluate the cost and validity of the moves within a local search framework. Our method is somewhat similar to the latter in the sense that we also propose to use constraint programming to eliminate subsets of neighbor solutions and furthermore limit the number of solutions that are actually visited when Tabu search needs to explore the large neighborhood at each iteration.

We experimented the proposed approach on Solomon’s 56 VRPTW benchmark instances. Experimental results indicate the benefits of dividing the optimization in two stages and using constraint programming in eliminating infeasible subsets of the large neighborhoods in local search method. The major advantage of bringing constraint programming into local search methods is the flexibility and ease with which additional constraints, such as time window constraints, can be handled.

II. PROBLEM DEFINITION

This section defines the vehicle routing problem with time windows (VRPTW) and the various concepts used in this paper.

Customers The problem is defined in terms of a set of N customers, C = {1,2,3, …, N} and a depot represented by the number 0. Each customer ci has a demand q(ci) ≥ 0 and a service time st(ci) ≥ 0. Information about the sites of customers is given by S, a distance matrix of order N. The traveling cost between the sites of two customers, s(ci,cj), is defined by s(ci,cj) = sxy (x = ci, y = cj, sxy∈S).Traveling costs satisfy the triangular inequality: ∀ ci, cj, ck ∈ C:s(ci, cj) + s(cj, ck) ≥ (ci, ck)

Let t(ci,cj) be the time for the vehicle traveling from customer ci to customer cj. In an ordinary VRPTW we assume t(ci,cj) = s(ci,cj).

Vehicles and the depot. The VRPTW is defined in terms of Kidentical vehicles. Each vehicle has the same capacity Qmax. All the vehicles start from the depot, denoted as c0.

Routes. A vehicle route, or route for short, starts from the depot, visits a number of customers at most once, and returns to the depot. In other words, a route r with size |r| is a sequence of customers <c0,c1,…,c|r|,c0> where all ci are different.

978-1-4244-8075-3/10/$26.00 ©2010 IEEE

previous(ci, r) denotes the predecessor of customer ci in a route r.next(ci, r) denotes the successor of customer ci in a route r.

previous_set(ci, r) denotes the set of customers on the path from the depot to customer ci, not including ci. That means: previous_set(ci, r) = {cj | cj ∈ r and j < i }

The demand of a route, denoted by Q(r), is the sum of the demands of its customers, i.e., Q(r) =

∈ rci

i

cq )(

A route satisfies its capacity constraint if: Q(r) ≤ Qmax .

The travel cost of a route r, denoted by s(r), is the cost of visiting all its customers, i.e.,

s(r) = s(c0, c1) +−

=+

1||

11 ),(

r

kkk ccs + s(c|r|, c0).

Time Windows The customers and the depot have time windows. The time window of a site ci is specified by an interval [ei, li], where ei , li represents the earliest and latest arrival times respectively. Vehicles must arrive at a site before the end of the time window li.They may arrive early but they have to wait until to be serviced. Notice that e0 = 0 represents the time when all vehicles in the routing plan leave the depot and that l0 > 0 represents the time when they must all return to the depot.

The arrival time to serve customer ci on route r, denoted by a(ci, r), is defined as :

a(ci, r) = d(cj, r)+ t(cj, ci) (where ci,cj ∈ r and cj = previous(ci)).

The departure time of customer ci on route r, denoted by d(ci, r), is defined recursively as:

d(ci, r)= ≤<+

=Nicstrcserved

i

ii 0)(),(00

The earliest service time of customer ci on route r is defined as: served(ci, r)= max(a(ci, r),

ice ) .

The earliest finish time of a route r, denoted by a(r), is defined as:

a(r) = d(cj,r)+ t(cj, c0) ( where cj∈r and next(cj) = c0).

Routing Plan A routing plan σ of size |σ | is a set of routes {r1,r2, … ,r|σ|} (|σ| ≤ K) visiting every customer exactly once.

A routing plan σ satisfies its capacity constraint if:

∀ r∈ σ : Q(r) Qmax (i)

A routing plan σ satisfies its time windows at all customers if:

∀ci ∈ C, ∃ r ∈ σ : ci ∈ r and a(ci, r) lci (ii)

A routing plan σ satisfies its time windows at the depot if:

∀ ri∈ σ : a(ri) l0 (iii)

According to Bent et al. [1], the objective function of VRPTW is usually expressed as costs related to the number of vehicles and to distance traveled. In other words, the VRPTW consists of finding a solution σ minimizing the objective function specified by the lexicographic order:

f(σ) = <|σ| , ∈σr

rs )( > (iv)

The objective of the VRPTW is to find a routing plan σmin = {r1,r2,. . , r|σ|} satisfying the capacity constraints and time window constraints (i.e. all the conditions (i), (ii), (iii)), and minimizing f(σ).

III. MOVE OPERATORS AND OBJECTIVE FUNCTION

In a metaheuristic context, an operator is defined as a recipe to modify a solution and obtain a potentially better one. An operator defines a neighborhood, that is the set of solutions that can be produced by applying that operator on one solution. A move is a transition from one solution to the one in its neighborhood. In our Tabu search algorithm, we use five move operators: 2-opt, 2-opt*, Exchange, Or-opt and GENI.

The objective function

f(σ) = <|σ| , ∈σr

rs )( >

is not appropriate, since it may lead to the search to solutions with a small travel cost and make it impossible to removes routes to minimize the number of vehicles ([1]). To overcome this difficulty, our algorithm uses a more complex objective function

fmin-routes = <|σ| , -slr(σ), mdl(σ)> (v)

especially tailored to minimize the number of routes. The first component is of course the number of routes. The second component in (v) maximizes

slr(σ) = ∈σr

r 2||

which means that it favors solutions containing routes with many customers and routes with few customers over solutions where customers are distributed more evenly among the routes. The intuition is to guide the algorithm into removing customers from some small routes and adding them to larger routes. It favors solutions where customers on the smallest route can be relocated on other routes with no constraints violations or with time window violations which are as small as possible. Minimizing minimal delay thus favors solutions where customers can be relocated more easily over solutions where relocation is hard. To represent the concepts more precisely, we need some more definitions.

Let la(ci, r) denote the latest arrival time to the customer ci in route r. It is defined as:

la(ci, r) = ≤<

=Njil

il,000

where l = min(la(cj,r) - t(ci, cj) - st(ci), lci) and cj = next(ci, r).

The delay time of a customer ci if ci is inserted after customer cj on another route in a routing plan σ is defined as:

dt(ci,cj,σ) = max(d(cj, r) + t(cj, ci)- icl , 0)

+ max(d(ci, r) + t(ci, ck) - la(ck, r), 0) where r = r(cj) and ck = next(cj, r).

The minimal delay of a customer ci on route r in the routing plan σis defined as:

mdl(ci, r,σ) = >+≠∈∀∞

=≠∈∃

otherwisedQcqrQrrr

truercinsertrrr

i

i

max)()'(:',')',(:','0

σσ

where d = min{ dt(ci, cj, σ) | cj ∈ C\ customer_set(r)}, insert(ci, r’) is a predicate that can determine whether customer ci can be inserted on another route r’ without violating any time windows, and customer_set(r) is the set of customers served on route r.

In other words, the minimal delay of a customer ci is 0 if ci can be relocated on another route, ∞ if ci cannot be relocated without violating the capacity constraints of the vehicle, or the minimal time window violations induced by relocating ci after a customer cj on another route.

The minimal delay of a routing plan σ (the third component in (v)) is the minimal delay of the route with the smallest number of customers. The delay of a route is the summation of the delay of its customers.

mdl(σ) = mdl(σ, rmin) (∀ r ∈σ: |r| ≥ |rmin|)

= ∈ min

),,(rc

rcmdl σ

IV. TWO-STAGE SOLVING METHOD

Our approach separates the optimization into two stages: the minimization of the number of routes and the minimization of travel costs. The objective function used for the first stage is the function fmin-routes given in Section III. In the second stage which minimizes the travel costs, we use the following objective function:

fmin_distance = <|σ|, ∈σr

rs )( >.

The local search method we use in both stages of optimizations is Tabu search. Tabu search is a metaheuristic that employs computer memory structures to avoid phenomena like local minima and limit cycles.

A.Combining Tabu Search and Constraint Programming One critical feature of our Tabu search algorithms used in both the

stages is that at each iteration, all the solutions in the neighborhood of the current solution are considered, and the computational cost would be extremely high in the exploration of large neighborhoods. It is easy to understand that larger neighborhoods will tend to include better solutions, but the time needed to explore those neighborhoods grow rapidly and substantially limits the scope of an operator. To reduce the computational cost in the exploration of the neighborhood, our Tabu search algorithms use constraint propagation technique to reduce the domain of the neighbor customer set by removing any customers in the set which can not satisfy any related capacity constraints or time window constraints. The constraint programming technique can be applied to all five move operators in our algorithm. In this paper, only 2-opt* operator will be represented, since all the other operators, such as 2-opt, Or-opt, Exchange and GENI can be implemented in the same way. The 2-opt* removes two arcs from two different routes (one from each) to divide each route into two parts and exchanges the second parts of the two routes. Figure 1. illustrates the 2-opt* operator.

The domains of neighbor customer sets for customer ci and cj-1 can be reduced by the following way.

In order to cut down on the combinatorics, the neighbor customer set of a given customer ci can be selected among ci’s closestneighbors, that means it is based on such the following set:

neigh_set(ci, r) = {cj | ci, cj∈ C and d(ci, r) + t(ci, cj) ≤ lj}.

Due to t(ci, cj) = s(ci, cj), we can apply triangular inequality s(ci,ck) + s(ck, cj) ≥ s(ci, cj) to temporal quantities to the new triangular inequality, i.e., t(ci, ck) + t(ck, cj) ≥ t(ci, cj).

If the conditions on time windows are violated for the vehicle traveling from the customer ci to customer cj, then we remove from the neighbor customer set of ci all the customers in the set previous_set(cj)which are specified as in the following clause.

Figure 1. 2-opt* operator

∀ck∈ previous_set(cj): d(ci) + t(ci, ck) + t(ck, cj) > d(ci) + t(ci, cj) > la(cj, rj).

Then, we can do the same thing for the domain of the neighbor customer set of customer cj-1.

Similarly, if the capacity constraints on the vehicle to travel from ci to cj are violated, we remove any customer cj from the neighbor customer set of ci. The sum of the demands of the customers on the new route r’ can be computed by the following formula:

Q(r’) = tq(ci) + q(ci) + Q(rj) – tq(cj).

where rj is the route of cj and tq(ci) is the sum of the demands of all customers on the path from the depot to customer ci, not including the demand of ci.

If Q(r’) > Qmax then we can ensure that all the other customers on the path from the depot to the customer cj on the route rj after applying the move operator will not satisfy the capacity constraint. Therefore, we remove from the neighbor customer set of ci all the customers in the set previous_set(cj) which are specified as in the following clause:

∀ck ∈previous_set(cj) : Q(r’) + q(ck) > Qmax .

Notice that the constraint propagation effect can be exploited in the most efficient way since the search algorithm can detect constraint violations as soon as possible. The computational cost for the scan on the solution space by Tabu search is reduced remarkably.

B. How to Obtain the Initial Solution The initial feasible solution σinit is generated by an extension of

the push-forward insert heuristic procedure (PFIH), proposed by M.M. Solomon, 1987 [7]. The procedure is an efficient method to create an initial routing plan.

V. EXPERIMENTAL RESULTS

This section describes experimental results on our algorithm. The algorithm was implemented in C#. All experiments are tested on a Pentium IV 2.8 GHz, 512 MB RAM PC. Our experiments use 56 standard Solomon benchmarks available at http://web.cba.neu.edu/~msolomom/heuristi.htm. Each benchmark instance comprises 100 customers. The location of the customers and the depot are given in a Cartesian coordinate system. The set of benchmark instances provides a variety of instances in terms of constraint tightness. (See [7] for their full description).

A. Comparing to Best Published Results The 56 Solomon instances are categorized into 6 classes, namely

C1, C2, R1, R2, RC1 and RC2. Experimental results show that our algorithm was able to obtain the route minimizations for 47/56 benchmark problems (i.e. 84%) and obtain travel cost minimization

after minimizing the number of vehicles in 32/56 benchmark problems (i.e. 57%). In 5 from 56 instances, our algorithm produces better results than the best published results.

B. Comparing the Performance of Tabu Search in two cases: with or without Constraint Propagation. The experimental results in Table 1 report the performances of our

Tabu Search in two cases: (1) Tabu Search with Constraint Propagation, (denoted as TS+CP) (2) Tabu Search without Constraint Propagation, (denoted as TS). In the test runs, we use the number of iterations in Tabu Search equal to 12000.

The columns on the left part of Table 1 give the results in case TS+CP. Column labeled Avg. number of neighbor solutions gives the average sum of neighbor solutions obtained from the application of move operator on the current solution in all iterations with all test runs (notice that these solutions may violate some constraints of the problem). Column labeled Avg. number of feasible solutions gives the average sum of feasible neighbor solutions obtained from the application of move operator on the current solution in all iterations with all test runs. The column labeled Ratio_1 is computed by the following formula:

Ratio_1 =solutionsneighborfeasibleofnumberAvg

solutionsneighborofnumberAvg..

.

Ratio_1 indicates how constrained a problem instance is by evaluating for a given solution the proportion of the neighbors which are feasible.

The column labeled Avg. run-time gives the average run times of the case TS+CP in all the test runs. For the benchmark group RC2, each instance requires a runtime about 8 minutes using TS+CP.

Similarly, the columns on the right part of Table 1 give the results in the case TS. Column labeled Avg. number of neighbor solutionsgives the average sum of neighbor solutions obtained from the application of move operator on the current solution in all iterations with all test runs (notice that these solution may violate some constraints of the problem and without using constraint propagation to reduce the size of the neighborhood). Column labeled Avg. number of feasible solutions and column labeled Avg. run-time have the same meanings as the corresponding columns of the case TS+CP.

We can see that constraint propagation technique works very well in the benchmark group R2. It also works well for the benchmark groups C2, R2. The reason is that the cost to remove the neighbor customers which cause constraint violations is remarkably smaller than that of the processing of all the neighbor customers to select a best one for the next iteration. In other words, since the number of customers in each route is quite large, constraint propagation can reduce so many candidate customers very quickly. From the experimental results, we can see that Ratio_1 in the case TS+CP is always smaller than Ratio_2 in the case TS. In average Ratio_1 in the case TS+CP is less than half of Ratio_2 of the case TS. In addition, the average run time in the case TS+CP is smaller than that of the case TS. Particularly, for the problem R208, the average run time of TS+CP can reduce 32%.

TABLE I. COMPARING PERFORMANCES OF OUR ALGORITHM IN TWO CASES: TS AND TS+CP (SOLOMON BENCHMARK GROUP R2)

Problem

With constraint propagation Without constraint propagation

Avg. number of neighbor solutions

Avg. number of feasible solutions Ratio_1 Avg. run-

time (sec) Avg. number of

neighbor solutions Avg. number of

feasible solutions Ratio_2 Avg. run-time (sec)

R201 188525184.1 3432592.3 54.9221 175.4 679895066.4 3545319 191.773 217.6

R202 308639228.8 17662590.6 17.4742 233.8 783369682.7 19216457.9 40.7656 282.8

R203 471784602.1 28294019.9 16.6744 541.9 1044519043 29848670.5 34.9938 606.7

R204 685747395.9 31664907.3 21.6564 805.8 1085160517 47457351.8 22.866 903.2

R205 316311209.9 4534989.4 69.7491 425.6 913355937.1 4666610.2 195.721 526.5

R206 440827236.6 20403583.3 21.6054 525.8 1006996324 23587078 42.6927 608.1

R207 612208991.2 39824803.7 15.3726 514.3 1096268880 42586338.2 25.7423 626

R208 709057332.4 13610696.4 52.0956 1759.3 1360288531 18789403.6 72.3966 2610.2

R209 458699765.3 9552498.4 48.0188 577.7 1019979282 10934892.5 93.2775 620.8

R210 411848892.1 15599218.1 26.4019 484.3 1004866937 16478832.6 60.9793 553.9

R211 866641288.9 11681846.7 74.187 507.4 1078864624 3025615.1 356.577 757.8

REFERENCES

[1] R. Bent, and P. V. Hentenryck, “A Two-Stage Hybrid Local Search for the Vehicle Routing Problem with Time Windows”, Transportation Science, 38:515-530, 2004.

[2] J. F. Cordeau, G. Desaulniers, J. Desrosiers, M.M. Solomon, F. Soumis, “Vehicle Routing Problem with Time Windows”, In Toth, P. and Vigo, D. (editors), The Vehicle Routing Problem, Monographs on Discrete Mathematics and Applications, S.I.A.M., Philadelphia, PA, 2002.

[3] S. Csiszar, “Two phase Heuristic for the Vehicle Routing Problem with Time Windows”, Acta Polytechnica Hungarica, Vol. 4, No. 2, pp 143-156, 2007.

[4] B. De Backer, V. Furnon, P. Kilby, P. Prosser, and P. Shaw, “Solving Vehicle Routing Problems using Constraint Programming and Metaheuristics”, Journal of Heuristics, Volume No., 1-16 , 1997.

[5] J. Homberger, H. Gehring, “Two Evolutionary Metaheuristics for the Vehicle Routing Problem with Time Windows”, INFOR, 37: 297-318, 1999.

[6] P. Shaw, “Using Constraint Programming and Local Search Methods to Solve Vehicle Routing Problems”, Proc. of Principle and Practice of Constraint Programming – CP98, Pisa, Italy, Oct. 1998.

[7] M.M. Solomon, “Algorithms for the Vehicle Routing and Scheduling Problem with Time Window Constraints”, Operation Research, 35:254-265, 1987.