Documente Academic
Documente Profesional
Documente Cultură
DOI 10.1007/s10732-013-9234-x
Abstract The single row facility layout problem (SRFLP) is the problem of arranging
facilities with given lengths on a line, with the objective of minimizing the weighted
sum of the distances between all pairs of facilities. The problem is NP-hard and
research has focused on heuristics to solve large instances of the problem. In this
paper we present a scatter search algorithm to solve large size SRFLP instances. Our
computational experiments show that the scatter search algorithm is an algorithm of
choice when solving large size SRFLP instances within limited time.
Keywords Facilities planning and design Single row facility layout
Scatter search Heuristics
1 Introduction
In the single row facility layout problem (SRFLP), we are given a set F = {1, 2, . . . , n}
of n > 2 facilities, the length l j of each facility j F, and a weight ci j for each pair
(i, j) of facilities, i, j F, i = j. The objective of the problem is to find a permutation
of facilities in F that minimizes the total cost given by the expression
z( ) =
ci j di j ,
1i< jn
R. Kothari (B)
HSBC, HSBC House, HDPI, Kolkata 700091, India
e-mail: ravikothari@iimahd.ernet.in
D. Ghosh
P&QM Area, IIM Ahmedabad, Ahmedabad 380015, India
e-mail: diptesh@iimahd.ernet.in
123
126
R. Kothari, D. Ghosh
where di j is the distance between the centroids of the facilities i and j when arranged
according to the permutation . The cardinality of F is called the size of the problem.
The objective of the SRFLP is to arrange the facilities in F on a line so as to minimize
the weighted sum of the distances between all pairs of facilities. This problem is known
to be NP-hard (Beghin-Picavet and Hansen 1982). The SRFLP was first proposed by
Simmons (1969) and since then it has been used to model a number of applications.
It has been used to design the arrangements of rooms in hospitals, departments in
office buildings and supermarkets (Simmons 1969), to arrange machines in flexible
manufacturing systems (Heragu and Kusiak 1988), to assign files to disk cylinders in
computer storage, and to design warehouse layouts (Picard and Queyranne 1981). A
detailed review of the literature on SRFLP has been provided by Kothari and Ghosh
(2012b) and Anjos and Liers (2012).
Since the SRFLP is NP-Hard, researchers have used many exact and approximate
approaches to solve the problem. Exact approaches include branch and bound (Simmons 1969), integer programming (Love and Wong 1976; Heragu and Kusiak 1991;
Amaral 2006, 2008), cutting planes (Amaral 2009), dynamic programming (Picard
and Queyranne 1981), branch and cut (Amaral and Letchford 2012), and semidefinite programming (Anjos et al. 2005; Anjos and Vannelli 2008; Anjos and Yen 2009;
Hungerlnder and Rendl 2013). Currently, the best exact algorithms are those of Amaral (2009) and Hungerlnder and Rendl (2013). The method used by Hungerlnder and
Rendl (2013) has been able to obtain optimal solutions to SRFLP instances with up
to 40 facilities and to one instance with 42 facilities. The 42 facility SRFLP instance
is the largest one for which an optimal solution is known in the literature. Polyhedral studies for the SRFLP are presented by Sanjeevi and Kianfar (2010) and Amaral
and Letchford (2012). In addition, the heuristics presented by Amaral and Letchford
(2012) and Hungerlnder and Rendl (2013) output high-quality feasible solutions for
the SRFLP.
Researchers have focused on approximate approaches or heuristics to solve large
size SRFLP instances. Heuristics are of two types, construction and improvement.
Construction heuristics for the SRFLP have been proposed by Djellab and Gourgand
(2001), Heragu and Kusiak (1988), and Kumar et al. (1995). However, improvement
heuristics have superseded these construction heuristics in the literature and have
yielded the best known solutions for large size SRFLP instances. Most improvement
heuristics for the SRFLP are metaheuristics which are either single solution approaches
or population approaches. Single solution based heuristics include simulated annealing (Gomes de Alvarenga et al. 2000; Romero and Snchez-Flores 1990; Heragu and
Alfa 1992), tabu search (Gomes de Alvarenga et al. 2000; Samarghandi and Eshghi
2010; Kothari and Ghosh 2013c), and local search with LinKernighan neighborhood (Kothari and Ghosh 2013b). Population heuristics for SRFLP include ant colony
optimization (Solimanpur et al. 2005), scatter search (Kumar et al. 2008), particle
swarm optimization (Samarghandi et al. 2010), and genetic algorithm (Datta et al.
2011; Ozcelik 2011; Kothari and Ghosh 2013a). Among these the genetic algorithms
by Ozcelik (2011) and Kothari and Ghosh (2013a) yield best results for benchmark
SRFLP instances of large sizes.
Scatter search has been shown to yield promising results for solving various nonlinear and combinatorial optimization problems (see Laguna and Marti 2003; Marti
123
127
123
128
R. Kothari, D. Ghosh
scatter search algorithms. Both these methods require an initial seed permutation of
facilities in F as an input for generating the initial population.
In the DIV-1 method, starting from the initial seed permutation = (1, 2, . . . , n),
we generate a large set of permutations with cardinality U _Si ze by randomly interchanging facilities in . We then choose E_Si ze lowest cost permutations from the
set to form a set of elite permutations. We generate the initial population of size
P_Si ze by choosing permutations from the elite set in a way such that the minimum distance between any two permutations in the population is as high as possible.
To do this, we first find out those two permutations among the elite permutations
between which the deviation distance is the largest. We move these two permutations
from the set of elite permutations to the initial population. We then perform the following iteration until the we have P_Si ze permutations in the initial population. In
an iteration, for each permutation in the elite permutation set we compute the minimum of the distances between it and members of the initial population. We then
move that permutation which has the maximum value of minimum distance from the
elite permutation set to the initial population. The parameters U _Si ze, E_Si ze, and
P_Si ze are specified by the user. The pseudocode for the DIV-1 method is given
below.
ALGORITHM DIV-1
Input: An SRFLP instance with n facilities, U _Si ze, E_Si ze, and P_Si ze.
Output: The initial population with P_Si ze permutations.
Code
1. begin
2.
set {1, 2, 3, . . . , n}; U _List, E_List, P_List ;
3.
for i from 1 to U _Si ze do begin
4.
set Pi ;
5.
for j from 1 to n/2 do begin
6.
r random number chosen from [0, 1];
7.
if (r 0.5) then interchange Pi [ j] and Pi [n j];
8.
end;
9.
U _List U _List {Pi };
10.
end;
11.
sort the permutations in U _List in non-decreasing order of their costs;
12.
copy the first E_Si ze permutations in U _list to E_List;
13.
for each pair of permutations i and j in E_List compute the
deviation distance Di j between them;
14.
set {i, j} = arg max{Di j |i , j E_List};
15.
set P_List {i , j }; PCount 2;
16.
while PCount < P_Si ze do begin
17.
for each i E_List do
18.
set M Di min{Di j | j P_List};
19.
set k arg max{M Di }; P_List P_List {k };
E_List E_List \ {k }; PCount PCount + 1;
20.
end;
21.
output P_List;
22. end.
123
129
In the DIV-2 method, we generate the initial seed permutation using Theorem 1
by Samarghandi and Eshghi (2010). A distance value H _Dist is taken as an input. We
first include in the initial population. We then generate permutations by randomly
interchanging facilities in , and include these permutations in the initial population
only if the distance between the newly generated permutation and each of the permutations in the initial population is at least H _Dist. The method stops when we
have the required number of permutations in the initial population. The pseudocode
for the DIV-2 method is given below. Note that steps 2 through 14 in the algorithm
operationalize Theorem 1 by Samarghandi and Eshghi (2010).
ALGORITHM DIV-2
Input: An SRFLP instance with n facilities, P_Si ze, and H _Dist.
Output: The initial population with P_Si ze permutations.
Code
1. begin
2.
arrange the facilities in non-increasing order of their lengths;
/* with i denoting the i-th facility in this order. */
3.
for i from 1 to n/2 do
4.
set [i] = 2 n i + 1;
5.
for i from 1 to
n/2 do
6.
set [n/2 + i] = 2i 1;
7.
set P_List { }; PCount 1;
8.
while PCount < P_Si ze do begin
9.
set Pi ;
10.
for j from 1 to n/2 do begin
11.
r random number chosen from [0, 1];
12.
if (r 0.5) then interchange Pi [ j] and Pi [n j];
13.
end;
14.
for all i P_List do
15.
set M Di deviation distance between Pi and i ;
16.
if (mini {M Di } > H _dist) then begin
17.
set P_List P_List {Pi }; PCount PCount + 1;
18.
end;
19.
end;
20.
output P_List;
21. end.
2.2 Improvement method
The improvement method tries to improve upon the permutations in the initial population and the permutations obtained by the solution combination method at later stages
of the algorithm. In our scatter search algorithms we use local search iterations with
an insertion neighborhood to improve the permutations. An insertion neighbor of a
permutation is obtained by removing a facility from its position and introducing it at
another position in the permutation. A local search iteration searches all the insertion
neighbors of a permutation and returns the best insertion neighbor of the permutation.
123
130
R. Kothari, D. Ghosh
123
131
The first combination method is the alternating combination method (see e.g.,
Larraaga et al. 1999). It creates a new permutation by alternately selecting facilities from the first permutation and the second permutation in the subset, omitting the
facilities that have already been located in the new permutation. The second combination method is the partially matched combination method. It is similar to the PMX
crossover (see e.g., Larraaga et al. 1999), and is the most widely used combination
operator for permutation problems.
Having described the components of scatter search we are now in a position to
describe a generic scatter search algorithm for the SRFLP. It starts by generating an
initial population of permutations using a diversification generation method. It then
uses an improvement method to improve the permutations in the initial population
and builds a reference set using the reference set update method. The algorithm then
performs iterations consisting of three steps till the reference set converges. In the first
step it creates subsets of the reference set using a subset generation method. In the
second step, for each of the subsets, it combines the permutations in the subset using a
solution combination method to create one permutation corresponding to each subset.
All of these permutations are then improved using the improvement method. In the
third step it tries to update the reference set using these improved permutations. An
improved permutation replaces the highest cost permutation in the reference set if its
cost is lower than that of the latter. If none of the improved permutations enter the
reference set in the third step, then the reference set is said to have converged and the
scatter search algorithm terminates after reporting the lowest cost permutation in the
reference set. The pseudocode for scatter search algorithm is given below.
ALGORITHM GENERIC-SS
Input: An SRFLP instance with n facilities, B1, B2, B, H _Dist, U _Si ze,
E_Si ze and P_Si ze.
Output: The best permutation which has the lowest cost among all the
permutations encountered in the algorithm.
Code
1. begin
2.
generate an initial population with P_Si ze permutations using the
diversification generation method DIV-1/DIV-2;
3.
improve each permutation in population using the improvement method;
4.
sort the improved permutations in the population in non-decreasing
order of their costs;
5.
choose first B1 and last B2 permutations in the sorted list to
construct the reference set RefSet;
6.
set flag TRUE;
7.
while flag = TRUE do
8.
create all subsets
of size 2 using the permutations in the RefSet;
9.
for i from 1 to B2 do begin
10.
flag TRUE;
11.
generate a permutation using the solution combination method
on the ith subset generated from the RefSet;
123
132
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
R. Kothari, D. Ghosh
The computational complexity of the GENERIC-SS algorithm depends on the relative magnitudes of B and n. In scatter search algorithms, the size B of the reference set
is kept small, so that each scatter search iteration (Steps 7 through 21 in the pseudocode)
does not take too long to execute. The critical step in each iteration is Step 12 which
takes an amortized O(n 3 ) time (see Kothari and Ghosh 2013b,c). Assuming that B is
much smaller than n, each scatter search iteration requires O(B 2 n 3 ) time.
Note that a scatter search algorithm called SS was presented for the SRFLP in
Kumar et al. (2008). The algorithm presented here differs from SS in several ways.
First, the diversification generation method in SS is one presented in Glover (1998).
The algorithm presented here uses one of two different diversification generation
methods (DIV-1 and DIV-2) based on the concept of deviation distance proposed in
Srensen (2007). Second, the SS algorithm uses a left and right insertion neighborhood
search to improve solutions. Our algorithm on the other hand performs an exhaustive
search in the insertion neighborhood to obtain the best insertion neighbor. Third, the
SS algorithm generates four subset types in their subset generation method while the
algorithm presented here only generates one subset type, corresponding to SubsetType 1 in Kumar et al. (2008). Finally, the solution combination methods used in the
two algorithms are completely different.
In the next section we present a computational comparison of our algorithm with
the best available in the published literature.
3 Computational experiments
We performed computational experiments with scatter search algorithms to compare
their performance with other methods available in the literature to solve large size
SRFLP instances. We developed four versions of scatter search. All the versions used
the same improvement method, reference set update method, and subset generation
method but differed in diversification generation methods and subset generation methods. The details of the diversification generation methods and solution combination
methods for the four algorithms are given in Table 1.
We coded these algorithms in C and performed our experiments on a personal
computer with four Intel Core i52,500 3.30 GHz processors, 4GB RAM, running
123
Algorithm
133
Diversification generation
Solution combination
Method
Method
SS-1A
DIV-1
Alternating combination
SS-1P
DIV-1
Partially matched
combination
Alternating combination
SS-2A
DIV-2
SS-2P
DIV-2
Partially matched
combination
Ubuntu Linux 11.10. Based on initial experiments we set U _Si ze = 1, 000, E_Si ze =
500, and P_Si ze = 100. For DIV-2 we set the value of H _Dist to n 2 /4 where n is
the size of the instance. Following usual practice we set the size of the reference set
B_Si ze at 20, with B1 = B2 = 10.
Since the four algorithms are very similar in their frameworks, we tested their
performance on randomly generated instances of various sizes. From our experiments
we observed that these algorithms output very similar results. However, SS-1P was
found to be marginally superior to the others for our randomly generated instances. It
often outputs the best solution among the four variants on any given instance. It also
generates its final solution faster than the other variants. For example, Fig. 1 presents
the variation of costs of the solutions obtained by the four algorithms on a randomly
generated instance of size 100.
The solid line in the figure represents the trajectory for SS-1P and the dotted lines
represent the trajectories of the other algorithms. Notice that for this instance, SS-1A
and SS-2A terminated with solutions of larger costs than those output by SS-1P and
SS-2P. Also note that SS-1P obtained this solution after about 320 s of execution
time while SS-2P obtained the solution after about 390 s of execution time. Hence in
our detailed computational experiments with benchmark instances, we used only the
SS-1P algorithm.
123
134
R. Kothari, D. Ghosh
We experimented with three sets of benchmark SRFLP instances. The first set is due
to Anjos et al. (2005) and consists of four groups of five instances each of size 60, 70,
75, and 80. We refer to these as the Anjos instances. These instances have been widely
experimented with in the published literature (see e.g., Datta et al. 2011; Hungerlnder
and Rendl 2013; Ozcelik 2011; Kothari and Ghosh 2013b). The second set of instances
are QAP-based sko instances. This set consists of seven groups of five instances each
of size 42, 49, 56, 64, 72, 81, and 100. They have been experimented with in the
literature by Anjos and Yen (2009), Amaral and Letchford (2012), Hungerlnder and
Rendl (2013), and Kothari and Ghosh (2013a). We refer to them as the sko instances.
The third set is due to Letchford and Amaral (2011) and consists of three instances of
size 110 each. They have been experimented with by Letchford and Amaral (2011),
Ozcelik (2011) and Hungerlnder and Rendl (2013) and we refer to them as the Amaral
instances.
123
135
Size
SS-1P
Anjos-60-01
60
1477834.0
1477834.0
Anjos-60-02
60
841776.0
841776.0
Anjos-60-03
60
648337.5
648337.5
Anjos-60-04
60
398406.0
398406.0
Anjos-60-05
60
318805.0
318805.0
Anjos-70-01
70
1528537.0
1528537.0
Anjos-70-02
70
1441028.0
1441028.0
Anjos-70-03
70
1518993.5
1518993.5
Anjos-70-04
70
968796.0
968796.0
Anjos-70-05
70
4218002.5
4218002.5
Anjos-75-01
75
2393456.5
2393456.5
Anjos-75-02
75
4321190.0
4321190.0
Anjos-75-03
75
1248423.0
1248423.0
Anjos-75-04
75
3941816.5
3941816.5
Anjos-75-05
75
1791408.0
1791408.0
Anjos-80-01
80
2069097.5
2069097.5
Anjos-80-02
80
1921136.0
1921136.0
Anjos-80-03
80
3251368.0
3251368.0
Anjos-80-04
80
3746515.0
3746515.0
Anjos-80-05
80
1588885.0
1588885.0
1981690.6
1981690.6
a Refers to the costs reported by Ozcelik (2011), Kothari and Ghosh (2013a,b,c)
From the table we see that on average, SS-1P requires 56.57 % of the time required
by the algorithm in Kothari and Ghosh (2013b) on these problems and is thus significantly faster.
3.2 Testing with sko instances
In the published literature, results of computational experiments with sko instances
have been reported by Amaral and Letchford (2012), Anjos and Yen (2009), Hungerlnder and Rendl (2013), Ozcelik (2011), Kothari and Ghosh (2013a,b,c) ). Not all
the studies experiment with all the sko instances. Amaral and Letchford (2012) use a
polyhedral approach, Anjos and Yen (2009) and Hungerlnder and Rendl (2013) use
SDP-relaxation based approaches, Ozcelik (2011) and Kothari and Ghosh (2013a) use
genetic algorithms, and Kothari and Ghosh (2013b) use a LinKernighan based local
search heuristic to experiment with these instances. In Table 4 we compare the costs
of the permutations output by the SS-1P algorithm with the best costs from the literature. The first and second columns of the table present details about the instances, the
third column presents the best costs known in the published literature, and the fourth
column presents the corresponding source. The fifth column presents the costs of the
permutations output by the SS-1P algorithm.
123
136
R. Kothari, D. Ghosh
Size
SS-1P
Anjos-60-01
60
57.35
46.73
Anjos-60-02
60
57.00
41.54
Anjos-60-03
60
45.90
50.4
Anjos-60-04
60
55.52
53.52
Anjos-60-05
60
55.15
52.35
Anjos-70-01
70
118.57
82.61
Anjos-70-02
70
123.34
88.16
Anjos-70-03
70
155.67
83.17
102.26
Anjos-70-04
70
143.78
Anjos-70-05
70
114.40
81.59
Anjos-75-01
75
257.13
127.66
Anjos-75-02
75
226.60
118.01
Anjos-75-03
75
256.81
143.69
Anjos-75-04
75
246.16
125.37
Anjos-75-05
75
257.16
138.71
Anjos-80-01
80
336.25
162.59
Anjos-80-02
80
375.93
174.8
Anjos-80-03
80
312.32
181.84
Anjos-80-04
80
306.22
148.41
Anjos-80-05
80
392.86
199.79
194.72
110.16
a Refers to the times required by LinKernighan algorithm in Kothari and Ghosh (2013b)
The results in Table 4 show that for 30 of the 35 instances, the costs of the solutions output by the SS-1P algorithms match the best known for these instances in the
literature. For four of the instances, the costs output by SS-1P are marginally worse
than the best costs known in the literature, and in one of the instances, the cost output
of SS-1P is better. The difference in costs of solutions output by SS-1P and those of
the previously known best solutions is never more than 0.004 % of the costs of the
previously known best solutions.
We next compare the execution times required by the previously known best algorithms in the literature and the SS-1P algorithm on the sko instances. In some of
the instances, several algorithms output the currently known best cost solutions. For
these instances we consider the times corresponding to that algorithm which required
the least time. Allowing for differences in computational set ups, the algorithms presented in Kothari and Ghosh (2013a,b) are the fastest among the algorithms in the
literature for these problems. For each of the instances, we ran the codes for the
algorithm among the ones reported in Kothari and Ghosh (2013a,b) which generated the least cost solution to the instance and the code for SS-1P on the same
machine, and report their execution times in Table 5. The first two columns in the
table describe the instance, the third column reports the total time required on the
123
137
Size
Sourcea
SS-1P
sko-42-01
42
25525.0
H&R, KGA
25525.0
sko-42-02
42
216120.5
H&R, KGA
216120.5
sko-42-03
42
173267.5
173267.5
sko-42-04
42
137615.0
H&R, KGA
137615.0
sko-42-05
42
248238.5
248238.5
sko-49-01
49
40967.0
sko-49-02
49
416178.0
H&R, KGA
416178.0
sko-49-03
49
324512.0
H&R, KGA
324512.0
sko-49-04
49
236755.5
H&R, KGA
236755.5
sko-49-05
49
666143.0
H&R, KGA
666143.0
sko-56-01
56
64024.0
sko-56-02
56
496561.0
H&R, KGA
496561.0
sko-56-03
56
170449.0
KGA
170449.0
sko-56-04
56
313388.0
KGA
313388.0
sko-56-05
56
592294.5
KGA
592316.5
sko-64-01
64
96881.0
KGA
96883.0
KGA
KGA
40967.0
64024.0
sko-64-02
64
634332.5
sko-64-03
64
414323.5
LKI, KGA
414323.5
sko-64-04
64
297129.0
KGA
297129.0
sko-64-05
64
501922.5
A&L,2
501922.5
sko-72-01
72
139150.0
LKI, KGA
139150.0
sko-72-02
72
711998.0
KGA
711998.0
634332.5
sko-72-03
72
1054110.5
sko-72-04
72
919586.5
KGA
sko-72-05
72
428226.5
KGA
428226.5
sko-81-01
81
205108.5
KGA
205106.0
sko-81-02
81
521391.5
LKI, KGA
521391.5
sko-81-03
81
970796.0
KGA
970796.0
sko-81-04
81
2031803.0
KGA
2031803.0
sko-81-05
81
1302711.0
KGA
1302711.0
sko-100-01
100
378234.0
OZ, KGA
sko-100-02
100
2076008.5
OZ, KGA
sko-100-03
100
16145598.0
sko-100-04
100
3232522.0
OZ, KGA
3232531.0
sko-100-05
100
1033080.5
OZ, KGA
1033080.5
1063341.5
KGA
1054110.5
919586.5
378234.0
2076008.5
16145614.0
1063342.8
Cost in boldface indicate the improvement of SS-1P over the published literature
a A&L, H&R, OZ, TS, LKI, and KGA refer to Amaral and Letchford (2012), Hungerlnder and Rendl
(2013), Ozcelik (2011), Kothari and Ghosh (2013a,b,c) ), respectively
1 H&R, A&L and KGA
2 TS, LKI and KGA
123
138
R. Kothari, D. Ghosh
Table 5 Execution times (in seconds) of scatter search algorithms for sko instances
Instance
Size
Sourcea
SS-1P
sko-42-01
42
658.00
KGA
11.42
sko-42-02
42
680.00
KGA
16.60
sko-42-03
42
680.00
KGA
15.40
sko-42-04
42
668.00
KGA
12.10
sko-42-05
42
636.00
KGA
11.16
sko-49-01
49
1172.00
KGA
25.40
sko-49-02
49
1100.00
KGA
27.86
sko-49-03
49
1108.00
KGA
24.07
sko-49-04
49
1146.00
KGA
25.67
sko-49-05
49
1106.00
KGA
22.45
sko-56-01
56
1920.00
KGA
48.61
sko-56-02
56
1708.00
KGA
42.12
sko-56-03
56
1692.00
KGA
47.05
sko-56-04
56
1780.00
KGA
43.50
sko-56-05
56
1662.00
KGA
36.94
82.80
sko-64-01
64
3074.00
KGA
sko-64-02
64
2796.00
KGA
68.31
sko-64-03
64
96.32
LKI
80.33
sko-64-04
64
2856.00
KGA
91.05
sko-64-05
64
87.90
LKI
75.86
sko-72-01
72
194.06
LKI
115.21
sko-72-02
72
4598.00
KGA
192.12
sko-72-03
72
179.94
LKI
114.16
sko-72-04
72
4460.00
KGA
135.46
sko-72-05
72
4656.00
KGA
116.50
sko-81-01
81
8148.00
KGA
311.63
sko-81-02
81
519.89
LKI
226.91
sko-81-03
81
7176.00
KGA
241.50
sko-81-04
81
7498.00
KGA
193.98
sko-81-05
81
7188.00
KGA
287.22
sko-100-01
100
19868.00
KGA
877.12
sko-100-02
100
17220.00
KGA
526.09
sko-100-03
100
16474.00
KGA
599.92
sko-100-04
100
16122.00
KGA
592.00
sko-100-05
100
16926.00
KGA
4510.12
591.75
169.44
instance by the best algorithm previously known in the literature, the fourth column
reports the source of this algorithm. The fifth column reports the time required by the
SS-1P algorithm.
123
139
From the table we see that SS-1P requires on average, 3.76 % of the execution
times required by the fastest algorithms known previously and is thus significantly
faster. This, combined with the fact that SS-1P generates the lowest cost solutions
to all but one of these instances make it the algorithm of choice for solving the sko
instances. Among the other algorithms known in the literature, the LinKernighan
based local search algorithm presented in Kothari and Ghosh (2013b) is the fastest for
these problems, but it does not output the best solutions to most of the sko instances.
3.3 Testing with instances from Letchford and Amaral (2011) with 110 facilities
Results for the Amaral instances have been reported by Letchford and Amaral (2011),
Ozcelik (2011), Hungerlnder and Rendl (2013), Kothari and Ghosh (2013a,b,c) ), in
the literature. Among these, the best results are reported by Ozcelik (2011). In Table 6
we report the best costs output by SS-1P on Amaral instances. The structure of Table 6
is the same as that of Table 4.
We see from the table that the costs reported by Ozcelik (2011) supersede those
output by the SS-1P algorithm. In only one of the instances the cost of the SS-1P
output matches the cost reported by Ozcelik (2011).
Table 7 compares the execution times required by the previously best known algorithms with those required by the SS-1P algorithm on the Amaral instances. To ensure
fairness of comparison, we multiply the average execution time per run reported in
Ozcelik (2011) by 20 and that reported in Kothari and Ghosh (2013a) by 200 to obtain
the total execution times. The structure of the table is similar to that of Table 5 presented earlier. We see that on average, the SS-1P algorithm required 0.90 % of the
times required by the genetic algorithms in Ozcelik (2011) and Kothari and Ghosh
Size
Best costs in
literature
Sourcea
SS-1P
Amaral-110-01
110
144296664.5
OZ
144297440.0
Amaral-110-02
110
86050037.0
OZ
86050208.0
Amaral-110-03
110
2234743.5
KGA, OZ
77527148.3
2234798.5
77527482.2
a OZ and KGA refer to Ozcelik (2011) and Kothari and Ghosh (2013a) respectively
Size
Sourcea
SS-1P
Amaral-110-01
110
124701.60
OZ
975.11
Amaral-110-02
110
124062.00
OZ
680.10
Amaral-110-03
110
23804.00
KGA
90855.87
811.08
822.10
a OZ and KGA refer to Ozcelik (2011) and Kothari and Ghosh (2013a) respectively
123
140
R. Kothari, D. Ghosh
(2013a) for these instances. Although the experimental set up in Ozcelik (2011) is
different from that in the current work and in Kothari and Ghosh (2013a), the difference between the execution times suggest that SS-1P is significantly faster for these
problems than existing algorithms.
Based on results from our computational experiments, we conclude that the SS-1P
algorithm presented in this paper is competitive for solving large size SRFLP instances
and is to be especially preferred in presence of time restrictions while solving these
instances.
123
141
facility layout problems such as the double row facility layout problem (see Chung
and Tanchoco 2010) or the corridor allocation problem (see Amaral 2012).
5 Appendix
The permutation of facilities for the instance sko-81-01 for which the SS-1P algorithm
improved the best solution known in the literature is given below. The facilities are
numbered from 1 through 81.
66 74 3 61 30 25 50 9 48 56 67 65 33 69 23 17 4 6 41 21 81 14 15 19 38 49 31 7 39
36 26 70 35 42 22 55 11 57 78 44 2 45 52 32 68 13 62 1 5 27 58 20 18 73 43 59 24
51 37 63 12 79 75 80 77 71 72 29 64 46 28 10 40 34 76 16 54 53 60 47 8
References
Amaral, A.R.S.: On the exact solution of a facility layout problem. Eur. J. Oper. Res. 173(2), 508518
(2006)
Amaral, A.R.S.: An exact approach to the one-dimensional facility layout problem. Oper. Res. 56(4),
10261033 (2008)
Amaral, A.R.S.: A new lower bound for the single row facility layout problem. Discret. Appl. Math. 157(1),
183190 (2009)
Amaral, A.R.S., Letchford, A. N.: A polyhedral approach to the single row facility layout problem. Math.
Programm. doi:10.1007/s10107-012-0533-z (2012)
Amaral, A.R.S.: The corridor allocation problem. Comput. Oper. Res. 39(12), 33253330 (2012)
Anjos, M.F., Kennings, A., Vannelli, A.: A semidefinite optimization approach for the single-row layout
problem with unequal dimensions. Discret. Optim. 2(2), 113122 (2005)
Anjos, M.F., Liers, F.: Handbook on Semidefinite, Cone and Polynomial Optimization, volume 166 of
International Series in Operations Research & Management Science, chapter Global Approaches for
Facility Layout and VLSI Floorplanning, pp. 849877. Springer, Berlin (2012)
Anjos, M.F., Vannelli, A.: Computing globally optimal solutions for single-row layout problems using
semidefinite programming and cutting planes. Inf. J. Comput. 20(4), 611617 (2008)
Anjos, M.F., Yen, G.: Provably near-optimal solutions for very large single-row facility layout problems.
Optim. Methods Softw. 24(45), 805817 (2009)
Beghin-Picavet, M., Hansen, P.: Deux problmes daffectation non linaires. RAIRO Recherche Oprationnelle 16(3), 263276 (1982)
Chung, J., Tanchoco, J.: The double row layout problem. Int. J. Prod. Res. 48(3), 709727 (2010)
Datta, D., Amaral, A.R.S., Figueira, J.R.: Single row facility layout problem using a permutation-based
genetic algorithm. Eur. J. Oper. Res. 213(2), 388394 (2011)
Djellab, H., Gourgand, M.: A new heuristic procedure for the single-row facility layout problem. Int. J.
Comput. Integr. Manuf. 14(3), 270280 (2001)
Glover, F.: Heuristics for integer programming using surrogate constraints. Decis. Sci. 8(1), 156166 (1977)
Glover, F.: Tabu search for nonlinear and parametric optimization (with links to genetic algorithms). Discret.
Appl. Math. 49, 231255 (1994)
Glover, F.: Scatter search and star-paths: beyond the genetic metaphor. OR Spectr. 17, 125137 (1995).
doi:10.1007/BF01719256
Glover, F.: A template for scatter search and path relinking. Lect. Notes Comput. Sci. 1363, 1354 (1998)
Glover, F., Laguna, M., Mart, R.: Fundamentals of scatter search and path relinking. Control Cybern. 39,
653684 (2000)
Gomes de Alvarenga, A., Negreiros-Gomes, F.J., Mestria, M.: Metaheuristic methods for a class of the
facility layout problem. J. Intell. Manuf. 11, 421430 (2000)
Heragu, S.S., Alfa, A.S.: Experimental analysis of simulated annealing based algorithms for the layout
problem. Eur. J. Oper. Res. 57(2), 190202 (1992)
Heragu, S.S., Kusiak, A.: Machine layout problem in flexible manufacturing systems. Oper. Res. 36(2),
258268 (1988)
123
142
R. Kothari, D. Ghosh
Heragu, S.S., Kusiak, A.: Efficient models for the facility layout problem. Eur. J. Oper. Res. 53, 113 (1991)
Hungerlnder, P., Rendl, F.: A computational study and survey of methods for the single-row facility layout
problem. Comput. Optim. Appl. 55(1), 120 (2013)
Kothari, R., Ghosh, D.: Path relinking algorithms for single row facility layout (w.p. no. 201205-01).
Ahmedabad, India: IIM Ahmedabad, Production & Quantitative Methods. Available at (2012a) http://
www.iimahd.ernet.in/assets/snippets/workingpaperpdf/6038336162012-05-01.pdf
Kothari, R., Ghosh, D.: The single row facility layout problem: state of the art. Opsearch 49, 442462
(2012b)
Kothari, R., Ghosh, D.: An efficient genetic algorithm for single row facility layout. Optim. Lett.10.1007/
s11590-012-0605-2 (2013a)
Kothari, R., Ghosh, D.: Insertion based LinKernighan heuristic for single row facility layout. Comput.
Oper. Res. 40(1), 129136 (2013b)
Kothari, R., Ghosh, D.: Tabu search for the single row facility layout problem using exhaustive 2-opt and
insertion neighborhoods. Eur. J. Oper. Res. 224(1), 93100 (2013c)
Kumar, R.K., Hadjinicola, G.C., Lin, T.-L.: A heuristic procedure for the single-row facility layout problem.
Eur. J. Oper. Res. 87(1), 6573 (1995)
Kumar, S., Asokan, P., Kumanan, S., Varma, B.: Scatter search algorithm for single row layout problem in
fms. Adv. Prod. Eng. Manag. 3(4), 193204 (2008)
Laguna, M., Mart, R.: Scatter Search: Methodology and Implementations in C. Kluwer Academic Publishers, Boston (2003)
Larraaga, P., Kuijpers, C.M.H., Murga, R.H., Inza, I., Dizdarevic, S.: Genetic algorithms for the travelling
salesman problem: a review of representations and operators. Artif. Intell. Rev. 13(2), 129170 (1999)
Letchford, A.N., Amaral, A.R.S.: A polyhedral approach to the single row facility layout problem. Technical
report, The Department of Management Science, Lancaster University, (2011)
Love, R.F., Wong, J.Y.: On solving a one-dimensional space allocation problem with integer programming.
INFOR 14(2), 139144 (1976)
Mart, R., Glover, F., Laguna, M.: Principles of scatter search. Eur. J. Oper. Res. 169(2), 359372 (2006)
Ozcelik, F.: A hybrid genetic algorithm for the single row layout problem. Int. J. Prod. Res. (2011)
Picard, J.-C., Queyranne, M.: On the one-dimensional space allocation problem. Oper. Res. 29(2), 371391
(1981)
Romero, D., Snchez-Flores, A.: Methods for the one-dimensional space allocation problem. Comput. Oper.
Res. 17(5), 465473 (1990)
Samarghandi, H., Eshghi, K.: An efficient tabu algorithm for the single row facility layout problem. Eur. J.
Oper. Res. 205(1), 98105 (2010)
Samarghandi, H., Taabayan, P., Jahantigh, F.F.: A particle swarm optimization for the single row facility
layout problem. Comput. Ind. Eng. 58(4), 529534 (2010)
Sanjeevi, S., Kianfar, K.: A polyhedral study of triplet formulation for single row facility layout problem.
Discret. Appl. Math. 158(16), 18611867 (2010)
Simmons, D.M.: One-dimensional space allocation: an ordering algorithm. Oper. Res. 17(5), 812826
(1969)
Solimanpur, M., Vrat, P., Shankar, R.: An ant algorithm for the single row layout problem in flexible
manufacturing systems. Comput. Oper. Res. 32(3), 583598 (2005)
Srensen, K.: Distance measures based on the edit distance for permutation-type representations. J. Heuristics 13, 3547 (2007). doi:10.1007/s10732-006-9001-3
123