Combinatorial instruments in the design of a heuristic for the quadratic assignment problem

Combinatorial instruments in the design of a heuristic for the quadratic assignment problem

Paulo Oswaldo Boaventura-Netto

Laboratoire PriSM, Université de Versailles à St. Quentin-en-Yvelines, Versailles Cedex – França, Programa de Engenharia de Produção / COPPE, Universidade Federal do Rio de Janeiro, Rio de Janeiro – RJ, [e-mail]; [e-mail]

ABSTRACT

This work discusses the use of a neighbouring structure in the design of specific heuristics for the Quadratic Assignment Problem (QAP). This structure is formed by the 4- and 6-cycles adjacent to a vertex in the Hasse diagram of the permutation lattice and it can be adequately partitioned in subsets of linear and quadratic cardinalities, a characteristics which frequently allows an economy in the processing time. We propose also a restart strategy and a mechanism for generating initial solutions which constitute, together with the neighbouring structure, a possible QAP-specific heuristic proposal. For the construction of these instruments we used the relaxed ordered set of QAP solutions.

Keywords: quadratic assignment problem; combinatory; heuristics.

RESUMO

Este trabalho discute o uso de uma estrutura de vizinhança em heurísticas específicas para o Problema Quadrático de Alocação (PQA). Esta estrutura envolve os ciclos de comprimento 4 e 6 adjacentes a um vértice do diagrama de Hasse do reticulado das permutações e pode ser particionada em subconjuntos de cardinalidade linear e quadrática em relação à ordem da instância, o que permite frequentemente uma economia de tempo de processamento. Propõem-se ainda uma estratégia de repartida e um mecanismo de geração de soluções iniciais, que constituem, ao lado da estrutura de vizinhança, uma proposta de heurística específica para o PQA. Na construção desses instrumentos foi utilizada a noção de conjunto relaxado ordenado das soluções do PQA.

Palavras-chave: problema quadrático de alocação; combinatória; heurísticas.

1. Introduction

QAP is a NP-hard problem that has been studied by a number of researchers in combinatorial optimization through the second half of the 20^th century and which continues to excite the curiosity of many others, both in the study of exact algorithms and through the formulation of information mechanisms for heuristics. The exact approach is severely limited by the high complexity of the problem, a difficult 30-order instance (Nug30) having been solved exactly only through a huge work of metacomputing. More recent years have seen an increased interest in the use of metaheuristic schemes: some examples are [AQB99], [BT94], [AOT00], [CMMT97], [Ma00], [TRFR01] and [TS95].

Specific heuristics for the QAP are normally classified as being constructive, limited enumeration and improvement ones.

Constructive methods build a solution by choosing an image element at each step through the use of a given criterion, until a complete solution is obtained ([BAV62], [AB63], [SWHH95], [TB98], [SWH98], [Bu91], [Lo00], [AHS01], [GY02] and [YSA03]).

Limited enumeration methods use available information to guide solution enumeration. Evidently an optimum value cannot be guaranteed unless the whole solution set is enumerated, so it is necessary to establish stopping criteria. This approach seems to have been abandoned since the eighties ([We83], [BB83]).

Improvement methods involve local search algorithms and most of the specific QAP heuristics are classified in this category. The main elements in these methods are the neighborhood definition and the order user for the analysis of the neighbors ([MO79], [Br84], [LS95], [BÇ95], [An96], [THKG98]). These methods are frequently utilized within the logic of the metaheuristics. The technique here presented can be included in this group.

We refer to [Ma00] for the discussion of QAP origins and for its definitions, from which we retain only that a QAP instance is a pair of matrices (M_F,M_D) where M_F = [f_ij] corresponds to flows and M_D = [d_ij] to distances traversed by these flows in a context of n machines functionally connected two by two in a shop. Through this work we will consider M_F and M_D as symmetric.

In what concerns the theoretical work on QAP the majority of the studies concerned the definition of better lower bounds for the optimal solution to be used in exact algorithms, such as in [KÇCE00]. A characterization of some polynomial cases has also been presented [Çe98].

The approach used in this paper is an algebraic and combinatorial one (AC) [Ab84], which considers some properties of the permutation set and its graph-theoretical description in order to propose three basic instruments which constitute together a proposal of a specific heuristic. The AC approach has already been used to inform metaheuristics such as simulated annealing [QAB99] and GRASP [RAB00] and also in the definition of a new difficulty measure for QAP instances [ABQG02].

The AC approach associates the solution set of a QAP instance to the set S_n of n-permutations. Graph-theoretical models are applied to allow the definition of a neighbourhood structure [LB01]. The corresponding definitions and notation follow [Be73] and [Bo01]. A relaxing and ordering scheme is applied to S_n which allows to the definition of a generator of initial solutions and a restart strategy. This whole set of instruments constitutes a QAP-specific heuristic algorithm.

Sections 2 and 3 present some concepts, definitions and instruments from AC. Sections 4 and 5 discuss some specific questions related to the proposed neighbourhood. Section 6 is related to the algorithm construction and finally Section 7 presents some results of tests with QAPLIB instances [BKR97].

2. A relaxed set and the question of feasibility

2.1 A graph-theoretical model

Let j Î S_n be a permutation,

and consider the function

where y_ij is the numerical ordering of the couple (i,j) within a lexicographical ordering.

We can then define a N-order permutation (where N = C_n,2), corresponding to j:

whose k^th element, k = y_ij, is, with j(i) = j_i,

a permutation of couples of elements from j .

Let S_N be the set of permutations with N elements. Every solution from S_n has a corresponding solution within S_N. The reciprocal is not true and we have then to distinguish feasible and infeasible solutions in S_N. This situation is more easily examined through a graph-theoretical model where we associate M_F and M_D respectively to complete undirected graphs K_F and K_D, whose edges will be valued after the corresponding entries in the matrices (Figure 1):

In this model the elements of a permutation set as defined in (2.1) will be vertex-permutations and those following (2.3) will be edge-permutations, so we will use these designations from now on. We will call S_N the relaxed set of S_n.

The infeasibility of most solutions corresponds to the fact that when we make a vertex exchange all edge extremities concerned with the exchanged vertices have also to exchange. Then every edge permutation having not a coherent allocation of edge extremities will not be associated to a vertex permutation, so it will not be feasible. It is important to observe that instance values have nothing to do with this question.

2.2 The feasibility matrix

We can define a feasibility matrix in order to verify if a given solution x Î S_N is feasible or not. To obtain it we can observe that an edge (i,j) from K_D can be associated to an edge (k,l) from K_F either by associating k to i and l to j, or by associating k to j and l to i. So we build a matrix M_x whose elements are the sums of the association possibilities for every pair (i,j), (k,l) of edges. If a relaxed solution x_kis feasible we will find in this matrix n independent positions with value n – 1.

For this calculation we use the inverse function (y_ij)^-1 to recover the vertex couples defining the edges.

Example:

Let's sum a unity over a null 4 x 4 matrix to the positions

from x₁ : (1,1), (1,4), (2,1), (2,4); from x₂ : (1,3), (1,4), (3,3), (3,4);

from x₃ : (1,2), (1,4), (4,2), (4,4); from x₄ : (2,1), (2,3), (3,1), (3,3);

from x₅ : (2,1), (2,2), (4,1), (4,2); from x₆ : (3,2), (3,3), (4,2), (4,3).

The final matrix is

Here we found n – 1 edges associated with each vertex and the n independent positions with this value correspond to a vertex permutation. The solution is feasible.

If we take, on the other hand, the permutation , we will obtain

where the matrix structure does not show any association with a vertex permutation. This solution is infeasible.

It is convenient to observe that the element sum is constant for every row and for every column, only the element distribution changes from a solution to another.

3. The ordering by value within an instance

Let we consider an instance (M_F,M_D). The cost of a solution j Î S_n from (M_F,M_D) is

For the symmetric QAP we can define N-component vectors F = [f_i] and D = [d_j] containing the values of the upper triangles of M_F and M_D. Then we can obtain their product [GP66]:

The N x N matrix Q contains every cost parcel for every j Î S_n . The cost is associated to the elements of the permutation x Î S_N corresponding to j,

It is possible to define a partial order by value on S_N. We order F and D by opposite orders, for instance F ® F⁺ (non-decreasing) and D ® D^- (non-increasing). Then we can define a new matrix,

whose trace å q_ii(i = 1,...,N) is an absolute lower bound for the instance (we can also observe that the opposite trace å q_i,N+1-i (i = 1,...,N) is an absolute upper bound for it).

We have a new (ordered) solution set which corresponds to a new permutation lattice. To distinguish it from the former we will respectively denote them S_N(Q*) and S_N(Q).

Figure 2 shows a scheme of S_N(Q*), a polygon, as a pictorial representation of level cardinalities: the upper and lower vertices of the polygon correspond to the single-solution extreme levels and between them the level cardinality grows from 1 (at N₀) through the lower half of the figure, goes to a maximum in the middle and shrinks to 1 (at N_N) through its upper half. For more details see Item 4.2 and Eq. 5.4 below.

4. The Hasse diagram of the permutation set

4.1 The permutation lattice

The n-order permutation set S_n can be described as a lattice (S_n, < ) [Be68] where the partial ordering is given by the number of inversions, that is, the number of times an element of a permutation has another element lesser than it in a more advanced position, for each element concerned. The Hasse diagram of this lattice is an undirected graph G_n = (S_n,U) where U is the set of permutation pairs differing between them by one and only one inversion. This (partial) ordering is not the same as that of S_N(Q*) but it is close enough in most instances to allow its use as a guide for finding better solutions. That is, we can think of inversion reduction as a strategy for getting better costs.

The number of inversions related to a given element p_iÎ pwill be

and the inversion number n(p) of a permutation will be the sum of the inversion numbers related to their elements,

It is convenient to define an inversion at the positions (i,j) as corresponding to the effect of an inversion operator t_ij which exchanges the positions of the i^th and j^th elements of a permutation.

4.2 Some properties of G_n

Most of the properties here discussed was presented in [LB01] but the discussion made here has been elaborated in some details.

Property 1:G_n is a regular graph of degree n – 1.

Proof. (Immediate)

Property 2: G_n is bipartite and we can partition S_n by the number of inversions of its elements.

Proof. We can define subsets N(n_i) Ì S_n (i = 0, ..., N = C_n,2)such that every permutation j Î N(n_i) has n _i inversions. As every permutation has a unique inversion number these subsets constitute a partition of S_n. Owing to the definition of G_n, there are no edges within vertices of the same level and every G_n edge ill connect vertices of consecutive levels. Then we can designate even and odd colors to the N(n_i) according to their index, in the sense of vertex coloring. So G_n is bipartite.

Obs.: The zero level N₀ and the opposite level N_N have exactly one element (resp. identity and opposite permutations).

Property 3: We can define a level set for G_n having in N₀ a given permutation.

Proof. We can take a permutationj Î S_n and do the necessary inversions to obtain a first level, a second level and so on. The content of the image is irrelevant.

Remark. We will use this property to define a level set on G_n and we will then speak of a level set related to a given permutation j.

Property 4: G_n has girth g(G_n) = 4.

Proof. G_n is a 1-graph, so there are no 2-cycles. As G_n is bipartite, it has no odd cycles. Finally, the successive operations t _ij, t_kl, t_ji and t_lk (i, j consecutive, k, l consecutive, {i,j} Ç {k,l} = Æ ) define a 4-cycle which e stablish the girth value.

Example: For n = 4 we have (1234) ® (2134) ® (2143) ® (1243) ® (1234).

Property 5: A vertex j Î S_n belongs to C_n-1,2 adjacent 4- and 6-cycles, from which C_n-2,2 4-cycles and n – 2 6-cycles.

Proof. From Property 1 the immediate neighbouring G(j) has n – 1 vertices. A cycle adjacent to j will have two vertices j₁ and j₂ in G(j). Then there will be C_n-1,2 ways to choose a pair of these vertices. From these, there will be n – 2 intersecting pairs made of consecutive triples and C_n-1,2 – (n – 2) = C_n-2,2 disjoint pairs which, by Property 4, give way to 4-cycles. The remaining n – 2 cases being those of j -element triples we can have 6 permutations of their positions, giving 6 different solutions. Then we will have 6-cycles.

Example: For n = 3 on a (123) ® (132) ® (312) ® (321) ® (231) ® (213) ® (123).

Property 6: No 6-cyclefrom G_n has chords.

Proof. A 6-cycle corresponds to 2 non-disjoint pairs, a 4-cycle to 2 disjoint pairs. So a 6-cycle cannot contain every vertex of a 4-cycle. As a consequence, no 6-cycle on G_n has chords.

5. A cycle-built neighbouring structure

We can now define a neighbouring structure based on the 4- and 6-cycles adjacent to a vertex j in G_n. We call it a rosace of order n, R_n = R_n (j) = (S³⁴,U³⁴). The vertex j is the root of R_n(j). The notation involves the fact that the cycles are generated by exchanges on three or four elements.

Applying Property 3 we can say that a rosace contains vertices from the levels N₁, N₂ and N₃ with respect to its root j.

The rosace R₄(j), for j = (3 1 4 2) is (Figure 3):

Theorem 1: The cardinality of S³⁴ is O(n²) owing to the 4-cycle external extremities.

Proof. We have C_n-2,2 = (n – 2)(n – 3)/2, which is O(n²). The only vertices which are exclusive of 4-cycles are their external vertices. From Properties 1 and 5, both N₁ and 6-cycle cardinalities are O(n).

Remark. From Props. 1 to 5 we can obtain G_n order and size,

and

Theorem 2: A rosace R_n is the union of N₁ and N₂ vertices with the N₃ vertices opposite to the root in the 6-cycles.

Proof. We have j È G (j) Ì R_n. As we take C_n-1,2 pairs from N₁ to apply the inversion operator we use it in every possible situation, then we will generate the whole N₂ level. But in N₃ we will attain only the n – 2 vertices opposite to j in the 6-cycles.

So N₂ will have a vertex within each 4-cycle and two vertices within each 6-cycle, then

For n = 6, we will have |N₂| = 14, which is also the value of the third coefficient of this lattice's generating function (see for instance [Ka68]):

For n = 6 we obtain (1, 5, 14, 29, 49, 71, 90, 101, 101, 90, ...).

When exploring a rosace we will then visit the 6-cycle farthest vertices and also do a two-level exhaustive local search (that is, to explore G (j) and G (j₁) for every j₁Î G (j)). Nevertheless there are two important differences:

- economy of repetitions (e.g., with n = 6 we would have (n – 1)(n – 2) = 20 vertices, while R₆ has only 14 vertices);

- we can easily explore separately the linear substructures (G(j), intermediate and farthest 6-cycle points) and 4-cycle extremities and select what to explore according to the obtained results and to the behavior of the instance.

We refer to [LB01] and [Bo02] for additional information about the properties of a rosace.

6. A proposal of a rosace-based algorithm

6.1 The initial solutions

As it was already discussed we can easily obtain the feasibility matrix of any solution of the relaxed set S_N(Q). One could then think about solving the QAP by transposing to S_N(Q) the identity permutation from S_N(Q*) – whose cost is the absolute lower bound of the instance – and so look for the nearest feasible solution by trying to find a set of greater-valued elements in its matrix.

Unfortunately the feasibility matrix is not so a precise instrument, owing to the very high value of the ratio N!/n! even for modest-sized instances (for n = 5 we have already 10!/5! = 30240). So it is not generally possible to identify such a set in the matrix, the closest feasible solution being frequently so far that its influence on the matrix entries becomes negligible.

We used it nevertheless to induce a sort of proximity, in order to generate intermediate-valued solutions. The process is as follows:

• we take the lower-bound and upper-bound solutions in S_N(Q*), transpose them to S_N(Q) and calculate their feasibility matrices and the difference between them;

• we sum to each entry a pseudorandom integer value r_ijÎ {0, n/k}, where k < n;

• we subtract every matrix entry from the maximum entry.

This way we are trying to get nearer to the lower bound and farther from the upper bound. The practical result is a set of intermediate solutions which are obtained by iteratively applying the Hungarian algorithm to the current matrix after penalizing the selected entries from the preceding iteration by summing one unity to them. Finally we order the solutions by non-decreasing cost and use the first nsol ones (nsol being the number of initial solutions obtained from each pseudorandom seed

6.2 Generating the neighbouring structure

The initial rosace was built at the initialization stage, the identity permutation I_n being used as root. The vertices were stocked in matrices of the form M(2,p,q) where the first and second dimensions receive the position of an exchange and its content. The third dimension corresponds to the list of exchanges. We have p = 3 for the 6-cycles and p = 4 for the 4-cycle extremities. There are two 6-cycle matrices, one for the N₃-elements and another for the N₂-elements.

Example: for n = 5 the N₃-element matrix of the 6-cycles is, with q = n – 2 = 3,

and the 4-cycle matrix is, with q = C_n-2,2 = C_3,2 = 3,

A set of routines is used that starts with N₁ vertices and couples them to obtain the 4- and the 6-cycle vertices. The process begins at a management routine, gerapar and for the non-intersecting couples it is executed there, the control passing then to a stock routine stocpar which fills the adequate positions in the 4-cycle matrix. If the couple intersection is not void three vertices will be calculated and this is done for each one by C6 and gama routines. After each pass stocpar is called to fill in the corresponding matrix. The scheme of the process is as follows:

Example of a 6-cycle generation

Let n = 5 and let (2 1 3 4 5) and (1 3 2 4 5) be two permutations from N₁. The first 4-tuple will be (1,2,2,3) with non-void intersection. We apply gama(4-tuple(1),4-tuple(4)) to (2 1 3 4 5), looking for the values 1 and 3 at the image and exchanging them to obtain (2 3 1 4 5). Now we apply gama(4-tuple(3),4-tuple(4)): the elements 3 and 4 of the 4-tuple are 2 and 3, so we obtain (3 2 1 4 5). Finally with gama(4-tuple(1),4-tuple(2)) we get (3 1 2 4 5). We could also begin with the second permutation (1 3 2 4 5) to obtain the same result.

6.3 The use of the structure

As we have a current solution j we calculate the products p o j , where p Î R_n(I_n) is a permutation from the initial rosace. As the operations are limited to the exchanged elements, the process is of constant complexity order for each permutation. On the other hand we can thus preserve the adjacency relations within G_n despite the fact that the composition of permutations does not generally preserve these relations.

Each matrix is inspected to determine the cost differences which allow the algorithm to choose the most convenient exchange. The linear-order rosace subsets are explored in the first place, beginning by the most external ones. We usually limit the search to these sets if a better solution is found; the quadratic-order 4-cycle subset is normally explored in case of failure of the former exploration and normally just until the point where a better solution is found.

The main exploration routine is called varre. It receives the current solution and uses a subsidiary named autom to make the subset-to-subset transfer of the basic rosace to this new root.

We use two types of blocking strategies to avoid direct return of the algorithm path, one-iteration blockings and taboo blockings. These last ones were applied with the aid of taboo vectors. If the new solution has a higher cost we call for a restart routine.

6.4 A restart strategy

This strategy has already been used as an information tool for a simulated annealing application to QAP [QAB99]. We work within the ordered relaxed set S_N(Q*) where the cost and inversion orderings can be approximately matched.

If we have a current solution j which is considered not adequate as a rosace root for the next iteration, we try to obtain new starting solutions j', j", ..., for which the corresponding S_N(Q*) permutations have less inversions. For that we determine an edge-permutation r Î S_N(Q*) corresponding to the current j and look into it for a pair of positions whose exchange brings maximum reduction to r inversion number. After that we search for vertex permutations differing by one exchange from j such that this exchange will imply the edge exchange we selected in r.

We then begin by applying (2.2) to obtain the edge-permutation x Î S_N(Q) associated to j.

The composition allowing us to find r Î S_N(Q*) corresponding to x is

where f_F : F ® F⁺ and f_D : D ® D^- are the permutations resulting respectively from the sortings of F into F⁺ and of D into D^-.

The first target to be found in this permutation is a position whose exchange (with another unknown position) implies the greatest inversion reduction: this is fulfilled by k₁ such that |k₁ – r(k₁)| has maximum value. The second position for the exchange should be one bringing the minimum loss – if a loss should arrive – on the inversion reduction, that is, a k₂ such that the sum of crossed differences |k₁ – r (k₂)| + |k₂ – r (k₁)| will be minimum.

As we already pointed, the resulting solution will not be feasible but we will look for feasible solutions whose exchanges, when made on j , imply the one we selected. For that we have to return into vertex permutations.

We then apply to k₁ and k₂ to find the corresponding m₁ and m₂ positions into x and their images p₁ = x(m₁) and p₂ = x(m₂). Their exchange will give us a new permutation x'. To return into G_n we have to apply the inverse y^-1 of (2.2). We will obtain four different vertex permutations if the edges k₁ and k₂ are non-adjacent or three ones if they are adjacent.

Example: We will take F = (5, 2, 3, 1, 3, 0, 2, 0, 0, 5) and D = (1, 1, 2, 3, 2, 1, 2, 1, 2, 1), the instance Nug05 from the literature. A (non unique) ordering possibility for F and D is

f_F = (9 5 8 4 7 1 6 2 3 10) and f_D = (6 7 2 1 3 8 4 9 5 10).

Let j = (4 1 3 5 2) be the current solution. The edge permutation associated to j is

x = (3 8 10 6 2 4 1 9 5 7).

The cost of the current solution is 32 and the permutation r Î S_N(Q*) is r = (1 5 3 8 9 6 7 10 2 4). It has 18 inversions; taking the differences |i – r(i)| for every i we find k₁ = 9 and, with the values of | k₁ – r(i) | + | i – r(k₁) | for every i we find k₂ = 4, then the new permutation is r' = (1 5 3 2 9 6 7 10 8 4).

By going into S_N(Q) we find, for the new permutation x',

(9) = 1 then x(1) = 3 and (4) = 4 then x(4) = 6

and finally

y ^-1(3) = (1,4) and y ^-1(6) = (2,4).

In this case the two edges are adjacent, so we will have only three possible exchanges, (1,2), (1,4) and (2,4). It is important to observe that we are working on the image, so when we take the current solution (4 1 3 5 2) we will obtain as new solutions (4 2 3 5 1), (1 4 3 5 2) and (2 1 3 5 4). The last one has a favorable difference of 2 cost units, then it will have cost 30.

In order to assure a greater distance from the last rosace we doubled this scheme to obtain two 2-exchanges. A better cost is certainly not guaranteed as we selected a single edge exchange among n – 2 ones. With two exchanges, according to edge adjacencies, we will have between 9 to 16 solutions to choose among.

This work is done by the routine novsol. It finds the permutation r Î S_N(Q*) and looks for the best e exchange first positions in it, then it makes a random choose for k₁ and goes through the whole process already described. (We found it convenient to use e = 3 + [n/12] in the tests).

The cost differences for every new solution are determined and ordered, the first difference being added to the current value and the corresponding solution is sent to a local search routine, buscaloc.

We can use just the best solution of the ordered list or go further while the solutions have favorable differences. The best solution is always used but if it is worse than the current one we reject the remaining list regardless of the strategy used.

6.5 Value repetition

The algorithm has two security schemes to avoid its path to stake at local optima. In the first, the routine verepet examines the set of the last p values and looks there for q equal ones, calling for a restart if it founds them. Best results have been found with p = 5 and q = 2. The second scheme looks for a given percent of the (specified) iteration number without global improvements and goes through a double restart scheme if this percent is attained.

7 . Some results

Two codes were used in the tests whose results are presented: Code 1, with simple blocking and use of a single restart solution and Code 2, with tabu blocking and use of several better restart solutions. The tests were run on QAPLIB instances [BKR97], [QAPLIB] and Drezner and new Taillard instances [DHT02]. Both codes used the option of restart after a worse solution.

The programming was done in Fortran 77. The execution times here presented correspond to the use of an onboard computer with an Athlon 2.4 chip. Typical values for both codes, compiled with optimization option, are shown at Figure 4.

The results were quite equilibrated among the two codes with respect to the set of instances utilized. We can distinguish four groups of instances according to the results:

(a) NugXX, SkoXX, WilXX, ThoXX, RouXX, Chr18b and Kra30X: optimal / better known value obtained, or approximation below 1% for greater instances. Low average with good convergence.

(b) EscXX, ScrXX, Els19, Chr12a, Chr18a: like (a) for optimal / better value, higher average.

(c) TaiXXa: better value with approximation over 1% for orders over 40. High averages.

(d) ChrXX with n > 20, DreXX (n < 28) and TaiXXe0x (n = 27, 45, 75), poor general average performance, unstable with respect to size for ChrXX and worsening with size for the other instances.

In the tables that follows we show the results obtained with series of T tests with its/T iterations for each one. The best obtained values (min) and the series averages (avg) are given in percentual difference over the optimal or best known cost value, so the zero entries indicate the algorithm attained this value.

8. Conclusions

8.1 Discussion

For many instances, specially those from Group (a), the instance order does not sensibly influence the performance, which is an interesting characteristic of the method. This can be seen quite well with the instances SkoXX.

Group (b) goes well from the same point of view for the best value found but the average suffers the influence of high-valued differences when compared to best known value, as it can be seen with EscXX instances.

Group (c) seems to show failed approaches, probably owing to the presence of many bad solutions around good ones, local optima at which the algorithm stakes. This should ask for local approach improvement.

Group (d) seems to show an influence of the arborescence structure in the polynomial instances ChrXX, which offers difficulties for heuristic algorithms. Owing to the sparsity of one of their matrices the DreXX instances are also difficult for heuristic methods, despite the fact that they are also polynomial, as tr(Q*) is an optimal value for them. Finally the staged TaiXXe0x instances present difficulties associated to the starting points utilized and also to the easy stacking at local optima. The average values are high owing to the values of these local optima. With some of these instances the second code was able to find an optimum value, while thw first was not.

Some time economy can be obtained through the use of more than one solution from novsol list, but it depends on the instance structure, as for some of them it is frequently difficult to obtain more than one positive difference. The difference in processing time between the two codes corresponds to this economy. The taboo blocking seems to be at least as efficient as the single blocking to avoid path return.

8.2 Further developments

Different restart approaches could be designed: for example, to use the rosace building functions to expand it in order to get a solution set for choosing a restart point. This could eventually give better chances of finding good restarts, specially if we could detect directions of inversion reduction which could be used to build a variable neighborhood.

We could also imagine the use of a path-relinking strategy using a set of good solutions obtained from a test or from three tests run in parallel. This last strategy would present the advantage of producing again three solutions which could be used to continue the process the same way. The speed could be improved by using parallelism on rosace exploration.

Acknowledgements

This work belongs to a research project developed within the Group of Graphs, Combinatorics and Operations Research Applications from COPPE/Federal University of Rio de Janeiro (UFRJ). We are indebted to COPPE/UFRJ and to the National Council for Scientific and Technological Development (CNPq), whose sponsorship was essential for the consecution of the stage at the PRISM Laboratory, University of Versailles at St. Quentin-en-Yvelines, where we developed the basic work from where this paper was written. We are also indebted to the colleagues of PRISM who gave support to our work, specially Catherine Roucairol, Van-Dat Cung, Adriana Alvim and Thierry Mautor. Finally, we are grateful for the very useful criticism and suggestions from the anonymous referees.

[QAPLIB] QAPLIB Home Page: <http://www.opt.math.tu-graz.ac.at/qaplib/>.

Recebido em 08/2002; aceito em 08/2003

Received August 2002; accepted August 2003

• [Ab84] Abreu, N.M.M. (1984). An algebraic and combinatorial study of the quadratic assignment problem on the sense of Koopmans and Beckmann (in Portuguese). D.Sc. Thesis, COPPE/UFRJ.
• [AB63] Armour, G.C. & Buffa, E.S. (1963). Heuristic algorithm and simulation approach to relative location of facilities. Man. Sci., 9, 294-309.
• [ABQG02] Abreu, N.M.M.; Boaventura Netto, P.O.; Querido, T.M. & Gouvêa, E.F. (2002). Classes of quadratic assignment instances: isomorphism and difficulty measures using a statistical approach. Discr. Appl. Maths., 124, 103-116.
• [AHS01] Arkin, E.M.; Hassin, R. & Sviridenko, M. (2001). Approximating the maximum quadratic assignment problem. Inf. Proc. Lett., 77(1), 13-16.
• [An96] Anderson, E.J. (1996). Mechanisms for local search. EJOR, 88, 139-151.
• [AQB99] Abreu, N.M.M.; Querido, T.M. & Boaventura-Netto, P.O. (1999). RedInv-SA: A simulated annealing for the quadratic assignment problem. RAIRO Opns. Res., 33, 249-273.
• [AOT00] Ahuja, R.; Orlin, J.B. & Tivari, A. (2000). A greedy genetic algorithm for the quadratic assignment problem. Comp. Opns. Res., 27, 917-937.
• [BAV62] Buffa, E.S.; Armour, G.C. & Vollmann, T.E. (1962). Allocating facilities with CRAFT. Harvard Business Review, 42, 136-158.
• [BB83] Burkard, R.E & Bonniger, T. (1983). A heuristic for quadratic boolean programs with applications to quadratic assignment problems. EJOR, 13, 374-386.
• [BÇ95] Burkard, R.E. & Çela, E. (1995). Heuristics for biquadratic assignment problems and their computational comparison. EJOR, 83(2), 283-300.
• [Br84] Bruijs, P.A. (1984). On the quality of heuristic solutions to a 19 x 19 quadratic assignment problem. EJOR, 17, 21-30.
• [Bu91] Burkard, R.E. (1991). Locations with spatial interactions: the quadratic assignment problem, Discrete Location Theory. John Wiley & Sons, New York, 387-437.
• [BR94] Battiti, R. & Tecchiolli, G. (1994). The reactive tabu search. ORSA J. Comp., 126-140.
• [Be68] Berge, C. (1968). Principes de combinatoire Dunod, Paris.
• [Be73] Berge, C. (1973). Graphes et hypergraphes 2^ème édition. Dunod, Paris.
• [BKR97] Burkard, R.E.; Karisch, S.E & Rendl, F. (1997). QAPLIB A quadratic assignment problem library. J. Global Opt., 10, 391-403.
• [Bo01] Boaventura-Netto, P.O. (2001). Graphs: theory, models, algorithms (in Portuguese). Ed. Edgard Blucher, São Paulo.
• [CMMT97] Cung, V-D; Mautor, T.; Michelon, P. & Tavares, A. (1997). A scatter search based approach for the quadratic assignment problem. Proc. IEEE Int. Conf. on Evolutionary Computation, 165-169.
• [Çe98] Çela, E. (1998). The quadratic assignment problem Kluwer, Dordrecht.
• [DHT02] Drezner, Z.; Hahn, P. & Taillard, E. (2002). A study of quadratic assignment problem instances that are difficult for meta-heuristic methods. Invited for submission to Ann. Opns. Res.: State of the Art and Recent Advances in Integer Programming. Available at Internet: <http://www.seas.upenn.edu/~hahn/new_instances.html>.
• [GP66] Gavett, J.W. & Plyter, N.V. (1966). The optimal assignment of facilities to locations by branch-and-bound. Opns. Res., 14, 210-232.
• [GY02] Gutin, G. & Yeo, A. (2002). Polynomial approximation algorithms for TSP and QAP with a factorial domination number. Discr. Appl. Maths., 119(1-2), 107-116.
• [Ka68] Kaufmann, A. (1968). Introduction à la combinatorique et ses applications. Dunod, Paris.
• [KÇCE00] Karisch, S.E.; Çela, E.; Clausen, J. & Espersen, T. (2000). A dual framework for lower bounds of the quadratic assignment problem based on linearization. SFB Rep. 120, Technical University of Graz / Tech. Rep. IMM-REP-1998-02, Department of Mathematical Modeling, Technical University of Denmark.
• [LB01] Loiola, E.M. & Boaventura-Netto, P.O. (2001). A neighbouring structure for the QAP (in Portuguese). An. XXXIII SBPO, 1288-1297, Campos de Jordão, Brazil, novembre.
• [Lo00] Loiola, E.M. (2000). An algorithm with statistical parameters for the QAP (in Portuguese). M.Sc. Thesis, COPPE/UFRJ, Rio de Janeiro, RJ, Brasil.
• [LS95] Li, W.-J. & Smith, M. (1995). An Algorithm for Quadratic Assignment Problems. EJOR, 81, 205-216.
• [Ma00] Mautor, T. (2000). Application des métaheuristiques au PAQ. Rapport #2000/15, Laboratoire PRISM, Université de Versailles à St. Quentin-en-Yvelines.
• [MO79] Mirchandani, P.B. & Obata, T. (1979). Algorithms for a class of quadratic assignment problems. Presented at the Joint ORSA/TIMS National meeting, New Orleans.
• [QAB99] Querido, T.M.; Abreu, N.M.M. & Boaventura Netto, P.O. (1999). RedInv-SA: a simulated annealing for the quadratic assignment problem. RAIRO Opns. Res., 33, 249-273.
• [RAB00] Rangel, M.C.; Abreu, N.M.M. & Boaventura-Netto, P.O. (2000). GRASP in the QAP: an acceptance bound for initial solutions (in Portuguese). Pesq. Operacional, 20, 45-58.
• [SWH98] Sarker, B.R.; Wilhelm, W.E. & Hogg, G.L. (1998). One-dimensional machine location problems in a multi-product flowline with equidistant locations. EJOR, 105(3), 401-426.
• [SWHH95] Sarker, B.R.; Wilhelm, W.E.; Hogg, G.L. & Han, M.-H. (1995). Backtracking of jobs in one-dimensional machine location problems. EJOR, 85(3), 593-609.
• [TB98] Tansel, B.C. & Bilen, C. (1998). Move based heuristics for the unidirectional loop network layout problem. EJOR, 108(1), 36-48.
• [THKG98] Talbi, E.-G.; Hafidi, Z.; Kebbal, D. & Geib, J.-M. (1998). A fault-tolerant parallel heuristic for assignment problems. Fut. Gen. Comp. Sys., 14(5-6), 425-438.
• [TRFR01] Talbi, E.G.; Roux, O.; Fonlupt, C. & Robillard, D. (2001). Parallel ant colonies for the quadratic assignment problem. Fut. Gen. Comp. Sys., 17, 441-449.
• [TS95] Tate, D.E. & Smith, A.E. (1995). A genetic approach for the quadratic assignment problem. Comp. Opns. Res., 22, 73-83.
• [We83] West, D.H. (1983). Algorithm 608: Approximate solution of the quadratic assignment problem. ACM Trans. Math. Softw., 9, 461-466.
• [YSA03] Youssef, H.; Sait, S.M. & Ali, H. (2003). Fuzzy simulated evolution algorithm for VLSI cell placement. Comp. & Ind. Eng., 44(2), 227-247.

Publication Dates

• Publication in this collection
  13 Feb 2004
• Date of issue
  Dec 2003

History

• Accepted
  Aug 2003
• Received
  Aug 2002