A Tabu Search Algorithm for a Capacitated Clustering Problem

Sudha Khambhampatia, Prasad Calyamb and Xinhui Zhanga∗a Department of Biomedical, Industrial and Human Factors Engineering,

Wright State University,3640 Colonel Glenn Hwy, Dayton, OH 45435, USA

Email: sudha.khambhampati@gmail.comEmail: xinhui.zhang@wright.edu

∗Corresponding Author

b Department of Computer Science,University of Missouri,

221 Engineering Building West, Columbia, MO 65211, USAEmail: calyamp@missouri.edu

Abstract

This paper investigates a clustering problem in a production and routing environment wherea centralized facility uses a fleet of vehicles to serve a set of customers. A multi-period capac-itated clustering problem is solved to partition customer into clusters with constraints that theaccumulated customer demand in every period of the planning horizon is satisfied. The resultingmathematical model is hard to solve exactly and efficient heuristics are thus developed in this paper.

The heuristics are based on the tabu search but include two novel features in the design ofneighborhood search; the first one is the dynamic combination of customers with close proximityinto supernodes to eliminate ineffective moves and the second one is an ejection chain approach toperform composite moves of variable length from a series of simple moves. Computational resultsshowed that they were able to provide superior solutions, especially in certain cases of tight capacityconstraints.

Keyword: Capacitated Clustering, Heuristics, Supernode, Ejection Chain, Tabu Search

Biographical notes: Sudha Khambhampati is a software engineer at Veterans United HomeLoans. Her current research interests include agile engineering and multi-tier process optimization.

Prasad Calyam is an assistant professor in the Department of Computer Science at Univer-sity of Missouri-Columbia. His research interests include real-time system scheduling, resourceoptimization, and performance engineering.

Xinhui Zhang is a professor in the Department of Biomedical, Industrial and Human FactorsEngineering at Wright State University. His research interests include data mining, simulationand optimization and their applications in manufacturing, logistics and transportation, and serviceoperations.

1

1 Introduction

The clustering problem is to partition objects such as customers into clusters with an objectiveto maximize some measure of similarity or closeness of the objects in the cluster. The problemhas various applications such as the uncapacitated clustering problems in customer segmentation[Kaufman and Roussweuw, 1990] and market based analysis [Cheng et al., 2014], the capacitatedclustering problems in sales force territory design [Mulvey and Beck, 1984], and the design ofdelivery routes in logistics operations [Koskosidis and Powell, 1992, Bard and Jarrah, 2009].

In logistics operations, one of the fundamental problems is concerned with the optimal allocationand routing of vehicles to visit a set of customers over a planning horizon. Due to its complexity,the problem is typically solved sequentially in practice. In the first stage, a clustering problem issolved to partition customers into clusters. In the second stage, a detailed vehicle routing problemis solved to minimize the sum of the route lengths. This approach is adopted in the solution of thelocation routing problem [Barreto et al., 2007], the vehicle routing problem [Koskosidis and Powell,1992], and pickup and delivery route formations [Jarrah and Bard, 2012, Bard and Jarrah, 2013].These applications have also generated various types of capacitated clustering problems (CCP)from the typical p-median and p-centroid capacitated problems to capacitated clustering problemswith a host of capacity and geometric constraints.

In this paper, we investigate a variant of the capacitated clustering problem for a productionand routing problem [Adulyasak et al., 2015]. The production and routing problem connects thelot-sizing problem and the vehicle routing problem and is of practical relevance to vendor managedinventory. Specifically, suppliers monitor the customers’ inventory, coordinate productions at cen-tral facilities and deliver products to customers over a planning horizon. Each customer’s demandin each period must be satisfied through delivery or inventory and no shortage is allowed [Mourgayaand Vanderbeck, 2007, Boudia et al., 2007, Adulyasak et al., 2015]. Following the logic of ‘clusterfirst route second’, a cluster problem can be modeled as a nonlinear integer program; the problemnevertheless differs from the standard capacitated cluster problems due to the capacity constraintsthat stipulate that the accumulated customer demand in every period of the planning horizon issatisfied. The problem is difficult to solve using exact methods, thus in this paper we have devel-oped efficient algorithms based on the tabu search method to provide near optimal solutions in areasonable amount of time.

The algorithms bring several novel features in the design of neighborhood search operationsthat have achieved superior performance. First, we introduce the “supernode” concept and dynam-ically combine customers with close proximity into supernodes in the neighborhood search process.While traditional neighborhood search applies to the movement of single customers, supernode-based neighborhood search applies to the movement of a set of customers. It reduces the size of theneighborhood, eliminates ineffective evaluations, and accelerates the convergence of the algorithm.Second, we developed a supernode-based ejection chain approach to perform a variable number ofcomposite moves from a series of simple shift moves. The ejection chain methods use referencestructures to represent incomplete solutions and have been particularly useful in capacitated prob-lems. Computational results from a variety of multi-period customer demand instances have shownthat the algorithms were able to quickly provide superior solutions. The supernode-based tabusearch algorithm was able to obtain better results two to three times faster than the standard tabusearch algorithm. Also, the supernode-based ejection chain algorithm has performed particularlywell in certain cases with tight capacity constraints where the standard tabu search algorithm couldnot even get feasible solutions.

2

The rest of this paper is organized as follows: Section 2 presents a detailed literature review.Section 3 formally describes the problem and its mathematical models. Section 4 presents thedetails of the proposed heuristics. Section 5 lists the computation results and discusses salientobservations. Section 6 concludes the paper and presents future work.

2 Literature Review

Before we present our model, let us first look at the classic capacitated clustering problems. Mulveyand Beck [1984] proposed one of the first models for the CCP with a p-median objective in thecontext of political districting. The p-median CCP minimizes the sum of the distances between thecustomers and the cluster center, also known as the median, and the p-centroid CCP, the sum ofdistances between the customers and the centroid. Rather than minimizing the distance betweenthe customers and the centroid (or median), yet another variant of the CCP is to minimize the sumof the distances of customers in the clusters and is defined below [Bard and Deng, 2011].

Let N be the set of customers indexed by i, K be the set of clusters indexed by k, zi be thelocation of customer i, and wij be the distance between customers i and j. Let us define xik asthe decision variable representing whether customer i is assigned to cluster k or not, the classic(uncapacitated) clustering problem can be formulated as follows.

Minimize∑i,j∈N

∑k∈K

wijkxikxjk (1)

Subject to∑k∈K

xik = 1, ∀ i ∈ N (2)

xik ∈ {0, 1} ∀ i ∈ N, k ∈ K (3)

Here, constraint (2) stipulates that each customer is assigned a cluster and constraint (3) stip-ulates that variable xik is binary. The objective (1) is to minimize the sum of the distance betweencustomers in the cluster and is similar to the quadratic assignment problem [Cordeau et al., 2006].

To linearize the objective function, let us define yijk as the decision variable representing whethercustomers i and j are both in cluster k or not, then we have

Minimize∑i,j∈N

∑k∈K

wijyijk (4)

Subject to∑k∈K

xik = 1, ∀ i ∈ N (5)

yijk ≤ xik, yijk ≤ xjk, ∀ i, j ∈ N, k ∈ K (6)

yijk ≥ xik + xjk − 1, ∀ i, j ∈ N, k ∈ K (7)

xik ∈ {0, 1} ∀ i ∈ N, k ∈ K (8)

Constraints (6) and (7) define yijk = xikxjk, specifying whether customers i and j are in clusterk or not. Because x is either 0 or 1, y will automatically be either 0 or 1, and hence this is notexplicitly specified. In the uncapacitated version, as seen above, there is no limit on the capacityof the cluster. In the capacitated version, each customer is associated with a demand di and thecluster is bounded by a capacity Q, the following constraint is thus needed for the model.

3

∑i∈N

dixik ≤ Q, ∀ k ∈ K (9)

The capacitated clustering problems are NP-hard and have sparked many research studies.These studies include exact methods such as branch and bound algorithm with reformulationtechniques, column generation approaches, cutting planes, and heuristic algorithms such as greedyrandomized adaptive search procedure, tabu search, genetic algorithm and scatter search et al. Fora classification of the clustering problems, their complexity and solution approaches, please see[Hansen and Jaumard, 1997, Bard and Deng, 2011].

Exact methods: Grotschel and Wakabayashi [1989, 1990] proposed a formulation with triangleconstraints. Their results showed that the linear relaxation of these triangle constraints gave agood representation of the clustering problem. Scheuerer and Desai [2003] developed a special-ized branch-and-bound algorithm based on the reformulation of the linearization technique. Thereformulation provided tight lower bounds and several cutting planes were utilized to strengthenthese bounds. Mehrotra and Trick [1998] and Mourgaya and Vanderbeck [2007] proposed columngeneration algorithms to the clique clustering problem; The former is based on the solution of aseries of maximal weight clique partitioning problems; the latter investigated truncated columngeneration with approximate solutions followed by a rounding procedure.

Heuristic methods: Al-Sultan and Khan [1996] provided an early study of the performanceof four heuristics. Recent developments in heuristics include a tabu search algorithm by Francaet al. [1999], GRASP with memory structures by Ahmadi and Osman [2005], a scatter search byScheuerer and Wendolsky [2006], and GRASP with path relinking by Bard and Jarrah [2009].

Most recently, Jarrah and Bard [2012] and Bard and Jarrah [2013] presented a series of analysesfor the capacitated clustering problems with a host of capacity and geometric constraints. Theirapproach was tested on data sets with roughly 6,000 to 45,000 customers and the results suggestedthat cost savings averaging 7.6% could be achieved.

3 Problem Statement and Formulation

The clustering problem studied in this paper arises as a critical part in several studies of integratedproduction and routing problems that are of practical relevance in a vendor managed inventory. Theproduction routing problem jointly optimizes production (the lot-sizing problem) and distribution(the vehicle routing problem) to provide optimal solutions when considering the total system cost,as seen in Kellogg and Frito-Lay [Brown et al., 2001, Cetinkaya et al., 2009].

The solution of the production and routing problem is challenging as it incorporates the con-straints of the two difficult problems – the lot sizing problem and the vehicle routing problem. Fordetails on these computational studies, please see [Boudia et al., 2007, Bard and Deng, 2011]; for arecent survey, please see [Adulyasak et al., 2015]. In view of this, a clustering problem that consid-ers the production and distribution environment is proposed. The clustering problem extends theclassic clustering problem to multiple time periods, is subject to accumulated demand constraintsat every time period of a planning horizon, and is presented below.

Let N , K and T be the sets of customers, vehicles and time periods, indexed by i, k and trespectively; each customer i has a demand dit in period t that must be satisfied – no shortageis allowed yet customer demand can be satisfied through inventory. The problem is to partition

4

customers into K clusters, each of which is serviced by a vehicle with capacity Q. Let variablesxik, yijk be defined as before, this multi-period clustering problem can be formulated as follows.

Minimize f(x) =∑i,j∈N

∑k∈K

wijyijk (10)

Subject to∑k∈K

xik = 1, ∀ i ∈ N (11)∑i∈N

∑v∈{1..t}

divxik ≤ tQ, ∀ k ∈ K, t ∈ T (12)

yijk ≤ xik, yijk ≤ xjk, ∀ i, j ∈ N, k ∈ K (13)

yijk ≥ xik + xjk − 1, ∀ i, j ∈ N, k ∈ K (14)

xij ∈ {0, 1} ∀ i ∈ N, k ∈ K (15)

The objective function (10) is to minimize the sum of the distances between the customers in theclusters – a surrogate of the operational route length. Constraint (11) specifies that each customermust be assigned to a cluster. Constraint (12) states that the accumulated demand of customers ina cluster must be satisfied at every time period in the planning horizon and no shortage is allowed.Constraints (13) and (14) state that if customers i and j are assigned to the same cluster k, thenyijk must be one. Finally, constraint (15) states that variable xik is binary.

Our experience with a state-of-the-art branch and bound algorithm shows that it was only ableto solve problems with up to 30 customers and 5 vehicles as given in Boudia et al. [2007]. Real-lifeproblem instances can involve hundreds or thousands of customers, with as many as 20 time periodsand 20 vehicles and are beyond the reach of current exact methods [Mourgaya and Vanderbeck,2007]. To provide near optimal solutions in a reasonable amount of time, a series of tabu searchalgorithms have been developed in this paper.

4 Tabu Search Algorithms

Tabu search is a metaheuristic based upon local search and uses memory in the form of tabu statusto restrict certain moves in an effort to prevent cycling and to escape from local optima. Tabusearch has been extensively used in the solution of hard combinatorial optimization problems; fordetails, please see [Glover and Laguna, 1997].

The design of appropriate local search operations is problem-specific and crucial to the success ofmetaheuristic algorithms, and thus deserves much consideration. To this end, this paper presents:(a) a supernode-based tabu search heuristic that aggregates customers into supernodes to reduceineffective moves in the case of loose capacity constraints, and (b) a supernode-based ejection chainapproach that forms powerful composite moves from a series of simple moves in the case of tightcapacity constraints.

4.1 The Baseline Tabu Search

To start, let us first look at a baseline tabu search algorithm that shares many features with the basictabu search utilized in [Yagiura and Ibaraki, 2004] for the quadratic assignment problem. In thealgorithm, a solution to a clustering problem is represented by a vector x := [x1, . . . , xi, . . . , x|N |],

5

where xi represents the index of the cluster customer i belongs to, and the algorithm iterativelysearches for better solutions in the neighborhood of x, referred to as N(x), until no better solutionis found in N(x).

Two types of neighborhoods, a shift neighborhood Nshift and a swap neighborhood Nswap,are extensively used in the literature and adopted in the algorithm. The shift neighborhood de-fines the set of solutions that are obtained by changing the assignment of a customer, and theswap neighborhood, the set of solutions that are obtained by exchanging the assignments of twocustomers.

When the search visits the infeasible region, we employ an strategic oscillation approach andevaluate the solutions by an objective function penalized by infeasibility to guide the search intofeasible regions. Here the following objective function is used:

f ′(x) = f(x) +∑

k∈K∑

t∈T βktpkt(x)

where

pkt = min(0, tQ−∑

i∈N ditxik) and βkt > 0

The parameters βkt, (> 0) can be given as fixed constants or adaptively calculated [Yagiura andIbaraki, 2004]. In our implementation, βkt is initially set to a large value in an effort to get feasiblesolutions. As the search progresses, if the current solution is feasible, then we decrease β (multiplyitself by 0.5); otherwise, we increase β (multiply itself by 1.5).

K-means Algorithm: The construction of a high-quality initial solution is very important forheuristics because it tends to result in superior final solutions than when a lower-quality initialsolution is used. Based on the studies in [Al-Sultan and Khan, 1996, Bard and Deng, 2011], theK-means algorithm is used to generate the initial solutions. The algorithm is composed of thefollowing steps: (1) place K points or seeds as the cluster centroids; (2) assign each object tothe cluster that has the closest centroid; (3) when all objects have been assigned, recalculate thepositions of the centroids; (4) repeat 2 and 3 until the centroids no longer change and output theclusters. Of the various methods to generate the seeds (as the centroids), a sequential method isadopted to start the K-means algorithm; for details, please see [Al-Sultan and Khan, 1996].

The baseline tabu search starts from the K-means solution and performs in the aforementionedshift and swap neighborhoods for better solutions. For shift neighborhoods, when a customer ismoved from one cluster to another, the shift of the customer is prohibited (declared as tabu) for θ it-erations; similarly, for swap neighborhoods, when two customers exchange assignment, the exchangebetween these two customers is prohibited (declared as tabu) for τ iterations. The algorithm stopsafter a pre-determined number of iterations ϕ is reached and the best solution found is returned.These parameters are dynamically adjusted similar to βkt; for details, please see [Khambhampati,2008]. For more procedures on dynamic setting of parameters in the case of a general assignmentproblem, please see [Yagiura and Ibaraki, 2004].

4.2 Supernode-based Tabu Search

The motivation for supernodes is that the shift and swap moves are performed one customer ata time; yet in the solution of a clustering problem, it would be desirable to move two or morecustomers if they are close to each other as customers with close proximity are likely to be inthe same cluster. To perform such an operation under single customer based local search would

6

require multiple shift moves in sequence, one for each customer. Intuitively, if these customers arecombined to form a supernode, only one shift move of the supernode is sufficient to obtain the sameresult from multiple shift moves of single customers.

The concept of supernodes is similar to the concept of cohesive locations used in [Cordeauet al., 2006] for solving the quadratic assignment problem and the idea of core cluster proposedin [Nananukul, 2013]. In our implementation, a supernode has two characteristics: first, it isdynamically formed during the search process; second, its size depends on a parameter ψ, whichmeasures the proximity of customers to be included. A supernode can be treated as a single nodehaving a centroid as its location and the sum of the capacities of all of its nodes as its capacity.

For each cluster k ∈ K, there could be m supernodes. Let SNk = {SNk1, . . . , SNkq,. . . , SNkm}be the supernodes of customers in cluster k, and αkq and NCkq denote the centroid and the numberof customers in supernode SNkq, respectively. The supernodes {SNk1, . . . , SNkq, . . . , SNkm} inthe cluster k are constructed sequentially as follows:

A random customer in a cluster is initially designated as an independent node. For the nextcustomer, the distance of the customer to the independent node is computed. If this distance iswithin a threshold value ψ, then both customers are grouped together into a supernode and thecentroid of the supernode is computed. Otherwise, the customers remain as independent nodes.The supernode construction process is repeated to obtain larger supernodes with updated centroids,or independent nodes. If the distance of a customer to more than one supernode centroids is withinψ, then the customer is grouped into the supernode that has the shortest centroid-to-node distance.This process repeats until all of the customers in the cluster have been evaluated and is formallydescribed in the Supernode Construction procedure.

Neighborhood Search: After the supernodes have been constructed, neighborhood search isperformed using moves of the supernodes instead of individual customers. The neighborhoodis limited to shift moves of supernodes, defined as the set of solutions obtained by removing asupernode SNkq from its current cluster Ck and inserting it into another cluster, as follows.

Let δq be the savings obtained by removing a supernode SNiq from its current cluster Ci andinserting it into cluster Cj . A positive value of δq indicates an improvement in the solution, whereasa negative value of δq indicates a degrading solution. We use the best admissible strategy to evaluatethe moves. The move where the supernode is non-tabu and which produces maximum cost savingsis accepted whether or not it produces any improvement over the current best solution N(S)∗.

In the process, when a supernode is moved from one cluster to another, the customers in thesupernode are declared tabu for θ iterations. The algorithm stops after a pre-determined numberof iterations ϕ are reached and the best solution found is returned. This procedure is formallydescribed in the Supernode-based Tabu Search algorithm.

Example: The supernode-based neighborhood search can be illustrated using an example shownin Figures 1(a)-(d). In Figure 1 (a), customers close to each other are grouped together intosupernodes in cluster C4. This results in cluster C4 having three supernodes SN41, SN42 and SN43

with centroids α41, α42, and α43, respectively. In Figure 1(b), customers x4 and x9 are now groupedwith the existing supernodes and the distances of these two customers to the centroids α41, α42

and α43 are computed. Since the distance of x4 to supernode SN42 is within the threshold, x4 isgrouped into SN42. However, the distance of x9 to the centroids of any of the supernodes is notwithin the threshold value. Hence, x9 remains as an independent node. The final construction ofthe supernodes of customers within cluster C4 is shown in Figure 1(c). After these supernodes areconstructed, the shift operation is performed between the clusters, see Figure 1(d). In this scenario,the supernode SN41 can be inserted into either cluster C1, C2 or C3. The shift operation on SN41

7

Procedure Supernode Construction

1: Input: Current solution S2: Output: Supernodes of customers in each of the L clusters3: begin procedure4: for i in 1. . . L do5: m = 1 /* Initialize the supernode index */6: Randomly choose xi ∈ Cl ∀ i in 1 . . . N7: SNl= ({xi}) /* Initialize the set of supernodes */8: for i in 1. . . N and xi ∈ Cl do9: /* Compute the distance of customers to existing supernodes */

10: for q in 1. . .m do11: Compute the distance diq of customer xi to centroid of existing supernode αlq

12: if(diq < ψ) then13: Add SNlq into List14: /* List keeps track of supernodes to which the customer’s distance is within ψ */15: end if16: end for17: if(List eq NULL) then18: /* Assign customer as an independent node */19: Increment m20: Assign xj to SNim

21: Compute αlm

22: else23: Assign xi to the closet supernode SNlq in List based on distance diq24: SNlq = SNlq ∪ xi25: Update αlq =

∑xi∈SNlq

xiNClq

∀i in 1 . . . N

26: end if27: end for28: end for29: end procedure

8

Algorithm Supernode-based Tabu Search

1: Input: Initial Solution S from K-means Algorithm2: Output: Best Solution S∗

3: begin procedure4: while (η ≤ ϕ) do5: /* Compute the supernode to be shifted for each cluster */6: for cluster l in 1. . . L do7: Generate supernodes using Supernode Construction Algorithm8: f(N(S)∗) = ∞ /* Initialize the best objective in the neighborhood */9: for q in 1. . .m do

10: /* Remove supernode SNlq from its current cluster Cl with m supernodes */11: dropq =

∑xi∈SNlq

xi ∀i in 1 . . . N12: Find the best vehicle v to insert into SNlq

13: /* Compute the cost of this insertion */14: addq =

∑xi∈Cv

xi +∑

xi∈SNlqxi ∀i in 1 . . . N

15: /* Compute savings δq obtained by removal of SNlq from Cl, and insertion into Cv */16: δq = addq - dropq17: end for18: Compute the supernode SNlq that obtains maximum cost savings19: δq and customers in SNlq that are non-tabu ∀q in 1 . . .m20: Derive modified solution Nl(S) by removal of SNlq from Cl and insertion into Cv

21: Compute f(Nl(S))22: if(f(Nl(S)) < f(N(S)∗)) then23: N(S)∗ = Nl(S)24: end if25: Accept the best solution N(S)∗ in the neighborhood26: Set tabu status of customers moved to tabu tenure27: if(f(N(S)∗) < f(S)∗) then28: /* Update the best solution so far */29: S = N(S)∗

30: f(S)∗ = f(N(S)∗)31: S∗ = N(S)∗

32: η = 0 /* Reset the iteration counter */33: else34: S = N(S)∗

35: η = η + N /* Increment the iteration counter */36: end if37: return f(S)∗

38: end for39: end while40: end procedure

9

Figure 1: An example of shift with supernode algorithm - (a) grouping customers into supernodes,(b) grouping customers into supernodes based on vicinity threshold (c) final supernodes of customerswithin a cluster, (d) shift of supernodes between clusters

results in insertion of SN41 into cluster C3, which produces an optimal insertion relative to thecostly C1 and C2 cluster insertions.

4.3 Supernode-based Ejection Chain Algorithm

The shift and swap moves are special cases of λ exchange neighborhood searches with λ = 1and λ = 2 respectively; as such, it is natural to ask whether it is possible to adopt large sizeneighborhoods. However, as λ increases so does the size of the neighborhood. As a trade off,ejection chains, an approach that combines several simple moves to form a compound move in amanageable neighborhood, has been proposed [Glover and Laguna, 1997].

In the construction of an ejection chain, two moves, ejection moves and trail moves, are alter-nately executed. The ejection move refers to the ejection of a supernode SNlq from its currentcluster Cl to generate an incomplete solution, where supernode SNlq remains free. Such a solutionis called the reference structure. This triggers another supernode from a different cluster to bemoved to the cluster from which a supernode was recently ejected. This results in a sequence ofsimple moves that together form a compound move. The number of ejection moves is referred to asthe length of the ejection chain. Finally, a trail move is to assign the free supernode to some othercluster to make a complete solution.

Figures 2(a)-(d) illustrate a length 2 ejection chain for the clustering problem. Suppose asupernode is ejected from cluster 4, forming a reference structure. This triggers an eject move ofa supernode from cluster 3 to be assigned to cluster 4, and subsequently, another eject move of asupernode from cluster 1 to be assigned to cluster 3. Finally, a trail move is performed in whichthe original ejected supernode from cluster 4 is assigned to a cluster, say cluster 2.

Supernode-based Ejection Chain Search: In our supernode-based ejection chain algorithm, we con-sider three neighborhoods in sequence. The neighborhoods are ejection chains of length 0, 1 and 2,respectively. Ejection chain of length 0 is a “shift neighborhood”, length 1 is referred to as “double

10

Figure 2: a length 2 ejection chain - (a) ejection of supernode from cluster 4, (b) eject movetriggered in cluster 3 to form reference structure, (c) eject move triggered in cluster 1 to formreference structure, (d) trail move of ejected supernode from cluster 4 into cluster 2

shift neighborhood” and length 2 is referred to as a “long chain neighborhood”. During the itera-tions, we use the best admissible strategy which involves accepting the best neighborhood amongshift, double shift and long chain neighborhoods. The supernode-based ejection chain algorithmiterates until no improvement is found for a threshold ϕ iterations.

The supernode-based ejection chain algorithm can be explained for any length as follows: Wefirst eject a supernode SNlq from its current cluster Cl. Consequently, the supernode SNlq becomesfree and the amount of resources available at Cl increase. Given the increased capacity in Cl, weshift another supernode into the cluster from which the first supernode is ejected, thus resulting inan eject move. This eject move is repeated as determined by the length of the ejection chain. Inthe process, a reference structure (partial solution) is created. Finally, a trail move is performedby inserting the free customers in SNlq to an appropriate cluster.

In this process, our supernode-based ejection chain algorithm has three steps. The first step iscalled cost saving procedure, which selects a supernode to be ejected. The second step is called ejectmove procedure, which builds the reference structure by performing eject moves in sequence. Thefinal step is called trail move procedure, which constructs a complete solution. In the following, wedescribe these three steps in detail:

Cost Saving Procedure: The cost saving procedure uses a candidate list strategy to come up withthe best candidates to be ejected from their respective clusters. Ejection of appropriate candidatesreduces the computation effort as opposed to exhaustive evaluation of the ejection of each supernodeindividually. We compute the savings δq obtained by removing a supernode SNlq from its currentcluster and inserting it into another cluster. The supernode that produces maximum cost savingswould be considered as a candidate to be ejected. Thus, the cost savings procedure removes a

11

supernode that has a better fit in a cluster other than its current cluster. After the cost savingsprocedure is executed, we obtain a list CList that contains all the candidates to be ejected. Thisprocedure can be formally described in the cost saving procedure.

Procedure Cost Savings

1: Input: Current Solution S2: Output: Candidate List CList3: begin procedure4: for cluster l in 1. . . L do5: Generate supernodes6: for q in 1. . .m do7: /* Remove supernode SNlq from its current cluster Cl with m supernodes */8: dropq =

∑xi∈SNlq

xi ∀i in 1 . . . N9: Find the best vehicle v to insert into SNlq

10: /* Compute the cost of this insertion */11: addq =

∑xi∈Cv

xi +∑

xi∈SNlqxi ∀i in 1 . . . N

12: /* Compute the savings δq obtained by removal of SNlq from Cl and insertion into Cv */13: δq = addq - dropq14: end for15: Compute the supernode SNlq that obtains maximum cost savings16: δq and customers in SNlq that are non-tabu ∀q in 1 . . .m17: best supernode(l) = SNlq

18: best localdelta(l) = δq19: end for20: Find the supernode SNlq that has the minimum value of best localdelta(l) ∀ l in 1 . . . L21: CList = {xl ∈ SNlq}22: end procedure

Eject Move Procedure: An eject move refers to the shift of a supernode into the cluster from whicha supernode has been recently ejected. The ejection of a supernode from its current cluster Cl

triggers the insertion of another supernode (of a different cluster) into that cluster. Thus, partialsolutions or reference structures are created in this process. We denote the cluster from which asupernode is ejected as ref. When supernodes from other clusters are considered for insertion intoref, we choose only the supernode whose cost of insertion into ref is minimal. To prevent revisitingof solutions, supernodes moved from their current cluster to ref are not moved from ref in theduration of tabu-tenure. Thus, we only consider ejection moves of supernodes that are non-tabu.This procedure takes as input the cluster ref and inserts the best supernode into ref. The clusterCprev to which the best supernode previously belonged is returned as a reference cluster ref forsubsequent operations. This procedure is formally described in the eject move procedure.

Trail Move Procedure: Trail move involves insertion of free supernodes to a cluster which producesminimal insertion cost. After such trail moves, a complete solution is constructed and this completesthe ejection chain move.The Algorithm: The ejection chain algorithm first ejects a supernode using the cost saving proce-dure. Then, eject moves are performed for the length of the ejection chain. Finally, a trail moveis performed. Starting from a solution S, three neighborhoods N0(S), N1(S), and N2(S) are con-sidered; each corresponds to an ejection chain of lengths 0, 1 and 2, respectively. We use the best

12

Procedure Eject Move

1: Input: Current Solution S2: Output: Reference Cluster ref3: begin procedure4: prev = ref5: /* Remove supernodes from their current cluster for insertion into prev */6: for cluster l in 1. . . L and l <> prev do7: Generate supernodes using Algorithm 38: for q in 1. . .m do9: /* Remove supernode SNlq from its current cluster Cl with m supernodes */

10: dropq =∑

xi∈SNlqxi ∀i in 1 . . . N

11: /* Compute the cost of insertion into prev */12: addq =

∑xi∈Cprev ,xi∈SNlq

xi ∀i in 1 . . . N

13: /* Compute the savings δq by removal of SNlq from Cl and insertion into Cprev */14: δq = addq - dropq15: end for16: Compute the supernode SNlq that obtains maximum cost savings δq and customers in SNlq

17: that are non-tabu ∀q in 1 . . .m, ∀l in 1 . . . L and l <> prev18: best supernode(l) = SNlq

19: best ref = Cl

20: for i in 1. . . N and xi ∈ best supernode do21: Assign xi to prev22: Update current solution S23: tabu eject(xi) = θ24: end for25: ref = best ref26: return ref27: end for28: end procedure

13

admissible strategy and move to the neighborhood N(S)∗, which has the least objective functionvalue. The ejection chain algorithm can be formally described in the supernode-based ejectionchain algorithm.

Modified K-means Algorithm: The K-means algorithm assigns customers to clusters solely basedon their geographic vicinity; however, we have found such solutions quite often are infeasible forproblems with tight capacity constraints. In view of this, we propose a modified K-means algo-rithm that considers both geographic vicinity and complementary capacity. The modified K-meansalgorithm uses the same sequential method to generate the initial seeds, yet is different from the K-means algorithm in two aspects. First, the assignment of customers to the closest cluster center isperformed only if such an assignment causes no capacity violation. Second, the algorithm is stoppedwhen no improvement to the best solution is found after ϕ iterations, rather than no change in thecluster centroids. Because the objective function is dependent not only on the distance but alsoon the capacity limitations, convergence of the K-means clustering algorithm based on centroids isnot effective. For details of the modified K-means algorithm, please see [Khambhampati, 2008]

5 Computational Results

In this section, we present the computation results of our proposed algorithm, the supernode-based tabu search algorithm and the supernode-based ejection chain algorithm. We start first withproblem sets with no capacity limitations and move to problem sets with tight capacities.

Our proposed algorithms have been implemented using the Xpress-MP development environ-ment (Guret, et. al, 2002) running on a PC with the Windows XP operating system, 1.6GHzCPU and 512 MB RAM. For the multi-period customer demands, we use the instances that wererandomly generated by the authors in [Boudia et al., 2007]. These instances are comprised of threesets of 30 instances with 50, 100, and 200 customers respectively, all with 20 time periods T . Otherinputs such as number of vehicles K and the vehicle capacity Q depend on the number of customers,and are calculated as suggested in Boudia et al. [2007].

5.1 Results With Loose Capacity Constraints

Tables 1 - 3 show the computation results of each of the 30 instances with 50, 100 and 200 customersrespectively for three heuristics: (i) the baseline single-node-based tabu search (TSsinglenode) algo-rithm, (ii) the K-means (KMS) algorithm, and (iii) the supernode-based tabu search (TSsupernode)algorithm. For each instance, we present the best solution obtained and the run time (in seconds)for each algorithm.

In addition, we report the average objective value and average time across all cases for eachalgorithm, indicate the total number of best solutions found, and the total number of the bestsolutions exclusively found (mark in bold in the table) by the corresponding algorithm.

The number of iterations ϕ for the TSb and the TSsupernode algorithms is set to N × 50.Consequently, as the number of customers N increases, the iterations increase correspondingly.The tabu tenure θ also depends on the number of customers and is set to 0.1×N . For each of thecustomer sizes, the threshold ψ for grouping customers into supernodes is dynamically calculatedby taking into account the average of the inter-customer distances in the data set.

From the cases with 50 customers shown in Table 1, we can see that the both the baseline single-node-based tabu search TSsinglenode and the supernode-based tabu search TSsupernode algorithmprovide satisfactory results and are able to get the best solutions for 26 and 30 instances respectively.

14

Algorithm Supernode-based Ejection Chain

1: Input: Initial Solution S, length of ejection chain2: Output: Best Solution S∗

3: begin procedure4: while (η ≤ ϕ) do5: level = 06: while (level ≤ length) do7: f(N(S)∗) = ∞ /* Initialize the best objective in the neighborhood */8: CList = supernode SNlq returned by Algorithm 6 that needs to be ejected9: ref = cluster Cl to which the CList customer belongs

10: Nlevel(S) = Modify S by removing CList customers from ref11: /* Perform ejection move for the duration of ejection chain length */12: for j in 1. . . level and level 6= 0 do13: /* Construct a reference structure */14: ref next = return value of eject move invoked with ref and Nlevel(S) inputs15: ref = ref next16: end for17: Nlevel(S) = Perform trail move on Nlevel(S) to construct a complete solution18: Compute f(Nlevel(S))19: if(f(Nlevel(S)) < f(N(S)∗)) then20: N(S)∗ = Nlevel(S)21: end if22: end while23: Accept the best solution N(S)∗ in the neighborhood24: Set tabu status of customers moved to tabu tenure25: if(f(N(S)∗) < f(S)∗) then26: /* Update the best solution so far */27: S = N(S)∗

28: f(S)∗ = f(N(S)∗)29: S∗ = N(S)∗

30: η = 0 /* Reset the iteration counter */31: else32: S = N(S)∗

33: η = η + N /* Increment the iteration counter */34: end if35: return f(S)∗

36: end while37: end procedure

15

The KMS algorithm produces solutions provides solutions with slightly higher objective values thanthe tabu search algorithms for all instances, nevertheless, at a much reduced time. In fact, itssolutions deviate only by an average of 5% from the best solutions. It is, however, most interestingto notice that the supernode-based tabu search TSsupernode algorithm is able to get equal or bettersolutions in all of the 30 cases (4 unique best solutions found by itself); however, this comes withmuch reduced computation time, from an average of 1.91 seconds to 0.91 seconds. We believethis can be credited to the construction of supernodes, and consequently to supernode shifts. Thesupernode allows the movement of multiple nodes in the TSsupernode algorithm as opposed to themovement of individual nodes in the TSsinglenode algorithm, and thus has dramatically reducedineffective move evaluations.

Similar conclusions can be drawn for the cases with 100 customers in Table 2. We can see thatthe single-node-based tabu search is able to get best solutions for 15 cases, and the supernode-basedtabu search is able to get the best solution for 28 cases. The computation time for the supernode-base tabu search TSsupernode algorithm is on average 3.73 seconds, whereas the computation timefor the single-node-based tabu search TSsinglenode algorithm is 12.86 seconds. Solutions producedby the K-means algorithm deviate by an average of only 6% from the best solutions, yet withan average computation time of 0.25 second. As a last note, notice that 14 out of the 20 bestsolutions are found by the supernode-based tabu search TSsupernode algorithm, with only 2 foundby the single-node-based tabu search TSsinglenode algorithm, yet the differences in objective valuesare insignificant (only 1) in these two instances.

For the cases with 200 customers in Table 3, we can see that supernode-based tabu searchTSsupernode still performs the best. It obtains the best solution for 21 instances with an averagetime of 26.76 seconds. This is not surprising as the number of customers increases, it is difficult tofind best solutions in all cases due to the increase in solution space. The K-means algorithm stillperforms the best in computation time with 0.77 seconds and produces results that deviate only byan average of 5% from the best solutions. Interestingly, the performance of the single-node-basedtabu search TSsinglenode algorithm in Table 3 produces best results for 9 instances. However, thesebest solutions are found at the expense of greater computation time. A careful study of the caseswhere the best solutions are obtained by single-node-based tabu search TSsinglenode algorithm, i.e.,instances 5, 8, 13, 14, 16, 18, 20, 25, and 28, shows that the distribution of customers is non-uniform. i.e., there is a sparse population in some regions and dense population in other regions.When the distribution of customers in a region is dense, customers that are very close to each othermay not belong to the same cluster, making the supernode construction ineffective and affectingthe computation results for the supernode-based tabu search algorithm.

To summarize, it can be observed that the supernode-based tabu search TSsupernode algorithmoutperforms the single-node-based tabu search TSsinglenode algorithm – it found the most numberof best solutions and was two to three times faster, especially in cases where customers naturallyaggregate. It can also be observed that K-means algorithm is fast, scalable, and comparable inproviding good solutions (on average only 5% to 7% from the best solutions). Our initial resultswithout K-means as the initial solution lead to unsatisfactory results which suggests that it hassignificantly accelerated the performance of neighborhood search process.

Finally, the superior performance of supernode-based tabu search seems to be attributed to theconstruction and movement of supernodes, which reduces neighborhood complexity and guides thesearch to better solutions, especially in cases where customers naturally aggregate.

16

Table 1: Results with loose capacity constraints for instances with 50 customers

Instance TSsinglenode K-means TSsupernode

Cost Time (secs) Cost Time (secs) Cost Time (secs)

1 4981 1.80 5026 0.09 4981 0.86

2 5137 1.78 5907 0.09 5137 0.95

3 4458 1.80 4458 0.09 4458 0.80

4 5232 2.08 5345 0.09 5232 0.86

5 5108 2.84 5972 0.09 5108 0.91

6 5172 1.81 5238 0.09 5172 0.95

7 5021 1.77 5317 0.09 5021 0.97

8 5177 2.63 5744 0.11 5156 0.91

9 5149 1.66 5274 0.09 5149 0.84

10 5031 2.17 5181 0.09 5031 0.81

11 4990 1.55 5252 0.09 4990 0.86

12 5222 2.19 5290 0.16 5222 0.83

13 5215 1.53 5442 0.11 5215 0.84

14 4977 1.97 5125 0.19 4977 0.83

15 5036 1.61 5262 0.14 5036 0.86

16 4959 1.86 5810 0.09 4959 1.20

17 5625 1.66 5654 0.09 5625 0.81

18 5645 1.70 6356 0.09 5597 0.95

19 5386 1.53 5557 0.13 5386 0.83

20 5332 1.81 5532 0.09 5332 0.84

21 5184 1.61 5365 0.16 5179 0.83

22 4950 1.89 5435 0.09 4950 0.89

23 4687 1.52 4876 0.11 4687 0.81

24 5347 2.17 5080 0.09 4865 0.88

25 5347 2.58 5396 0.09 5347 0.83

26 5232 2.02 5692 0.19 5232 1.07

27 4938 1.92 5070 0.13 4938 0.86

28 5209 1.84 5580 0.14 5209 1.13

29 4923 1.67 5109 0.09 4923 0.92

30 5312 2.24 5560 0.13 5312 1.30

Average 5132.73 1.91 5396.80 0.11 5114.20 0.91

Best Solutions 26 – 0 – 30 –

Exclusive Best 0 – 0 – 4 –

17

Table 2: Results with loose capacity constraints for instances with 100 customers

Instance TSsinglenode K-means TSsupernode

Cost Time (secs) Cost Time (secs) Cost Time (secs)

1 8640 10.74 9072 0.23 8585 4.50

2 8718 12.83 9349 0.23 8701 3.80

3 8272 14.61 8422 0.24 8272 3.20

4 8352 14.50 8721 0.22 8336 4.00

5 8497 10.74 9532 0.28 8482 4.30

6 8463 11.88 9467 0.25 8449 3.40

7 8009 13.77 8528 0.28 8002 3.30

8 8241 11.53 8571 0.25 8241 4.00

9 8237 10.91 8608 0.22 8230 3.30

10 8275 10.72 8981 0.22 8275 3.00

11 8405 18.88 9017 0.27 8405 3.20

12 8133 17.31 8874 0.24 8133 4.20

13 7566 10.94 7963 0.22 7566 3.20

14 8628 10.80 8963 0.27 8629 3.20

15 8543 11.67 8745 0.34 8521 3.20

16 7944 12.53 9933 0.31 7944 3.20

17 8168 11.78 8474 0.22 8056 3.20

18 8482 11.38 9298 0.23 8476 3.90

19 8191 14.97 8632 0.23 8191 3.30

20 8304 14.88 8454 0.22 8304 3.10

21 8473 12.16 8566 0.27 8384 3.50

22 8775 12.55 9421 0.22 8760 4.00

23 8648 12.09 8875 0.28 8597 4.10

24 8677 12.48 9295 0.22 8585 5.20

25 8412 15.75 8782 0.25 8412 4.70

26 8449 11.38 8879 0.25 8449 4.30

27 7839 11.31 8707 0.27 7839 3.90

28 8031 14.41 8378 0.25 8007 4.10

29 8646 11.27 9851 0.25 8647 4.00

30 8435 14.97 9538 0.25 8435 3.60

Average 8348.43 12.86 8929.90 0.25 8330.43 3.73

Best Solutions 15 – 0 – 28 –

Exclusive Best 2 – 0 – 15 –

5.2 Results With Tight Capacity Constraints

Tables 4 - 6 show the computation results of the 30 instances under tight capacity constraints with50, 100 and 200 customers respectively for the following three heuristics: (i) the single-node-basedtabu search (TSsinglenode) algorithm, (ii) the supernode-based ejection chain (EC) algorithm, and(iii) the supernode-based ejection chain with modified K-means (ECK) algorithm. The tables areorganized similar to tables 1 to 3 and thus are not elaborated upon.

From the cases with 50 customers shown in Table 4, we can see that the EC algorithm performs

18

Table 3: Results with loose capacity constraints for instances with 200 customers

Instance TSsinglenode KMeans TSsupernode

Cost Time (secs) Cost Time (secs) Cost Time (secs)

1 19910 75.28 21337 0.73 19774 32.50

2 19933 72.45 20583 0.83 19808 14.90

3 19476 67.08 20481 0.77 19463 32.00

4 19725 86.52 20207 0.69 19680 14.10

5 20091 91.86 20945 0.91 20138 50.00

6 20489 92.49 22600 0.70 20437 37.00

7 21077 73.77 21723 0.70 20827 21.14

8 19370 91.27 20002 0.78 19378 14.50

9 19387 87.39 21210 0.89 19359 36.90

10 20081 41.14 20937 0.75 19874 28.60

11 19917 70.39 20715 0.88 19878 34.30

12 19212 79.58 20657 0.70 19134 21.90

13 19490 73.58 20340 0.84 19588 29.30

14 19357 72.45 20246 0.77 19341 12.60

15 20438 82.67 21798 0.70 20392 18.40

16 20100 75.50 21561 0.69 20107 20.80

17 19933 75.17 21535 0.75 19582 22.50

18 20123 82.78 20898 0.67 20180 23.50

19 19580 78.38 20252 0.89 19580 16.70

20 19850 68.11 21170 0.78 19938 13.80

21 19586 66.05 20429 0.70 19584 19.90

22 20141 84.25 21518 0.78 19971 20.20

23 20196 76.00 21245 0.73 19779 21.60

24 20154 76.95 22447 0.83 20079 54.70

25 19813 101.00 21233 0.70 19816 25.90

26 20150 100.10 21478 0.94 20046 30.36

27 20296 88.20 21249 0.78 20255 15.60

28 19516 71.94 20295 0.69 19539 28.90

29 19790 72.13 20717 0.80 19462 16.20

30 20420 88.31 20897 0.70 20396 74.10

Average 19920.03 78.76 21024.00 0.77 19846.20 26.76

Best Solutions 10 – 0 – 22 –

Exclusive Best 9 – 0 – 21 –

better than the baseline tabu search TSsinglenode algorithm; yet the ejection chain with modifiedK-means ECK algorithm outperforms the other two algorithms. Specifically, 11 best solutions arefound using the TSsinglenode algorithm, and 12 best solutions are found using the EC algorithm,whereas 24 best solutions are found using the ECK algorithm. However, the computation timesrequired for the EC and ECK algorithms are high when compared to the TSsinglenode algorithm.This can be attributed to the evaluation of variable lengths of the ejection chain. It is also interestingto notice that the ECK algorithm produces better solutions over the EC algorithm using almost the

19

same computation time, indicating that the use of the modified K-means algorithm as the initialsolution accelerates the search to find better solutions.

From the cases with 100 customers shown in Table 5, we can see that the ECK algorithmobtains best solutions for 22 instances, which clearly dominates the other two algorithms, wherethe TSsinglenode and EC algorithms obtain best solutions for only 3 and 5 instances, respectively.For the 100 customer instances, we chose stringent capacity limitations to evaluate the performanceof the algorithms. In these extreme cases, the TSsinglenode and EC algorithms failed to produce afeasible solution for 13 and 5 instances respectively (labeled NF in the table), whereas the ECKalgorithm is able to obtain feasible solutions in all cases. For instances where feasible solutions werefound using the TSsinglenode and EC algorithms, the ECK algorithm produces dramatically bettersolutions. However, these solutions are obtained at the expense of higher computation time. Forinstances such as 19, 23, and 28, the TSsinglenode algorithm performs better than the EC and ECKalgorithms. Again, for the above instances, the supernode construction is not effective due to non-uniform distribution of customers. Hence, the TSsinglenode algorithm that examines independentcustomers is more effective.

From the cases with 200 customers shown in Table 6, similarly, we can see that the EC andECK algorithms outperform the TSsinglenode algorithm. The TSsinglenode algorithm produces in-feasible solutions for 5 instances (labeled as NF). However, both the EC and ECK algorithmsproduce feasible solutions for all instances. The ECK algorithm generates the largest number ofbest solutions compared to the TSsinglenode and EC algorithms. Specifically, the TSsinglenode andEC algorithms produce 2 and 4 best solutions, respectively, whereas the ECK algorithm produces24 best solutions. The ECK algorithm produces better results in less computation time indicatingthat the modified K-means algorithm was able to accelerate the search process and contribute tothe superior quality of the final solutions.

To summarize, we can conclude that the EC algorithm is able to obtain better solutions thanthe TSsinglenode algorithm, and the ECK algorithm performs the best. However, the improvementin performance is at the expense of longer computation time. Nevertheless, for problems with tightcapacity constraints, as noted in Yagiura et al. [1998] and [Yagiura and Ibaraki, 2004] and quotedbelow, local search with neighborhood Nshift

⋃Nswap may not have the enough search power.

Consider the behavior of local search in which Nshift⋃Nswap is always used as the

neighborhood. In this case, if the current solution is close to locally optimal, shiftmoves rarely occur, since the cluster to which a customer is shifted usually becomesinfeasible and its penalty increases by a large amount. As swap moves do not changethe number of customers assigned to each cluster, this means that the number of nodesof each cluster is usually fixed at an early stage of the search procedure and will neverbe changed until a locally optimal solution is reached.

It is therefore easy to see why an ejection chain neighborhood is superior to the shift and swapneighborhoods. First, when a customer or a supernode is ejected, it creates an incomplete solution,the reference structure, and thus releases the availability of resources. Second, an ejection chainapproach performs ejection moves of variable lengths and could modify the cardinality of clusters inthe current solution (recall that ejection moves share one cluster between subsequent moves; in thetrail move, the free objective is not necessarily assigned to the clusters from which the last ejectionmove is trigger). As such, ejection chain algorithms provide a powerful and complex neighborhoodstructure around the current solution and are essential to the solution of these problems.

20

Table 4: Results with capacity constraints for instances with 50 customers

Instance TSsinglenode EC ECK

Cost Time (secs) Cost Time (secs) Cost Time (secs)

1 5053 2.34 5056 8.22 5053 7.35

2 5185 2.44 5185 8.44 5185 13.49

3 5056 2.59 4694 12.45 4699 11.64

4 5722 3.08 5429 7.64 5393 9.20

5 5180 2.97 5108 11.56 5108 8.48

6 5217 3.03 5217 7.99 5182 6.88

7 5029 1.94 5029 8.34 5029 8.81

8 5379 2.13 5693 7.41 5299 11.22

9 5602 2.20 5321 9.72 5318 10.68

10 5217 2.36 5231 11.33 5217 9.33

11 5099 2.33 5142 8.53 5089 9.47

12 5365 2.45 5056 8.24 5365 10.38

13 5346 1.99 5390 12.24 5400 8.70

14 5012 2.75 5012 13.17 5012 11.45

15 5207 2.38 5160 12.69 5154 7.89

16 5003 1.95 5003 9.48 5003 10.73

17 6484 3.13 6164 11.61 5812 13.87

18 5727 2.89 5877 11.56 5785 7.69

19 5441 3.66 5441 12.83 5441 11.91

20 5332 2.02 5332 8.19 5332 8.58

21 5317 2.20 5308 9.80 5308 14.09

22 5032 2.86 5065 10.30 5024 8.15

23 4842 3.50 4842 11.99 4837 11.25

24 4899 2.38 4970 8.31 4899 9.86

25 5505 2.61 5609 7.69 5505 10.30

26 5445 3.06 5456 22.63 5404 19.92

27 5171 2.69 5171 11.33 5138 8.06

28 5428 2.44 5411 14.08 5299 8.90

29 5666 2.05 5285 12.91 5109 20.70

30 5674 2.03 5546 7.75 5554 10.66

Average 5321.17 2.55 5273.43 10.61 5231.77 10.65

Best Solutions 11 – 12 – 24 –

Exclusive Best 1 – 3 – 13 –

21

Table 5: Results with capacity constraints for instances with 100 customers

Instance TSsinglenode EC ECK

Cost Time (secs) Cost Time (secs) Cost Time (secs)

1 9368 13.41 8966 104.33 8955 88.40

2 10211 17.94 9295 125.58 9211 66.95

3 NF – 9267 107.02 8963 73.61

4 NF – 9330 68.17 9226 27.27

5 NF – NF – 10807 32.19

6 NF – NF – 10265 63.70

7 8836 16.19 8736 102.23 8891 62.25

8 8891 16.83 8560 102.41 8518 37.83

9 10059 28.99 9654 142.72 9509 73.06

10 9942 25.91 9043 99.88 9970 24.36

11 11242 176.34 9731 41.47 9882 123.98

12 8403 54.64 8306 37.30 8212 14.88

13 8770 40.58 8462 120.16 8750 27.75

14 9561 27.38 10299 73.58 9549 67.94

15 NF – NF – 10588 110.80

16 10599 24.86 8628 122.61 8545 193.90

17 NF – NF – 17120 36.34

18 NF – NF – 8836 66.66

19 9261 31.44 9377 99.08 9769 45.91

20 8780 15.22 8441 63.33 8426 73.06

21 NF – NF – 10824 35.63

22 NF – 24920 58.05 9824 46.56

23 9351 15.59 9364 84.25 9476 274.67

24 NF – NF – 10365 79.73

25 NF – 10627 68.14 9486 53.30

26 9189 14.49 8899 59.09 9238 181.20

27 NF – 9011 80.39 8606 71.38

28 8600 21.13 8913 67.55 8743 181.70

29 NF – NF – 11752 42.30

30 16082 44.58 11834 134.94 10055 107.81

Average – 19.52 – 65.41 – 79.50

Best Solutions 3 – 5 – 22 –

Exclusive Best 3 – 5 – 22 –

6 Conclusion

In this paper, we solved the multi-period clustering problem that arose in recent studies of pro-duction and routing problems. The problem extends the classic capacitated cluster problem dueto accumulated demand constraints at every time period of a planning horizon, is hard to solveand tabu search heuristics are thus proposed. The core of our heuristics has been the developmentof neighborhood search operations; specifically, we extended the standard movement of a single

22

Table 6: Results with capacity constraints for instances with 200 customers

Instance TSsinglenode EC ECK

Cost Time (secs) Cost Time (secs) Cost Time (secs)

1 20556 114.38 20419 547.25 20386 514.77

2 20324 120.48 20030 310.19 19967 207.75

3 20345 99.97 20586 342.13 20259 363.89

4 20434 123.14 20813 256.48 20221 216.70

5 NF – 20348 413.48 20370 339.52

6 NF – 21115 665.41 21515 351.92

7 22531 168.33 21382 303.67 21048 183.69

8 NF – 20196 557.69 20186 327.89

9 19689 196.06 19663 381.88 19657 403.00

10 20453 163.24 20413 320.11 20365 248.47

11 20426 219.69 20503 542.27 20305 750.28

12 19771 270.36 19912 405.20 19406 366.27

13 20405 193.09 20096 471.55 20583 376.13

14 20730 264.16 19994 377.45 19480 249.42

15 66103 129.14 20951 435.52 20939 201.86

16 21188 170.73 20557 670.45 20465 293.22

17 20167 180.63 20064 452.91 20016 255.39

18 21156 209.78 20839 392.45 20784 307.80

19 19874 186.88 20338 900.81 20013 228.30

20 20847 153.83 20189 939.99 20055 359.64

21 20511 180.00 20507 398.36 20160 164.61

22 20850 133.75 20539 561.30 20182 199.63

23 NF – 20112 731.78 20138 193.00

24 20720 157.13 20760 384.86 20655 448.93

25 20345 124.47 20631 346.52 20357 243.02

26 NF – 22031 410.75 20427 353.98

27 20845 198.67 20636 457.05 20586 230.84

28 19976 201.41 20052 385.72 20083 287.50

29 20453 176.84 21784 350.16 20260 187.11

30 21059 138.61 21090 366.41 20733 111.81

Average – 142.49 20551.67 469.33 20320.03 298.88

Best Solutions 2 – 4 – 24 –

Exclusive Best 2 – 4 – 24 –

customer to the movement a group of customers, called a supernode, and developed a supernode-based ejection chain to power the neighborhood search. The algorithms are evaluated on a set ofmulti-period customer demand instances under various capacity constraints and have demonstratedsuperior performance. Though similar supernode concepts and ejection chain approaches have beenproposed in other clustering studies, supernode and ejection chain complement each other in thereduction of the complexity of ejection chains and are combined in this paper to achieve a betterperformance that otherwise could not be obtained when each is applied separately.

23

To extend this work, it is necessary to investigate more advanced features such as: a) adaptiveadjustment of the parameters, such as the size of the supernode (defined by ψ) to create a morerobust approach that is independent of customer distributions; and b) elite solutions and path-relinking to explore characteristics of good solutions. In addition, the study of the cluster solutionsin the production and routing environment is of practical value and deserves much consideration.

Acknowledgments

We would like to thank the anonymous reviewers for their helpful comments; the comments werevery constructive and useful to improve the quality of the paper.

References

Y. Adulyasak, J. Cordeau, and R. Jans. The production routing problem: A review of formulationsand solution algorithms. Computers and Operations Research, 55:141–153, 2015.

S. Ahmadi and I. H. Osman. Greedy random adaptive memory programming search for the capac-itated clustering problem. European Journal of Operational Research, 162:30–40, 2005.

K. S. Al-Sultan and M. M. Khan. Computational experience on four algorithms for the hardclustering problem. Pattern Recognition Letters, 17(3):295–308, 1996.

J. F. Bard and Y. Deng. A reactive grasp with path relinking for capacitated clustering. Journalof Heuristics, 17(2):119–152, 2011.

J. F. Bard and A. I. Jarrah. Large-scale constrained clustering for rationalizing pickup and deliveryoperations. Transportation Research Part B, 43:542–561, 2009.

J. F. Bard and A. I. Jarrah. Integrating commercial and residential pickup and delivery networks:A case study. Omega, 41(4):706–720, 2013.

S. Barreto, C. Ferreira, J. Paixo, and B. S. Santos. Using clustering analysis in a capacitatedlocation-routing problem. European Journal of Operational Research, 179(3):968 – 977, 2007.

M. Boudia, M. A. O. Louly, and C. Prins. A reactive grasp and path relinking for combinedproduction-distribution problem. Computers and Operations Research, 34(11):3042–3419, 2007.

G. Brown, J. Keegan, B. Vigus, and K. Wood. The kellogg company optimizes production, inven-tory, and distribution. Interfaces, 31(6):1–15, 2001.

S. Cetinkaya, H. ster, G. Easwaran, and B. B. Keskin. An integrated outbound logistics model forfrito-lay: Coordinating aggregate-level production and distribution decisions. Interfaces, 39(5):460–475, 2009.

C. K. Cheng, A. Gunasekaran, and K. H Woo. An ant colony optimisation-based approach forclustering in data matrix. International Journal of Operational Research, 19(4):407–434, 2014.

J. Cordeau, M. Gaudioso, G. Laporte, and L. Moccia. A memetic heuristic for the generalizedquadratic assignment problem. INFORMS Journal of Computing, 18(12):433–443, 2006.

24

P. M. Franca, N. M. Sosa, and V. Pureza. An adaptive tabu search algorithm for the capacitatedclustering problem. International Transaction in Operational Research, 6:665–678, 1999.

F. Glover and M. Laguna. Tabu Search. Kluwer Academic Publishers, 1997.

M. Grotschel and Y. Wakabayashi. A cutting plane algorithm for a clustering problem. Mathemat-ical Programming, 45:59–96, 1989.

M. Grotschel and Y. Wakabayashi. Facet of the clique partitioing polytope. Mathematical Pro-gramming, 47:367–387, 1990.

P. Hansen and B. Jaumard. Clustering analysis and mathematical programming. MathematicalProgramming, 79:191–215, 1997.

A. I. Jarrah and J. F. Bard. Large-scale pickup and delivery work area design. Computer andOperations Research, 39(12):3102–3118, 2012.

L. Kaufman and P. Roussweuw. Finding Groups in Data: An Introductory to Cluster Analysis.Wiley, 1990.

S. Khambhampati. A tabu search heuristic for multi-period clustering to rationalize delivery op-erations. Master thesis, Industrial and Human Factors Engineering, Wright State University,Dayton OH, 2008.

Y. A. Koskosidis and W. Powell. Clustering algorithms for consolidation of customer orders intovehicle shipments. Transportation Research Part B, 26(5):365–379, 1992.

A. Mehrotra and M. A. Trick. Cliques and clustering: A combinatorial approach. OperationsResearch Letters, 22:1–12, 1998.

M. Mourgaya and F. Vanderbeck. Column generation based heuristic for tactical planning in multi-period vehicle routing. European Journal of Operational Research, 183(3):1028–1041, 2007.

J. M. Mulvey and M. P. Beck. Solving capacitated clustering problems. European Journal ofOperational Research, 18:339–348, 1984.

N. Nananukul. Clustering model and algorithm for purduction inventoy and distribution problem.Applied Mathematical Modelling, 37:9846–9857, 2013.

H. D. Scheuerer and J. Desai. A global optimization rlt-based approach for solving the hardclustering problem. Journal of Global Optimization, 32(2):281–306, 2003.

S. Scheuerer and R. Wendolsky. A scatter search heuristic for the capacitated clustering problem.European Journal of Operational Research, 169:533–547, 2006.

M. Yagiura and T. Ibaraki. An ejection chain approach for the generalized assignment problem.INFORMS Journal on Computing, 16(2):133–151, 2004.

M. Yagiura, T. Yamaguchi, and T. Ibaraki. A variable depth search algorithm with branchingsearch for the generalized assignment problem. Optimization Methods and Software, 10(2):419–441, 1998.

25