Download - VLSN Search Algorithms for Partitioning Problems Using Matching Neighbourhoods

VLSN Search Algorithms for Partitioning Problems Using Matching NeighbourhoodsAuthor(s): T. Öncan, S. N. Kabadi, K. P. K. Nair and A. P. PunnenSource: The Journal of the Operational Research Society, Vol. 59, No. 3 (Mar., 2008), pp. 388-398Published by: Palgrave Macmillan Journals on behalf of the Operational Research SocietyStable URL: http://www.jstor.org/stable/30132760 .

Accessed: 28/06/2014 09:00

Your use of the JSTOR archive indicates your acceptance of the Terms & Conditions of Use, available at .http://www.jstor.org/page/info/about/policies/terms.jsp

.JSTOR is a not-for-profit service that helps scholars, researchers, and students discover, use, and build upon a wide range ofcontent in a trusted digital archive. We use information technology and tools to increase productivity and facilitate new formsof scholarship. For more information about JSTOR, please contact [email protected].

.

Palgrave Macmillan Journals and Operational Research Society are collaborating with JSTOR to digitize,preserve and extend access to The Journal of the Operational Research Society.

http://www.jstor.org

This content downloaded from 91.220.202.45 on Sat, 28 Jun 2014 09:00:33 AMAll use subject to JSTOR Terms and Conditions

http://www.jstor.org/action/showPublisher?publisherCode=pal

http://www.jstor.org/action/showPublisher?publisherCode=ors

http://www.jstor.org/stable/30132760?origin=JSTOR-pdf

http://www.jstor.org/page/info/about/policies/terms.jsp


Journal of the Operational Research Society (2008) 59, 388-398 C 2008 Operational Research Society Ltd. All rights reserved. 0160-5682/08 $30.00

www.palgravejou rnals.com/jors

VLSN search algorithms for partitioning problems using matching neighbourhoods T Oncanl, SN Kabadi2, KPK Nair2 and AP Punnen3*

1Galatasaray Universitesi, Ortakiy, Istanbul, Tiirkiye; 2University of New Brunswick, Fredericton, New Brunswick, Canada; and 3Simon Fraser University Surrey, Surrey, British Columbia, Canada

In this paper, we propose a general paradigm to design very large-scale neighbourhood search algorithms for generic partitioning-type problems. We identify neighbourhoods of exponential size, called matching neighbourhoods, comprised of the union of a class of exponential neighbourhoods. It is shown that these individual components of the matching neighbourhood can be searched in polynomial time, whereas searching the matching neighbourhood is NP-hard. Matching neighbourhood subsumes a well-known class of exponential neighbourhoods called cyclic-exchange neighbourhoods. Our VLSN algorithm is implemented for two special cases of the partitioning problem; the covering assignment problem and the single source transportation problem. Encouraging experimental results are also reported. Journal of the Operational Research Society (2008) 59, 388-398. doi:10.1057/palgrave.jors.2602356 Published online 3 January 2007

Keywords: integer programming; combinatorial analysis; VLSN search; partitioning problems; generalized assignment; local search

1. Introduction

Several problems of practical interest, well studied in the operations research literature can be formulated in a com- mon framework as partitioning problems. These include the capacitated minimum spanning tree problem (Ahuja et al, 2003), the graph partitioning problem (Kernighan and Lin, 1970), the k-constrained multiple knapsack problem (Ahuja and Cunha, 2005), the airline-crew scheduling problem (Hoff- man and Padberg, 1993), the problem of scheduling n jobs on m non-identical parallel machines so as to minimize the sum of completion times (Pinedo, 1995), and the p-centre and p-median problems (Drezner and Hamacher, 2004). Loosely speaking, a partitioning problem seeks a partition of the space of decision variables such that the 'cost of partitioning' is minimized. Depending on the way one defines the 'cost', partitioning problems are divided into various subclasses such as minmax problems, minsum problems etc. Minsum partitioning problems are perhaps the most well-studied class in the literature. In fact, except the p-centre problem, all the examples discussed above belong to the class of minsum partitioning problems.

A formal definition of the partitioning problem is as follows. Let N = {1,2,...,n} be a finite set and { F1, F2 ..., Fm) } be families of prescribed subsets of N. Let S = (S1,S2, 2 .. Smn) be an ordered partition of N, that is

Ui, Si = N and S, n S = 0 for i : j. We say that the or-

dered partition S is feasible if and only if Si E Fi for all i. For each i = 1, 2 ..., m and X E Fi, a cost function ci(X) is also prescribed. Then the minsum partitioning problem is to find a feasible partition S such that f(S) = L1, ci (Si) is minimum. In this paper, we consider only minsum partitioning problems and hereafter, a partitioning problem means a minsum partitioning problem.

When N is the node set of a complete edge-weighted graph G(N, E) and ci(X) is defined as the value of the smallest Hamiltonian cycle in the subgraph of G induced by X, the resulting partitioning problem is the well-known vehicle routing problem. Later in this paper, we discuss other examples of partitioning problems.

Partitioning problems are inherently difficult combinatorial optimization problems. As a result of the inadequacy of exact methods, heuristic and metaheuristic algorithms are widely used in practice. Very large-scale neighbourhood (VLSN) search algorithms (Ahuja et al, 2002) are known to be very powerful in solving partitioning problems. The concept of cyclic-exchange neighbourhoods (Thompson and Orlin, 1989; Thompson and Psaraftis, 1993) plays a vital role in the design of most of the well-studied VLSN search algorithms (Agarwal et al, 2004; Ahuja et al, 2004a,b). However, find- ing the best member in the cyclic-exchange neighbourhood is an NP-hard problem (Thompson and Orlin, 1989; Thompson and Psaraftis, 1993). Thus, VLSN search algorithms using the cyclic exchange neighbourhoods often employ heuristics or enumerative schemes to search the neighbourhood for an improving solution.

*Correspondence: AP Punnen, 17048, 57th Ave, Surrey, British Columbia, Canada V3S 8M9.

E-mail: [email protected]



T Oncan et a--VLSN search algorithms for partitioning problems using matching neighbourhoods 389

In this paper, we introduce a closely related neighbourhood, called the matching neighbourhood to design VLSN search algorithms for partitioning problems. Various properties of the matching neighbourhood are established along with complexity results. The matching neighbourhood contains the cyclic-exchange neighbourhood and we observe that searching the matching neighbourhood is also NP-hard. Also the transition from one solution to another in the matching neighbourhood is achieved by means of one or more cyclic exchanges involving the movement of one or more items. In the case of a cyclic exchange neighbourhood, such a transition is accomplished by one cyclic exchange, normally by moving one item. We show that a solution S is a local minimum for a partitioning problem with respect to the matching neighbourhood if and only if it is a local minimum with respect to the cyclic exchange neighbourhood. In this sense, the two neighbourhoods are equivalent, although the path to a local minimum could be different in a VLSN search, es- pecially since an improving matching could be composed of several cyclic exchanges. Since both these neighbourhoods are NP-hard, heuristics employed to search the neighbourhoods are different which could also lead to different search

paths resulting in termination of different approximate local optimal solutions. For a discussion of approximate local optimal solutions, we refer to Orlin et al (2004). The matching neighbourhood is designed as the union of simpler neighbourhoods.

Depending on the feasibility restrictions, each of these simpler neighbourhoods itself could be of exponential size. Inter- estingly, we show that these simpler neighbourhoods can be searched in polynomial time by solving a weighted bipartite matching problem (Lawler, 1976).

To illustrate our VLSN search algorithms for partitioning problems, we consider two special cases: the covering assignment problem (CAP) and the single source transportation problem (SSTP). Given n factories with non-negative demands al, a2,. an and m suppliers with non-negative supply quantities bl, b2 ..., bm, the classical transportation problem is to find a shipping plan so that the total shipping cost is minimized while supply and demand constraints are satisfied. The cost dij represents the shipping cost of one unit from supply point i to a demand point j. We assume that dij 0. A variation of the transportation problem is the SSTP where the demand points must be served by exactly one supplier. This problem can be mathematically formulated as

mi n

min dijYij (1) i=1 j=l n

s.t. Zyij bi i =1 ..

m (2) j=1

yij= aj j= 1

.... n (3)

i=1 (4) Yij = 0 or aj Vi, j (4)

where decision variable yij stands for the quantity supplier i supplies to factory j. Using the transformation Yij =ajxij and

cij = dijaj, we get an alternative formulation of the SSTP as

inn

min Z c 1xij (5) i=1 j=1

n

s.t. Laixij<bi

i= 1,..., m (6) j=1

m

xij = 1 j = 1 ...

n (7) i=1

xij = 0 or 1 Vi, j (8)

Hence, the SSTP can be considered as a special case of the well-known generalized assignment problem (GAP) (Martello and Toth, 1990). Thus, the SSTP can be solved using any heuristic or exact algorithm for the GAP.

To the best of our knowledge, the SSTP was first discussed by DeMaio and Roveda (1971) and investigated later by Srinivasan and Thompson (1973). In both of these papers, implicit enumeration-based exact algorithms are developed. Although the transportation problem with a fixed number of supply points can be solved in linear time, computing a feasible solution to the SSTP is NP-hard even if m = 2 since the NP-hard subset sum problem (Garey and Johnson, 1979) can be reduced to this problem.

The CAP considered by Foulds and Wilson (1997) is closely related to the SSTP where constraints (6) are changed to '>' type. The CAP is a special case of a variation of the GAP which is not as thoroughly investigated as the GAP. Foulds and Wilson (1997) studied the problem CAP in the context of allocation problems in the New Zealand dairy industry, where the milk demand of dairy companies is sup- plied by different farms. The problem is to find the optimal allocation of farms to factories such that each farm supplies exactly one factory.

Although the difference between the CAP and the SSTP is simply in the direction of the inequalities in (6), it is a significant difference since we assume that the problem data ai, bj and cij are non-negative.

As in the case of the SSTP, computing a feasible solution to the CAP is NP-hard even if m=2 since the NP-hard subset sum

problem (Garey and Johnson, 1979) can be reduced to this problem. However, the problem can be solved in polynomial time if m =n by reducing it to a standard assignment problem.

Both the SSTP and the CAP are special cases of the partitioning problem. In the case of the SSTP, Fi is defined as {Si : Si c N; Ejes aj <bi}, i =1 ...., m and in the case of the CAP, Fi is defined as {Si : Si c N;

L_,jes ajbi), i= 1...m. In each case, for any ordered partition S= (S1, S2 ..., Sm) define xij = 1 if j E Si, i = 1, 2 ..., m and zero otherwise. Then it can be verified that this solution is feasible for the SSTP (CAP) if and only if S is a feasible



390 Journal of the Operational Research Society Vol. 59, No. 3

partition. The element cost functions ci(X) for X E Fi is defined as ci(X)= Cjexcij, i

= 1 ..., m. The major contributions of the paper can be summarized

as follows: A general algorithmic approach is introduced to develop VLSN algorithms for partitioning problems by means of matching neighbourhoods. It is shown that a restricted version of the matching neighbourhood and the well-studied cyclic exchange neighbourhood have the same set of local minima. In this sense, these two neighbourhoods are equivalent and searching each of these neighbourhoods is an NP- hard problem. The different combinatorial structure of these neighbourhoods leads to different heuristics to search these neighbourhoods. The matching neighbourhood could perform multiple cyclic exchanges in one move, whereas cyclic exchange neighbourhood makes one cyclic exchange per move. This could potentially reduce the number of iterations in a VLSN search and may allow additional parallelization op- portunities. The matching neighbourhood is the union of a class of large neighbourhoods. It is shown that each of these component neighbourhoods can be searched for an improving solution in polynomial time. In addition to establishing desirable theoretical properties of the matching neighbourhoods, the approach is tested on two classes of partitioning problems which produced promising experimental results.

The paper is organized as follows. In Section 2, we introduce the matching neighbourhood and investigate its properties. We also introduce a general VLSN search algorithm for the partitioning problems using the matching neighbourhoods. Section 3 deals with application of the VLSN search algorithm to the special cases of the CAP and the SSTP. Com- putational results are given in Section 4 followed by conclud- ing remarks in Section 5.

2. The matching neighbourhood

Let us now define the matching neighbourhoods for the partitioning problem. Our work on matching neighbourhoods is inspired by the work of Punnen (2001) in the context of the travelling salesman problem. For any subset X of N, let ci(X) =

jexcij and a(X) = Zjexaj. Throughout

this paper, we assume that summation over the empty set is zero. Let S = (SI, S2 ..., S,,n) be a given ordered partition of N. Then the cost of S, denoted by C(S), is given by C(S) = L7i ci(Si). For each set Si in S, choose a subset li. Note that

I/ could be the empty set. The ordered collection

I = (II, I2 . I .,

7,) is called an ejection vector of S. Given S and an ejection vector I, we construct a bipartite graph G, called the improvement graph, as follows. The generic bipar- tition of its vertex set is V1 U V2 where VI {=1, 2,..., m} and V2 = {Z1,, Z

.. Zmnl}. Node i in VI represents the subset Si

and node zj in V2 represents the subset Il. A node i in VI is connected to a node zj in V2 by an arc (i, zj) if (Si U Ij)\Ii e

Fi. For example, in the case of SSTP verifying this condition is equivalent to testing if a(Si) - a(l) + a(Ij) bi, that is, node i in V1 is connected to a node zj in V2 by an arc if and

only if a(Si) - a(li) + a(I) o bi. The edge (i, zoj)

signifies adding Ij to Si while i is ejected from Si. The cost of (i, z j) is given by

fij- =

c(i(j) - ci(li)

Note that for each i = 1,2 ... m the arc (i, zi) is in G and

/3i =0.

Let M= {(i, zL(i))i = 1, 2 ..., m} be any perfect matching in G. (G contains at least one perfect matching.) Then S =

(SI, S2 ....

S,,,) is a feasible ordered partition where Si = IUi U Si \Ii, i 1, 2, ..., m. The operation of building S from S is called an M-matching exchange. The simple matching neighbourhood of S with respect to a given ejection vector

1= (11, 12, . . .

In,}, denoted by MI(S), is the collection of all feasible ordered partitions each of which can be obtained by a M-matching exchange from S using some perfect matching M of G.

For example, consider the SSTP with cost matrix

13 14 14 17 13 13 15 14 17 15 17 19 19 13 11 11 20 20 12 14 19 12 15 12 16 14 15 20 13 20 12 15 13 15 13 15 17 17 11 11

supplies (al, a2z,..., alo)=(3, 2, 2, 1, 3, 3, 2, 1,2, 1) and demands (bl, b2, b3, b4)=(10, 6, 8, 3). Let S= (SI, S2, S3, S4) where S1 = {1,3,4, 6}, S2 = {2, 5}, S3 = {7, 8, 9, 10}, and S4 = 0 be a given feasible ordered partition. Consider the ejection vector I = {I1, 12, 13, 4} where II - {4, 6}, 12 = {5}, 13 = {10}, and 14 = 0. The resulting improvement graph G is given in Figure 1.

The minimum cost perfect matching is marked by thick lines. The cost of this matching is -13 and the resulting improved partition is given by S1 = {1, 3, 5}, S2 = (2, 4, 6}, S3 = {7, 8, 9} and S4 = {10}.

Lemma 1 There is a cost preserving one-to-one correspondence between elements of the simple matching neighbourhood Mi(S) of S and perfect matchings in G.

The proof of this lemma is straightforward and hence omitted. The minimum cost perfect matching in G can be computed in O(m3) time (Ahuja et al, 1992; Lawler, 1976).

The size of the matching neighbourhood Mi(S) for a given I could be as large as O(m!) and the best member in this neighbourhood can be identified in O(m3) time (Ahuja et al, 1992; Lawler, 1976) by solving a weighted matching problem on G. Let us now consider a generalization of Mr (S). Let M(S) = U1 Mi(S), that is M(S) is the union of simple matching neighbourhoods corresponding to all possible ejection vectors I. We call M(S) the matching neighbourhood of S. For other ways of generating large neighbourhoods, we refer to Ergun et al (2002). M(S) is of very large size for any collection of moderately dense improvement graphs. This desirable property of very large size of M(S) comes at



T Oncan et al-VLSN search algorithms for partitioning problems using matching neighbouriloods 391

1 0

z1

13

-17

2 0 z2

-4/ /13

-15

3 )-0- 3

Z3 11-

\-30 S-tl \

-20\

4 0 Z4

Figure 1 The improvement graph.

an apparent cost of our ability to search the neighbourhood in polynomial time. This is established in the following Lemma.

Lemma 2 Computing the best member in M(S) is NP-hard for the SSTP and the CAP.

Proof We reduce the NP-hard subset sum problem (Garey and Johnson, 1979) to this problem. The subset sum problem is: Given k positive integers d1, d2 ... dk, find a subset Q of {1, 2... k} such that jeQdj = (L~ild)/2. Given an instance of the subset sum problem, we construct a corresponding instance of the SSTP as follows. Choose n = k + 1, m = 2, aj = d, j = 1 ..., k, ak+1 =

(oo=1ldj)/2; c1j = 0,

j = 1, . . . k, cl,k+l = M, C2j = M, j = 1 ..,.

k and C2,k+1 =O0. Here M is selected as a large number. Set b1 =

(_k ,dj)/2

and b2 = L=ldJ.

Choose S1 = {k + 1}, S2 = {1, 2..., k}.

Any feasible ordered partition (S1, 12) other than (Si, S2) is a strictly better solution. For such a solution, S1 C { 1, 2

...., k} and gives a feasible solution Q for the subset sum problem. Thus, if the best solution in M(S) is (Si1, S2) then the subset sum problem is infeasible. Otherwise, we get a solution to the subset sum problem. The proof for the case of the CAP follows similarly. []

A special case of the matching neighbourhood is obtained by restricting the size of the component sets of the ejection vector to be no more than one. We denote this special

Figure 2 A cyclic exchange.

matching neighbourhood of a solution S by M1 (S). Thus,

M(s) {M(S) I = (/1,/

' 2, , I)&Ii~ 1Vi}.

I

The matching neighbourhood M' (S) is very closely related to the cyclic exchange neighbourhood (Thompson and Orlin, 1989; Thompson and Psaraftis, 1993). Let S = {S1, S2, ..., Sp} be a feasible ordered partition. A cyclic exchange of S selects a collection

{Sti, St2 .. ., Sqq } of subsets from S and moves an element say bi from subset Sqi to subset Sqi+1 for i = 1, 2 .., q where q + 1 = 1. (See Figure 2.) Let S* be the resulting ordered partition. If S* is feasible, then we call the exchange a feasible cyclic exchange. The cyclic exchange neighbourhood of S consists of all feasible ordered partitions that can be obtained by a cyclic exchange of S and is denoted by c(S).

Theorem 3 A feasible ordered partition S is a local minimum with respect to M1 (S) if and only if it is a local minimum

with respect to ((S).

Proof Let S be a feasible solution (ordered partition) and S* an improved solution in (2(S). Suppose S* obtained by a cyclic exchange involving Si+l for i = 1, 2 ..., q and the element moved from Sqi to Srqi+l is say xi. We show that S* E M' (S). Consider the ejection vector I = (11, 12 .

. . Im)

defined by Ii = {xi} for i = 1, 2 ..., q and Ij 1=0 otherwise. (In fact, these Ij's could be selected as any singleton subset if

Sj 0.) Now consider the improvement graph G =(V1, V2) with respect to the ejection vector I. Let V1 = { 1, 2 ..., m} represent SI, S2 ..., Sm and V2 = {Z1, 22

... Zm} represent

the sets l1, 12, ..

/ *m. Consider the matching M* defined by

ri E V1 is matched to zqi+l e V2 for i = 1, 2 ...., q with q + 1

= 1 and the rest are matched by identity. It can be

verified that the partition corresponding to M* is precisely




1 2 3 4 5 6 7

Z1 Z2 Z3 Z4 Z5 Z6 Z7

Figure 3 The matching exchange.

S*. By construction, S* E M' (S) and hence S is not a local minimum with respect to M1 (S).

Conversely, suppose S is an improved solution in M1 (S). Then there exists an ejection vector f = (fl,

,72 . ,i m) where Io1 i 1 for all i and S corresponds to a matching, say M in the improvement graph corresponding to f. This matching can be viewed as a permutation of (1, 2,..., m) which can be written as a product of cycles of the form

(1, 7 .. . "t

* r)(Jr+l .. .

o , s)*... ( ... o,m). (See Figure 3. The given matching corresponds to the

product representation of the permutation (1 3 5)(4 6) (2) (7).) Each such cycle of length more than one represents a cyclic exchange. Since S is improving, at least one of the cyclic exchanges defined above will have negative cost. Thus, we can find an improving solution in c(S) and hence S is not a local minimum with respect to C(S). This completes the proof. OD

Searching for an improving solution in E(S) is NP-hard. Thus, in view of the above theorem, searching for an improving solution in M' (S) is also NP-hard. Another consequence of the theorem is that M'(S) and c(S) are LO-equivalent, a concept closely related to the theory of extended neighbourhoods (Orlin and Sharma, 2004). It can be verified that E(S) C M' (S) c M(S). This underscores the usability of matching neighbourhoods as a tool in developing VLSN search algorithms.

A VLSN search algorithm is a local search algorithm where the underlying neighbourhood is normally of exponential size. Let us now discuss our generic VLSN search algorithm for partitioning problems. It is simply a local search using the neighbourhood M(S) but M(S) is explored for an improving solution using simple heuristics. Thus, when the algorithm terminates, local optimality is not guaranteed. This is com- mon in many successful implementations of VLSN search (Ahuja et al, 2002, 2007). Given a feasible partition S, we assume that a (heuristic) procedure improve(S) is available which with input S searches (approximately) M(S) for an

improving solution and outputs such a solution if obtained. The algorithm terminates when improve(S) fails to detect an improving solution.

The crucial steps of the algorithm are: (1) the construction of an initial solution and (2) the procedure improve(S). Effective implementation of improve(S) often uses information of a specific partitioning problem. For simplicity and def- initeness, for the rest of this paper, we concentrate on the two special cases of the partitioning problem: the CAP and the SSTP.

3. VLSN search algorithms for the CAP and the SSTP

We now consider the procedure improve(S) for the CAP and the SSTP as well as algorithms to obtain an initial solution. Let us first consider improve(S). The task of improve(S) is to search for an improving solution in M(S) and by Lemma 2, developing an efficient algorithm for this seems difficult. But note that a best solution in M(S) is a best solution in MI (S) for some ejection vector I. Further, MI (S) can be searched for a best improving solution in polynomial time. Thus, if we can generate a good enough ejection vector I we are likely to find an improving solution in M(S) if one exists. Thus, we consider some simple rules to generate the ejection vectors. We use two parameters MINIJECT and MAXEJECT. The components of the ejection vector I have cardinality between these parameters. It is possible to set MINEJECT= 0 which opens the possibility of selecting I, = 0 for some component Ir of I and in all our experiments we set MINEJECT- 0 or 1.

3.1. Multi item ejection rules

Random ejection rule: For a given partition S = (Si1, S2 ...

Sm) eject a random subset Ir from each non-empty Sr for r = 1 ... m such that r I = kr, where kr is a random number between MINIJECT and min{ I SrI, MAXIJJECT}. Ir = 0 if Sr = 0.

Maximum cost multi-ejection: In this rule, from each non-empty set Sr for r = 1,...,m we eject a subset I, of kr items of largest cost. Here MINEJECT~ kr o min{ ISrl, MAXEJECT}.

Minimum cost multi-ejection: In the maximum cost multi- ejection rule, if we choose the kr smallest costs instead of largest costs we get the minimum cost multi-ejection rule.

Maximum capacity multi-ejection: In this rule, from each set Sr for r = 1 ..., m we eject a subset Ir of cardinality kr such that these k, items have the largest aj values in S.

Minimum capacity multi-ejection: In this rule, from each set Sr for r = 1 ..., m, we eject a subset Ir of cardinality kr such that these elements correspond to those with kr smallest

aj values in S. Memory-based multi-ejection: For this rule, we keep

track in an n dimensional array the number of times an item is ejected during a given run of improve(S). Then, this rule ejects a subset Ir of kr elements of Sr that have been



T Ojncan et a/-VLSN

search algorithms for partitioning problems using matching neighbourhoods 393

ejected the least number of times during the run of the algorithm.

3.2. Single item ejection rules

If kr is set to 1 for all non-empty Sr, 1 r <m the above ejection rules generate their corresponding single item ejection rules. In addition to these, we also consider the following single item ejection strategies.

Swap-based single ejection: Consider two sets Sp and S, in the ordered partition S. Let k E S, and I E Sq. Consider the new partition S* = (S, SI, , S , S,), where S* = Si if i # p, q, S* = S, U {l}\{k} and S* = S, U {k}\{l}. The process of

obtaining S* from S is called a (k, 1)-swap exchange. Such an exchange is feasible if S* is feasible. For the CAP this is equivalent to verifying the conditions

a(Sp) + a - ak bp

and a(Sq) + ak - al > bq

For the case of the SSTP, the above inequalities are reversed. The cost of this exchange is given by -Cpk + cpl - Cql + Cqk. In the swap-based single ejection rule, the ejection vector I is constructed as follows:

Set the active set A = N. Select an item, say k from A. Suppose k e Sp. Choose an item, say l from A\S, such that the cost of the resulting (k, 1)-swap exchange is as small as possible. Find q such that l E Sq. Choose Ip = {k) and I, = ({l}). Update A = A\(S, U Sq) and continue until A = 0.

Iterative single ejection: In this rule, we iteratively eject items from sets keeping in view the items already ejected. We first determine a random ordering m of the sets as

Sm1, Sl ..., Sm and we iteratively examine the sets in this order. In other words, we examine the set Snk in the kth iteration. Given the ordering it, let jk denote the item ejected from the set

Snko. The index jk is determined using the pa-

rameter value (k, j) for items j in set Snk, k = 1, 2 ...., m. For the SSTP, we define value(k, j) as follows:

For k = 1,

value(k, j) = I{i : ci,,j - cm,,j o0; i = 2 ..., m}l

and for k > 1

value(k, j) = |{i : co1i

- c-kj c 0, and a(Si) + aj - aji ~ bi; 1 < i < k - 1}1

For the CAP, the definition of value(l, k) is the same as that of the SSTP. For k > 1 we have

value(k, j) = {i : cm,j -ckj o0, and a(Smi) + aj - aj >3 bi; 1 i k - 1}l

Under the iterative ejection rule, we eject item jk from set Sk such that value(k, jk) =

maxjesk {value(k, j)}. Note that with this rule, which items to be ejected from Sk depends

on the selection of items from Sx, for r < k. The iterative single ejection rule is illustrated using the following example. Consider the instance of the SSTP with cost matrix

C- 1 5 3 4 2 7 2 4 2 3 3 5

supplies (al, al ..., a6) = (2,4,1, 3,2,6) and demands

(bl, b2, b3) -= (7, 5, 8). As the initial solution, consider

S1 = {1, 2}, S2 = {3, 4} and S3 = {5, 6} and, let 7 = (1,2, 3) be the order in which we examine sets S1, S2, S3. In the first iteration, we eject an item jl e SI with largest value(l, j). Note that, value(l, 1)= 2 since c2,1 oC1,1

and C3,1 ~C1,1l and value(l, 2)= 0 since c22~c1,2 and C3,2 C1,2. Hence,

jl = 1. In the second iteration, we consider the set S2 = {3, 4} and among all items in S2 we eject the one satisfying both

cij - C2,j o0 and a(S1) +aj -al bn. Since value(2, 3)= 1 and value(2, 4) = 0, we have j2 = 3. In the third iteration, we look for an item j e S3 satisfying the following conditions: (1) c1,j - C3,j o0 and a(S1) + aj - a1 obi, and (2) C2,j - C3,j o0 and a(S2) + aj - a3 ob2. Note that only item 5 satisfies condition (2). Hence, value(3, 5) = 1 and value(3, 6) = 0 and therefore we have j3 = 5. Consequently, we obtain the ejection vector I = {II, 12, 13} where II = {I}, 12 = (3}, 13 = {5}. The cost of the minimum cost perfect matching is -3 and the resulting improved partition is given by SI = {2, 3}, S2 = {4, 5}, S3 = {6, 1}.

3.3. Implementation of improve(S)

The procedure improve(S) uses the ejection rules discussed above in sequence to generate the corresponding ejection vector I and its matching neighbourhood MI (S) which is searched optimally for an improving solution. We have eight single ejection rules and six multiple ejection rules. Moreover, we also employ a mixture of multiple-ejection rules. In this case for each set Si, we apply a different rule to eject an Ii in a random sequence. Therefore, we have in total 15 ejection rules that are applied sequentially. We first start with single ejection rules, then multiple ejections followed by random ejection rules. In case there is no improvement with one rule we move to the next rule until some prescribed termination criterion is satisfied.

Many stopping criteria can be adopted for our algorithm such as stop when time limit is reached, stop when iteration limit is reached, or stop when all ejection rules are tried without improvement. The multi-ejection rules also have random elements in them (ie size of the set ejected) and repeating these rules multiple times could lead to potential improvements. Likewise there are random elements in swap-based single ejection and iterative single ejection which can also be exploited to diversify the search path. The procedure improve(S) terminates when an improved solution is obtained or we have tried all 15 ejection rules and then 100 random ejection rules without any improvement. We set our stopping




criterion to have a balance between the computation time and the solution quality. Of course by allowing more time and exploiting various diversification options built in the algorithm, there is potential for identifying further improvements which we did not explore in the current implementation.

3.4. Initial solution

Let us now consider procedures to construct initial solutions for the CAP and the SSTP. Note that computing a feasible solution for each of these problems is NP-hard. However, we can construct equivalent fictitious problems of the same type with the same set of optimal solutions whenever the original problems are feasible with the additional advantage that a feasible solution can be identified easily for the fictitious problems. The fictitious problem for the SSTP is obtained as follows: Introduce a new row in C, say row m + 1 where

c,,,+1,j is a large number for each j and set b,,+l = Eo-laj. Then

x,,,+1, = 1, j= 1 2, .....

n and xij =0 for i = 1, 2 ..., mi and j = 1, 2 ..., n is a feasible solution to the fictitious SSTP. Further, if the SSTP is feasible, the fictitious SSTP and the original SSTP have the same set of optimal solutions.

To retain the problem structure, the fictitious problem considered for the CAP is slightly larger than its SSTP counter- part. We increase the problem size by adding mn new columns and one new row to the cost matrix C. Let the new columns in C be n + 1, n + 2 ..., n + nm; and let the new row be m + 1. Define b,,+l =

ilbi. For each j =n + I, n + 2 ..., n +m, ,

define cij = M for i = 1, 2 ...., m; c,,,11j =0; and a1 =b j,,. For each j = 1, 2 ..., n, define

c,,,+l.j = M. Here, M is a large number. The solution

x,,+l.K = IVj = 1,2....

n, x1i.+i = IVi = 1, 2 ...., mn, and all other xij = 0 is obviously a feasible solution to this modified CAP problem and it is easy to see that if the original CAP is feasible, then an optimal solution to the modified CAP is also optimal for the original CAP. In any feasible solution to the modified CAP, if for some j e {l,2,..., m}, an assignment is made in the cell

(mn + 1, n + j) then the column n + j can be discarded from further consideration.

Another approach to generate a feasible solution to the SSTP or the CAP is to employ some simple construction heuristics. For the CAP, we have used an assignment-based construction heuristic proposed by Foulds and Wilson (1997). This algorithm does not guarantee a feasible solution. If the algorithm fails, we could use the fictitious problem discussed above or could construct a related fictitious problem using a partial solution obtained at the end of the construction heuristic of Foulds and Wilson (1997). Further, the construction heuristic can be modified in the obvious way to obtain a starting solution for the SSTP. Again, if the algorithm fails to obtain a feasible solution, we could use the fictitious problem or a variation of it exploiting the partial solution generated by the construction heuristic.

We also consider another approach to obtain an initial solution by relaxing constraints (6) and adding a penalty

for violating these constraints. Equivalently, for the CAP this can be viewed as replacing the right-hand side in constraints (6) by 0 for all i and defining a new cost

xij = max{b/

- a(Si\li) - a(I1), 0} for the edge (i, z i) of the improvement graph. Note that in this case, the improvement graph becomes a complete bipartite graph. The equivalent case for the SSTP is obtained by replacing the right-hand side in constraints (6) by M, a very large number, and defining the cost of edge (i, z i) of the improvement graph as Tij = max{a(Si\li) + a(1j) - bi,0}. This modified improvement graph is called feasibility improvement graph. In the procedure improve(S) if the improvement graph is replaced by the feasibility improvement graph the resulting procedure is called improve feas(S). Procedure improve_feas(S) can be used repeatedly to search for a feasible solution. Note that computing a feasible solution for the SSTP and the CAP are NP-hard

problems. We summarize our VLSN algorithms for the CAP and the

SSTP here.

Algorithm VLSN begin

Apply Foulds and Wilson assignment algorithm to compute an initial solution which is an ordered partition S. while S is infeasible do

S* := improve_feas(S) if S = S* then

stop/* No feasible solution obtained*/ endif S := S*

endwhile /* A feasible solution S is obtained*/

repeat S* := S; S := improve(S)

until (S* = S) Output S

end

4. Computational experiments

We have conducted some preliminary experiments using the VLSN search algorithm applied on instances of the CAP and the SSTP. We also compared the algorithm with CPLEX (2003). There are no standard test problems available for the CAP and the SSTP. Thus, we have generated random test problems using a scheme similar to that of Foulds and Wilson (1997).

For the CAP, two groups of test instances are produced according to the distribution used for the cost parameters: U(l, 2n) and U(1,nm). Here U(x, y) represents uniformly distributed random integers in the range [x, y]. For all instances the supply quantities ai are produced using U(1,20). To generate the demand quantities bj we have considered the



T Oncan et a/-VLSN

search algorithms for partitioning problems using matching neighbourhoods 395

Table 1 Parameter combinations used for the generation of different CAP test instance types

Parameters 1 2 3 4 5 6 7 8 9

S0.45 0.45 0.45 0.70 0.70 0.70 0.90 0.90 0.90 /3 1.80 1.80 1.80 1.45 1.45 1.45 1.10 1.10 1.10 y 0.95 0.97 0.99 0.95 0.97 0.99 0.95 0.97 0.99

Table 2 Test instance sizes generated for the CAP and the SSTP instances

Sizes 1 2 3 4 5 6 7 8 9 10

n 200 300 500 1000 500 1000 1000 1500 1500 2000 m 20 50 50 50 100 100 200 200 300 500

Table 3 Parameter combinations used for the generation of different SSTP test instance groups

Parameters 1 2 3 4 5 6 7 8 9

S0.40 0.40 0.40 0.65 0.65 0.65 0.90 0.90 0.90 P 1.35 1.35 1.35 1.20 1.20 1.20 1.35 1.35 1.35

y 1.02 1.04 1.06 1.02 1.04 1.06 1.02 1.04 1.06

formulae (9) and (10) below:

L

aj/nm<bi <fL aj/nm

for eachi (9) j=l j=1

in n

L bi= y a (10) i=1 j=1

where a, /, and y are some parameters. For each group of test instances, we have generated nine test instance types each of which is generated with a different combination of a, /3, and 7. These parameter combinations are presented in Table 1. For each test instance type (parameters combination), we have generated 10 sets of instances with different sizes. Our test instance sizes are presented in Table 2. Furthermore, for each instance type and size, we have generated five different instances which makes 2 x 9 x 10 x 5 = 900 instances for the CAP.

For the SSTP, again the test bed consists of two groups of instances such that the costs are generated from U(1,2n) and U(1, nm). For all instances, we have considered aj e U(1, 20). To generate the supply quantities bi, we have used the formulae (9) and (10). As in the case of the CAP, 900 test problems are generated. The values of the parameters , /3 and y for these instances are given in Table 3.

In summary, our test bed consists of a total of 900 instances each for both the CAP and the SSTP. According to the cost parameter distributions, we have two groups of instances for both the CAP and the SSTP. For both of the CAP and the SSTP test groups, the instances are classified according to their sizes (ie m and n), and their types (ie the combination of a, /, and 7y parameters). For each group of instances, we have

nine different instance types (parameter combinations). For each of different instance type, we have 10 different instance sizes. For each of the generated instance type and size, we have generated five different test instances.

The algorithms are coded in C++ and tested on a Dell Inspiration workstation with a 1.8 GHz Xeon processor and 512 MB of memory. For solving the weighted bipartite matching problem (assignment problem), we have used a FOR- TRAN code by Carpaneto et al (1988). For each test case, we call Phase I as the initial phase to get a starting solution. We first implemented Foulds and Wilson's algorithm and whenever it failed to produce a feasible solution, we have used improvefeas(S) repeatedly to produce a starting solution. In 519 out of 900 SSTP test instances and in 356 out of 900 CAP test instances, the Foulds and Wilson's algorithm failed to obtain feasible solution. However, our improve feas(S) procedure always produced a feasible solution very quickly for both of the CAP and the SSTP where the feasibility problems themselves are known to be NP-Hard. Phase II refers to the improvement algorithm using procedure improve(S) repeatedly. For each test instance, the CPU time (in seconds corrected to two decimal points) and number of iterations are noted. We have also compared our algorithm with the commercial integer programming solver that ran for I h. For large instances that we have used, CPLEX did not produce a feasible solution in 1 h. This is indicated with NA in Tables 4 and 5. For smaller size problems, it found the optimal solution and for medium range problems it terminated without certificate of optimality. The results are summarized in Tables 4 and 5 for the CAP and the SSTP, respectively, in the form of average, minimum, and maximum values of iterations and CPU times (in seconds truncated to two



C13 C13 C13 C13 C13 C13 C13 C13 C13 C13 C13

Table

4

Averages

results

for

900

CAP

instances

CAP

Phase

I

Phase

II

Phase

I

Phase

II

CPU

Iterations

CPU

Iterations

Max.

%

Aver.

%

Max.

%

Aver.

%

M

N

Min

Max

Aver

Min

Max

Aver

Min

Max

Aver

Min

Max

Aver

Dev

Dev

Dev

Dev

20

200

0.00

0.00

0.00

0.00

5.00

1.10

0.05

0.17

0.09

128.40

466.80

221.33

120.31

33.71

28.26

11.21

50

300

0.00

0.02

0.01

0.00

6.20

2.17

0.73

2.24

1.29

257.80

868.60

480.81

167.32

56.57

27.59

16.22

50

500

0.00

0.01

0.00

0.00

3.67

0.90

0.71

3.19

1.63

145.80

771.20

370.18

232.85

61.98

29.81

13.05

50

1000

0.00

0.00

0.00

0.00

0.00

0.00

1.08

3.64

1.84

104.60

409.80

192.99

13.96

5.64

9.96

4.91

100

500

0.00

0.10

0.04

0.00

7.00

3.13

9.65

18.89

13.61

579.00

1245.80

857.14

96.65

59.06

11.70

9.99

100

1000

0.00

0.09

0.01

0.00

3.00

0.48

9.35

30.63

19.35

258.80

988.60

578.53

18.19

11.38

9.53

6.88

200

1000

0.00

0.72

0.30

0.00

6.40

2.92

96.64

189.04

144.78

762.20

1564.00

1198.56

NA

NA

NA

NA

200

1500

0.00

0.75

0.23

0.00

5.00

1.51

83.36

312.26

191.39

404.40

1785.60

1023.90

NA

NA

NA

NA

300

1500

0.00

2.77

1.06

0.00

7.40

3.10

388.58

743.24

566.47

908.80

1937.60

1397.41

NA

NA

NA

NA

500

2000

2.64

8.36

5.12

2.75

6.40

4.30

1135.62

3224.80

2187.34

757.20

2332.60

1508.42

NA

NA

NA

NA

Average

0.26

1.28

0.68

0.28

5.01

1.96

172.58

452.81

312.78

430.70

1237.06

782.93

108.21

38.06

11.60

10.38

Table

5

Averages

results

for

900

SSTP

instances

SSTP

Phase

I

Phase

II

Phase

I

Phase

II

CPU

Iterations

CPU

Iterations

Max

%

Aver

%

Max

%

Aver

%

M

N

Min

Max

Aver

Min

Max

Aver

Min

Max

Aver

Min

Max

Aver

Dev

Dev

Dev

Dev

20

200

0.00

0.00

0.00

0.00

7.33

1.45

0.06

0.15

0.09

137.40

395.00

212.83

178.26

34.22

16.08

7.24

50

300

0.00

0.02

0.01

2.00

6.60

4.45

0.94

2.25

1.48

325.40

860.80

541.32

1027.73

562.87

34.89

19.42

50

500

0.00

0.02

0.00

0.00

4.60

1.32

0.83

2.88

1.82

177.00

658.00

395.62

528.18

116.27

16.37

9.09

50

1000

0.00

0.00

0.00

0.00

0.00

0.00

1.18

2.62

2.06

114.60

259.40

206.93

10.26

5.07

6.74

3.77

100

500

0.04

0.11

0.07

2.80

7.00

5.04

8.64

17.33

12.67

507.40

1109.80

781.04

2168.33

1110.29

19.12

-1.44

100

1000

0.00

0.16

0.04

0.00

5.80

1.53

12.41

42.40

22.56

343.20

1291.20

649.86

993.78

288.07

14.87

7.60

200

1000

0.25

0.79

0.54

2.67

7.00

5.09

91.92

171.45

143.98

699.20

1423.60

1154.32

NA

NA

NA

NA

200

1500

0.00

1.16

0.46

0.00

6.80

2.96

104.14

288.94

202.16

533.40

1583.40

1033.96

NA

NA

NA

NA

300

1500

1.00

2.66

1.90

3.25

7.20

5.41

366.71

947.67

602.07

821.60

2304.40

1445.24

NA

NA

NA

NA

500

2000

5.54

11.52

8.21

4.67

8.40

6.31

2281.84

3582.69

2832.32

1531.80

2477.20

1895.11

NA

NA

NA

NA

Average

0.68

1.64

1.12

1.54

6.07

3.36

286.87

505.84

382.12

519.10

1236.28

831.62

817.76

352.80

18.01

7.61



T Oncan et a--VLSN a--VLSN search algorithms for partitioning problems using matching neighbourhoods 397

0)

0)

0)

0)

1-

0.8

0.6

0.4

0.2

0-

CAP (scaled)

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 iteration / total iteration

Figure 4 Improvement versus Iteration for a CAP instance.

ar

C

a,

a

1-

0.8

0.6

0.4

0.2

0-

SSTP (scaled)

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

iteration/ total iteration

Figure 5 Improvement versus Iteration for a SSTP instance.

decimal places) over the test problems considered for a given problem size (m, n). The meaning of the contents in each column of the tables are self explanatory from the titles. In the last columns, % Dev represents the average deviation from CPLEX solution calculated with a 1 h CPU time limit for execution. In some cases the deviation is negative. This is because our solution in those cases are better than the CPLEX solution produced with a 1 h time limit.

One observation from the Tables 4 and 5 is the large amount of CPU time used in Phase II for large size problems. Al- though this behavior was anticipated, we wanted to see at what rate the improvements are taking place. It was observed that most of the improvements took place in the first 15% of the iterations. Graphs in Figures 4 and 5 show, respectively, a plot for an instance of the CAP and the SSTP with m = 500 and n = 2000. For both of the graphs the x-axis stands for (current iteration number)/(total number of iterations) and the y-axis stands for (final objective function)/(current objective function value).

Figure 4 represents the CAP instance and Figure 5 represents the SSTP instance. It shows that if we had terminated after 15% of the total number iterations planned, we would have obtained a solution which is almost as good as the one we obtained with significant savings on computational time.

5. Conclusion

In this paper, we have introduced a method to design VLSN search algorithms for partitioning type problems. A new class

of neighbourhoods is introduced which contains the well- known multi-exchange neighbourhood. Our VLSN search algorithm explores the matching neighbourhood heuristically by considering sub-neighbourhoods each of which is potentially of exponential size that are searched by using polynomial time algorithms. Computational results are presented on two partitioning-type problems: the CAP and the SSTP. The performance of the algorithm is very encouraging. It is observed that most of the improvements are done in the first 15% of iterations. Thus, we believe that combining the heuristic with different types of neighbourhoods within a variable neighbourhood search (Hansen and Mladenovic, 2003) framework could provide improved solutions. Experimental analysis of such heuristics is beyond the scope of this paper and is a topic for further investigation.

Acknowledgements- This work was partially supported by the NSERC discovery grants awarded to Santosh N Kabadi, KPK Nair, and Abraham P Punnen.

References

Agarwal R, Ahuja RK, Laporte G and Shen ZJ (2004). A composite very large-scale neighborhood search algorithm for the vehicle routing problem. In: Leung, JY-T (ed). Handbook of Scheduling: Algorithms, Models and Performance Analysis, Chapter 49. Chapman & Hall CRC, New York, pp 49-01-49-23.

Ahuja RK and Cunha CB (2005). Very large-scale neighborhood search for the k-constraint multiple knapsack problem. J Heuristics 11: 465-481.

Ahuja RK, Ergun O, Orlin JB and Punnen A (2002). A survey of very large scale neighborhood search techniques. Discrete Appl Math 23: 75-102.

Ahuja RK, Ergun O, Orlin JB and Punnen A (2007). Very large scale neighborhood search: Theory, algorithms, and applications. In: Gonzalez T (ed). Handbook on Approximation Algorithms and Metaheuristics. CRC Press: New York. To appear.

Ahuja RK, Liu J, Orlin JB, Goodstein J and Mukherjee A (2004a). A neighborhood search algorithm for the combined through and fleet assignment model with time windows. Networks 44: 160-171.

Ahuja RK, Magnanti TL and Orlin JB (1992). Network Flows: Theory, Algorithms and Applications. Prentice Hall: Englewood Cliffs, NJ.

Ahuja RK, Orlin JB and Sharma D (2003). A composite very large scale neighborhood structure for the capacitated minimum spanning tree problem. Opl Res Lett 31: 185-194.

Ahuja RK et al (2004b). A multi-exchange heuristic for the single source capacitated facility location. Mngt Sci 50: 749-760.

Carpaneto G, Martello S and Toth P (1988). Algorithms and codes for the assignment problem. Ann Oper Res 13: 193-223.

CPLEX, ILOG CPLEX 9.0 User's Manual (2003). DeMaio A and Roveda C (1971). An all zero-one algorithm for a

certain class of transportation problems. Opns Res 19: 1406-1418. Drezner Z and Hamacher HW (2004). Facility Location: Applications

and Theory. Springer: Berlin. Ergun O, Orlin JB and Steele-Feldman A (2002). Creating very large

neighborhoods out of smaller ones by compounding moves: A study on the vehicle routing problem. MIT Sloan Working Paper No. 4393-02.

Foulds LR and Wilson JM (1997). A variation of the generalized assignment problem arising in the New Zealand dairy industry. Ann Oper Res 69: 105-114.




Garey MR and Johnson DS (1979). Computers and Intractability: A Guide to the Theory of NP-Completeness. Freeman: San Francisco.

Hansen P and Mladenovic N (2003). A tutorial on variable neighborhood search. Les Cahiers du GERAD, G-2003-46, Universit6 de Montr6al, HEC, Canada.

Hoffman K and Padberg M (1993). Solving airline crew-scheduling problems by branch-and-cut. Mngt Sci 39: 667-682.

Kernighan B and Lin S (1970). An efficient heuristic procedure for partitioning graphs. AT & T Tech J 49: 291-307.

Lawler E (1976). Combinatorial Optimization: Networks and Matroids. Holt, Rinehart and Winston: New York.

Martello S and Toth P (1990). Knapsack Problems: Algorithms and Computer Codes. Wiley: New York.

Orlin JB, Punnen AP and Schulz AS (2004). Approximate local search in combinatorial optimization. SIAM J Comput 33: 1201-1214.

Orlin JB and Sharma D (2004). Extended neighborhood: Definition and characterization. Math Program 101: 537-559.

Punnen AP (2001). The traveling salesman problem: New polynomial algorithms and domination analysis. J Inform Optim 22: 191-206.

Pinedo M (1995). Scheduling: Theory, Algorithm and System. Prentice Hall: Englewood Cliffs, NJ.

Srinivasan V and Thompson GL (1973). An algorithm for assigning uses to sources in a special class of transportation problems. Opns Res 21: 284-295.

Thompson PM and Orlin JM (1989). The theory of cyclic transfers. MIT Operations Research Center Report 200-89.

Thompson PM and Psaraftis HN (1993). Cyclic transfer algorithms for multivehicle routing and scheduling problems. Opns Res 41: 935-946.

Received February 2006; accepted September 2006 after three revisions



Download - VLSN Search Algorithms for Partitioning Problems Using Matching Neighbourhoods

Top Related