Approximate Approaches to the Traveling Thief Problem

Hayden Faulkner, Sergey Polyakovskiy, Tom Schultz, Markus Wagner

Optimisation and Logistics
School of Computer Science
University of Adelaide, Australia

ABSTRACT thief uses a knapsack of limited capacity and pays rent for it
This study addresses the recently introduced Traveling Thief depending on the overall travel duration. To make the two
Problem (TTP) which combines the classical Traveling components interdependent, the speed of the thief is made
Salesman Problem (TSP) with the 0-1 Knapsack Problem dependent (non-linearly) on the weight of the items picked
(KP). The problem consists of a set of cities, each containing so far. The thief has to visit all cities once and collect items
a set of available items with weights and profits. It involves so that the overall profit is maximized. While it is possible
searching for a permutation of the cities to visit and a deci- to generate solutions for the TTP by combining solutions
sion on items to pick. A selected item contributes its profit for the individual components, such approaches do not nec-
to the overall profit at the price of higher transportation essarily result in near-optimal solutions: (1) each solution
cost incurred by its weight. The objective is to maximize for the TSP hinders the best quality that can be achieved in
the resulting profit. the KP component because of the impact on the profit that
We propose a number of problem-specific packing strate- is a function of travel time, and vice versa (2) each solution
gies run on top of TSP solutions derived by the Chained for the KP component influences the tour time for TSP as
Lin-Kernighan heuristic. The investigations provided on different items impact the speed of travel differently due to
the set of benchmark instances prove their rapidity and ef- the variability of the weights of items.
ficiency when compared with an approximate mixed integer A range of different approaches to the problem have been
programming based approach and state-of-the-art heuristic developed recently. For example, Mei et al. [6] focus on large
solutions from the literature. TTP instances with relatively simple approaches. They an-
alyze the computational complexity of different algorithms
and suggest asymptotic speed-ups. The resulting algorithm
Categories and Subject Descriptors significantly outperforms the three iterative and constructive
G.1.6 [Optimization]: Miscellaneous; I.2.8 [Problem algorithms originally presented in [10]. Bonyadi et al. [4] are
Solving, Control Methods, and Search]: Scheduling the first to attempt to solve both components of the TTP
in parallel, instead of sequentially. The authors design a co-
Keywords evolutionary approach called CoSolver in which modules
responsible for either the TSP part or the KP part communi-
Traveling thief problem; local search; multi-component cate with each other. The proposed CoSolver outperforms
problems a heuristic similar to the constructive heuristic SH from [10].
Mei et al. [7] also investigate a co-evolutionary approach and
1. INTRODUCTION compare it to a memetic algorithm, with the result of the
Recently, a new benchmark problem called the Traveling memetic algorithm outperforming the co-evolutionary one.
Thief Problem (TTP )has been introduced [3] in an attempt Recently, Polyakovskiy et al. [11] investigated a non-linear
to provide an abstraction of problems with multiple inter- knapsack problem that occurs when packing items along a
dependent components. The underlying idea of TTP is to fixed route and taking into account travel time. They ad-
combine the Traveling Salesman Problem (TSP) and the dress the complexity of the problem and show that even the
Knapsack Problem (KP). They both have been intensively capacity unconstrained version is N P-hard. Subsequently,
studied for many years and are the core problems in the they propose exact and approximate mixed integer program-
field of optimization. The TTP comprises a thief stealing ming (MIP) solutions that are able to produce (near-) opti-
items with weights and profits from a number of cities. The mal results for instances of a moderate size.
Despite the state-of-the-art techniques there remains
Permission to make digital or hard copies of all or part of this work for personal or
potential for TTP-specific algorithms based on different
classroom use is granted without fee provided that copies are not made or distributed paradigms. In this article, we provide a set of structurally
for profit or commercial advantage and that copies bear this notice and the full cita- diverse algorithms to effectively solve the entire range of ex-
tion on the first page. Copyrights for components of this work owned by others than isting TTP instances.
ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or re-
publish, to post on servers or to redistribute to lists, requires prior specific permission This article is set out as follows. In Section 2 we outline
and/or a fee. Request permissions from [email protected]. the important features of the Traveling Thief Problem. In
GECCO 15, July 11 - 15, 2015, Madrid, Spain Section 3 we describe our three local search routines, based

c 2015 ACM. ISBN 978-1-4503-3472-3/15/07. . . $15.00 on which we construct heuristic searches in Section 4. Sec-
DOI: http://dx.doi.org/10.1145/2739480.2754716
tion 5 adopts the MIP based approximate approach of [11]
and yields another high-quality technique. In Section 6, we
present and compare their results with the state-of-the-art
solutions. We finish with some concluding remarks.

2. TRAVELING THIEF PROBLEM

In the following, we first describe the TTP as defined
in [10]. Given is a set of cities N = {1, . . . , n} and a set
of items M = {1, . . . , m} distributed among the cities. The
distance dij between any pair of cities i, j N is known. Figure 1: Illustrative Example [10]
Every city i, except the first one, contains a set of items
Mi = {1, . . . , mi }, M = Mi . Each item k positioned in routine is applied to construct an initial packing which is
iN
the city i is characterized by its profit pik and weight wik , further enhanced by a set of local search procedures.
thus the item Iik (pik , wik ). The thief must visit each of
the cities exactly once starting from the first city and return- 3.1 Packing Routine
ing back to it in the end. Any item may be selected in any For greedy heuristics, it is common to utilize a goodness
city as long as the total weight of collected items does not measure of the elements of a problem to make a decision.
exceed the capacity W . A renting rate R is to be paid per Here, we provide our packing heuristic algorithm with a scor-
each time unit taken to complete the tour. Respectively, ing function which generates a score sik for item k placed in
max and min denote the maximal and minimum speeds city i as:
that the thief can move. The goal is to find a tour, along pik
sik = ,
with a packing plan, that results in the maximal profit. wik di
To set up the objective function precisely, let yik {0, 1}
where di is the distance from city i to the end of a given tour
be a binary variable equal to one when the item k is selected
. The function incorporates a trade-off between a distance
in the city i. In addition, let Wi denote the total weight of
that item Iik is to be carried over, its weight and its profit.
collected items when the thief leaves the city i. Therefore,
Depending on a particular instance, it might be beneficial
the objective function for a tour = (x1 , . . . , xn ), xi N
to strengthen the influence of one or more variables of the
and a packing plan P = (y21 , . . . , ynmi ) has the following
function. In this scope, we introduce exponents applied to
form:
n Xmi the weight and the profit of an item to manage their impact.
Thus, the function takes the following form:
X
Z(, P ) = pik yik
i=1 k=1 p
ik
n1
! sik =
.
d xn x1 X dxi xi+1 wik di
R + (1)
max Wxn i=1
max Wxi Our preliminary study shows that keeping the exponent
max min of a distance low relative to the exponents of other two vari-
where = W
is a constant value defined by input ables results in the best objective values. Therefore, we
parameters. The minuend is the sum of all packed items omit using an exponent for the distance variable. Moreover,
profits and the subtrahend is the amount that the thief pays using the same value for the exponents of the profit and
for the knapsacks rent equal to the total traveling time along weight variables often achieves the higher objective values
multiplied by R. when compared to varying exponents between the variables.
A brief numeric example of the TTP problem is provided Algorithm 1 depicts our knapsack packing routine. The
in Figure 1 [10]. Each node but the first has an assigned set constructing process starts by giving a score to each item,
of items. Let us assume that the maximum weight W = 3, and then subsequently sorting the entire set M of the items
the renting rate R = 1 and max and min are set as 1 in non-decreasing order based on their scores. Then, the al-
and 0.1, respectively. Then the optimum objective value gorithm instantiates the control parameters. Since evaluat-
Z(, P ) = 50 for = (1, 2, 4, 3) and P = (0, 0, 0, 1, 1, 0). ing the objective function (1) is time-consuming, especially
Specifically, the thief collects no items traveling from city when complicated by the size of an instance, we introduce a
1 to city 3 via cities 2 and 4. Therefore, this part of the parameter controlling the frequency of the objective value
tour has a cost of 15. In the city 3 only items I32 and I33 recomputation. Thus, the objective value is only evaluated
are picked up, resulting in a total profit of 80. However, each time items have been included for a possible pack-
on the way from city 3 back to city 1 the thiefs knapsack ing. The value of is initialized in relation to the number of
has a weight of 2. This reduces the speed and results in an items m as = bm/ c, where is a given integer constant.
increased cost of 15. Consequently, the final objective value In addition, the current and the best packing plans P and
is Z(, P ) = 80 15 15 = 50. P respectively, are initialized as empty sets. Finally, the
best objective value found so far is set to .
3. LOCAL SEARCH ROUTINES Having been initialized, the algorithm starts the iterative
In this section, we discuss a number of routines used to solution construction process by considering the first item
elaborate a packing plan for a given permutation of the cities I1 M with the largest score. At each iteration k, item k is
. We assume that a TSP tour is the outcome of the added to P if there remains enough free space in the knap-
call of the Chained Lin-Kernighan heuristic [2]1 . A packing sack. Every time items have been considered, the routine
1 computes the objective value Z. When Z is improved, re-
As available at http://www.tsp.gatech.edu/concorde/
downloads/downloads.htm mains the same and the best objective value Z is updated
Algorithm 1 Algorithm 2
Packing Routine Pack (,) Iterative Packing Routine PackIterative (,c,,q)
compute score for each of the items Im M obtain Pl by Pack (,c ) and compute Zl = Z (, Pl )
sort the items of M in non-decreasing order of their scores obtain Pm by Pack (,c) and compute Zm = Z (, Pm )
set the frequency = bm/ c obtain Pr by Pack (,c + ) and compute Zr = Z (, Pr )
set the current packing plan P = and W 0 = 0 set the best packing plan P =
set the best packing plan P = set the counter i = 1
set best objective value Z = while i q do
set the counter k = 1 and set k = 1 if (Zl > Zm ) and (Zr > Zm ) then
while (W 0 < W ) and ( > 1) do if (Zl > Zr ) then
if (W 0 + wk W ) then set Zm = Zl , c = c and P = Pl
add item Ik M to the packing plan P = P {Ik } else
set W 0 = W 0 + wk set Zm = Zr , c = c + and P = Pr
if (k mod = 0) then else if (Zl > Zm ) then
compute the objective value Z = Z (, P ) set Zm = Zl , c = c and P = Pl
if (Z < Z ) then else if (Zr > Zm ) then
restore the packing plan P = P set Zm = Zr , c = c + and P = Pr
set k = k and update W 0 = /2;
set = b/2c obtain Pl by Pack (,c ) and compute Zl =Z(,Pl )
else obtain Pr by Pack (,c+) and compute Zr =Z(,Pr )
update the best packing plan with P = P set i = i + 1
set k = k and Z = Z if (Zl Zm < ) and (Zr Zm < ) then break
set k = k + 1
return P
return P

Algorithm 3
accordingly. However, as soon as the packing plan P yields Bitflip (,P )
Z < Z , the previous packing plan P is restored and the set Z = Z(, P )
algorithm returns back to consider the items again starting set P = P
with item Ik M . In addition, the frequency is halved. for each item Im M do
This strategy helps to identify the moment when no further if Im 6 P then
solution improvement is possible while keeping the algorithm add item Im , P = P {Im }
computationally fast. The heuristic terminates either when else
no further improvement is possible or the limit value of 1 is remove item Im , P = P \ {Im }
reached for .
To reach a better packing performance, we run the packing compute the objective value Z (, P )
routine routine Pack (,) iteratively for different values of if Z > Z then
the exponent . Algorithm 2 explains the structure of the set Z = Z
solution process. The algorithm PackIterative (,c,,q) set P = P
return P
is fed by the starting exponent value c R+ , and a de-
viation value R+ which defines the current studying
interval for potential exponent values as (c , c + ). In
addition, an integer q is given as a limit on the number of not necessarily be optimal for a given tour. Therefore, we
iterations. The algorithm starts with evaluating objective present two local search operators to complement the pack-
values obtained by Pack (,) in case of = c and in cases ing plan generation from Section 3.1.
of two terminal values = c and = c + . At each The BitFlip operator is a simple greedy hillclimber with a
iteration, the algorithm compares the corresponding objec- low runtime. Its pseudocode is shown in Algorithm 3. The
tive values Zl , Zm and Zr , and selects the further interval operator iteratively evaluates the outcome of flipping each
for investigation. Specifically, it switches its attention to bit position corresponding to item Im M in the packing
smaller values if (Zl > Zm ) (Zl > Zr ) or to larger values if plan P . If flipping a bit improves the objective value (Z >
(Zr > Zm ) (Zr > Zl ). Subsequently, the routine updates Z ), the change is kept, otherwise P remains unchanged. A
the best packing plan P found so far. In addition, it nar- single iteration of the operator ends when all bit flips have
rows the potential interval for a search setting = /2 and been attempted once. Multiple passes can result in further
changes the current exponent value c to c or c + , de- improvement of the objective value.
pending on which produces the largest objective value. The
searching process continues until the number of iterations 3.3 Insertion
performed reaches its limit or improvement in the objective The insertion operator takes advantage of the situation
value is less than , where  is a small threshold constant. where a valuable item at a particular city is picked up early
and it is worth trying to delay the item pickup by modifying
3.2 Bitflip the tour . Figure 2 shows an example where city x2 is
The previously presented packing approach is not guaran- inserted later in the tour, after city x7 . In this case the result
teed to find a globally optimal TTP solution as (1) it does is a slightly longer tour, however the items at x2 are now
not modify the tours, and (2) the packing plan it finds may later in the tour and hence contribute a lower carrying cost.
 Heuristic S4: run CLK, then PackIterative, then
repeat Insertion until converged;
Heuristic S5: repeat S1 until time is up.
Because Bitflip and Insertion are deterministic, we can
stop the heuristics S2 and S4 once the objective value does
not change.
Figure 2: A graphical example of insertion: The solid black (1+1)-EA is a simple alternative to the greedy Bitflip,
line represents the initial tour option, while the red dashed line which was previously used in [10]: given a packing plan, we
represents a modified tour where city x2 has been inserted after
flip each item with probability 1/m. If the TTP solution
city x7 . The red tour can have a higher objective score due to
a valuable (but heavy) picked item at city x2 . with the new packing plan has a higher objective value, we
use it as the next starting point. We terminate it once the
CPU time is used up.
Algorithm 4 Since we expect the different routines to be able to escape
Insertion (,P ) each others local optima, we also define the following slightly
for a = n 1 do more complex heuristics:
compute Z = Z(, P )
Heuristic C1: run CLK, then PackIterative, then
for b = a 1 1 do
repeat one Bitflip pass, one Insertion pass until
set =
converged;
insert city xa between xb and xb1 in tour
compute Z = Z( , P ) Heuristic C2: run CLK, then PackIterative, then
if Z > Z then repeat one Bitflip pass, one (1+1)-EA pass, one
set Z = Z Insertion pass;
set = Heuristic C3: run CLK until 10% of the time is used,
if b = 1 then then apply PackIterative, select the best of those,
set = then one Bitflip pass, one Insertion pass;
return
Heuristic C4: run CLK until 10% of the time is used,
then apply PackIterative, select the best of those,
then one Bitflip pass, one (1+1)-EA pass, one In-
There is a tradeoff between increasing the tour length and sertion pass;
hence travel time and carrying cost for all items before the
insertion point, and decreasing the carrying cost of the items Heuristic C5: repeat C1 until time is up;
of the inserted city. The insertion pseudocode is shown in Heuristic C6: repeat C2 until time is up.
Algorithm 4. The operator searches over all cities in reverse
tour order (xn x1 ), evaluating the effect of inserting each The heuristics C1 and C2 are straight-forward extensions
city at all positions before its own position in the tour . of S2 and S4, with the hope that the two routines comple-
If an insertion for a city xa is found that produces a greater ment each other. Heuristics C3 and C4 use 10% of their
objective value than (1) the current tour and (2) all other CPU time to sample better starting points. This allows us
insertions for a , then the tour is stored as . Once the to investigate the benefits of a better starting point over
tour has been completely checked for better positions for xa performing more iterations of the routines. Lastly, C5 and
then becomes the new tour and the process begins C6 are the restart variants of C1 and C2, with which we can
with the next city xa1 . Again, multiple passes can result observe the advantage of restarts to make the best use of
in further improvement of the objective value. the available computation time.
Note that in typical good solutions to the TTP many items Note that we limit (1+1)-EA to 10,000 iterations in these
are picked up towards the end of the tour. The intuition complex heuristics, whereas it is unlimited in the simple
is that it is not too harmful to the overall objective value ones. In addition, note that we decided to execute only sin-
if items are picked up late, since the speed of the thief is gle passes of Bitflip and Insertion per iteration due to
typically low at that point in time. We begin our insertions their computational complexity. With this interleaving of
at the end of the tour since this is a time consuming search the two routines, none of them will use a disproportionate
operation for very large instances. amount of time. This is important particularly for the in-
stances in which there are a large number of cities and items.

4. LOCAL SEARCH ALGORITHMS 5. PACKING ITEMS WITH A MIP BASED

In order to isolate the effects of the different search rou- APPROACH
tines, we first define a set of straight-forward local search
algorithms. All algorithms use the Chained Lin-Kernighan When a tour is given, the two MIP based approaches of
heuristic (CLK) to generate an initial TSP tour: Polyakovskiy and Neumann [11] are able to solve the resid-
uary knapsack packing part either exactly or approximately.
Heuristic S1: run CLK, then PackIterative; Obtaining the optimal solution is costly in regard to run-
ning time as it requires the use of a linearization technique
Heuristic S2: run CLK, then PackIterative, then
to handle the non-linear terms in the objective function. As
repeat Bitflip until converged;
an alternative, the piecewise linear approximation technique
Heuristic S3: run CLK, then PackIterative, then can be used. In this case, each of the non-linear terms is rep-
(1+1)-EA; resented by the function t () = 1/ which is subsequently
approximated by a set of straight line segments. The compu-
tational experiments presented in [11] show that the approx-
imate approach yields a tight approximation within only 1%
of the optimal packing plan.
For our MIP-based approach, we adopt the approximative
technique and run it on top of the Chained Lin-Kernighan
heuristic [2] as a tour generator. The final solution for a
particular instance results from the following iterative pro-
cess. Each iteration starts with computing a distinct tour
as a result of the TSP heuristic. Then, we run the approx-
imative solver for the KP component. Firstly, the primal
order = (x1 , x2 , . . . , xn ) is considered. Specifically, the
set of items M is refined to exclude any existing unprof-
itable and compulsory items according to the pre-processing
scheme as prescribed in [11]. Then the resulting non-linear
knapsack problem on the reduced set of items is solved as
the linear mixed 0-1 program named NKPa , where is the
number of equal-sized line segments and is used to manage Figure 3: Heat-map of objective values for different values
the precision of the approximation. Secondly, the reversed of , averaged over the same 50 tours for each of the thirty
order = (x1 , xn , . . . , x2 ) is investigated for which the pre- instances of pcb3038 n9111. Greener (darker) squares indicate
higher objective values and boxes represent the best.
processing scheme and NKPa are performed again. Thus, we
obtain through each iteration two feasible solutions based on
either or . Afterwards, we start the next iteration with
From the set of 9,720 TTP instances, we select 72 as a
a new tour. We consider the best solution found by this
representative subset to cover small, medium, and large size
iterative process within a given time limit to be the output
instances with different characteristics:
of this approach.
six different numbers of cities (spread out roughly log-
6. EXPERIMENTAL INVESTIGATIONS arithmically): 195, 783, 3038, 11849, 33810, 85900;
In this section, we investigate the effects of the different two different numbers of items per city: 3, 10;
local search routines and compare our approaches with ex-
isting ones. all three different types of knapsacks;
two different sizes of knapsacks (capacities): 3 and 7
6.1 Experimental Setup times the size of the smallest knapsack.
As mentioned above, we use the comprehensive set of TTP
instances from Polyakovskiy et al. [1, 10] for our investiga- We run all algorithms for a maximum of 10 minutes per
tions. The two components of the problem are balanced instance, except for the MIP-based approach which we run
in such a way that the near-optimal solution of one sub- for 8 hours on the instances with n {33810, 85900} cities.
problem does not dominate over the optimal solution of an- Due to their randomized nature, we perform 30 independent
other sub-problem. repetitions of the algorithms on each instance. All com-
The characteristics of the 9,720 instances vary widely, and putations of heuristics S1S5 and C1C6 are performed on
we outline the most important ones in the following:2 machines with Intel Xeon E5430 CPUs (2.66GHz), on De-
bian Linux 4.7.2, with Java SE RE 1.7.0. All computations
The instances have 51 to 85,900 cities, based on in- of our MIP-based appproach were performed on machines
stances from the TSPlib by Reinelt [12]; with AMD Opteron 6348 CPUs (2.8GHz) on Red Hat Linux
For each TSP instance, there are three different types 4.4.7, with IBM ILOG CPLEX 12.6.
of knapsack problems: uncorrelated, uncorrelated with We assess the quality of the algorithms using the following
similar weights and bounded strongly correlated types, approach. For each instance, we consider the best solution
where the latter has been shown to be difficult for dif- found to be a lower bound on the achievable objective value.
ferent types of knapsack solvers in [5, 10]; Then, we take the average of the 30 results produced by an
For each TSP and KP combination, the number of algorithm and then compute the ratio between that aver-
items per city (referred to as an item factor ) is F age and the best objective value found, which gives us the
{1, 3, 5, 10}. Note that all cities of a single TTP in- approximation ratio. This ratio allows us to compare the
stance have the same number of items, except for the performances across the chosen set of instances, since the
first city (which is also the last city), where no items objective values vary across several orders of magnitude.
are available;
6.2 Impact of the Exponent in the Packing
For each instance, the renting rate R that links both Routine
subproblems is chosen in such a way that at least one
TTP solution with zero negative objective value exists; In the following, we investigate the performance of the
packing approaches from Section 3.1. First, in an attempt
Lastly, for each TTP configuration 10 different in- to uncover the best performing values for for varying in-
stances exist where the knapsack capacity is varied. stances, we carry out an experimental study with objective
2 values being calculated and averaged over 100 unique tours
For a more detailed description, we refer the interested
reader to [1, 10]. using values e [1, 6] at 0.25 intervals.
 Figure 6: Results of S1S5: ranking across the 72 instances.

Figure 7: Results of C1C6: ranking across the 72 instances.

our heuristics S1S5, C1C6, and MIP based heuristic with

the heuristic MATLS [6] and with the three heuristics pre-
sented in [10]. Note that the study in [6] already shows that
Figure 4: The best performing exponent values averaged over MATLS outperforms these three on large instances.
50 tours for varying instances and instance types. In Table 1 we list all achieved average ratios. Due to space
constraints, we only show in this table the results of algo-
Figure 3 is a heat-map from the study for the rithms with an average approximation ratio 96%. Thus,
pcb3038 n9111 instances.3 It is easy to see that (1) there the three approaches from [10] are missing in the table, as
appears to be a single best performing exponent for each are S2S4. S1 remains as an important baseline for our anal-
instance, and (2) there is also an optimal trend-line curve yses. In addition, we show in Figure 5 for all 16 approaches
for instances of the same type that stars at high exponents the number of times that a heuristic achieved the best, sec-
for small knapsacks and ends at smaller exponents for larger ond best, and third best average ratio.
knapsacks. This heat-map is representative of heat-maps for A closer look into the results yields surprising insights.
other instances. Across all instances, the trend-lines are de- First, let us look into our group of simple heuristics S1S5.
pendent on the knapsack types (bounded-strongly, uncorr- In Figure 6 we show the number of times that a particular
similar, uncorr). approach performed on average either best or second best
In order to quickly determine well performing exponents, in this group. We can see that S5 clearly outperforms our
we use PackIterative. Based on previous experiments, we other simple heuristics when it comes to the number of times
use the starting exponent c = 5 and the sampling spread that its average is the highest. The runner-ups are S2S4,
= 2.5. To limit the runtime of Algorithm 2, we limit the which shows that all three routines Bitflip, (1+1)-EA and
number of iterations q = 20 and use  = 0.1. We show the Insertion perform well on instances for which the others do
best performing exponents in Figure 4. What we can ob- not. In particular the performance of S4 shows that mod-
serve in Figure 3 is now visible across all 72 instances: the ifications of the tours need to be considered in addition to
best performing exponents for the uncorrelated ones are sig- modifications of the packing plans. Note that the dominat-
nificantly smaller than those for the instances with bounded ing performance of S5 is a first indicator of the importance
and strongly correlated items. of the initial TSP tour for the final objective value.
Interestingly, the best performing exponents for certain Next, for the analysis of the complex heuristics, let us
classes of TTP instances are in very narrow ranges, e.g. for recall that C3 and C4 sample several starting points in com-
all instances with uncorrelated weights. For the instances parison to C1 and C2, and that C5 and C6 are the restart
with bounded and strongly correlated items, however, the variants of C1 and C2. In Figure 7 we show again the num-
best performing exponents vary significantly. ber of times that an approach achieved either the best, sec-
Further investigation into these trends is necessary to fully ond best, or third best average objective value in this group.
understand why they exist and what particularities of an We can see that C3 and C4 perform best, which we at-
instance affect the value of the optimal exponent. tribute to the fact that both select the best from several
TTP solution candidates for the subsequent hill-climbing.
6.3 Results and Discussion The restarting algorithms C5 and C6 perform better than
In the following, we will show and analyse the performance the single-iteration ones, however, they do not perform as
of the different heuristics on the 72 instances. We compare well as algorithms C3 and C4 that can explore more TSP
tours. Again, the performance of the algorithms that sample
3 more tours indicates that the TSP tours are of high impor-
Only here we consider the wider range of knapsack sizes
110 to better show the trends. tance.
Figure 5: Results for all approaches: ranking across the 72 instances. Shown are the number of times an algorithms approximation
ratio is best, second best, or third best on an instance.

Interestingly, it is possible to directly compare the effects

of resampling tours and of hill-climbing based on a good
initial solution: C3/C4 contain S5, even though it is limited
to just 10% of the overall computation time. A look into
Table 1 reveals that the resampling strategy is the more
successful one, since S5 achieves an average approximation
ratio of 98.2%, whereas C3 and C4 achieve only about 97%.
Since PackIterative requires only a small number of
evaluations, it is very quick compared to the traditional iter-
ative TTP approaches that are allowed to use up to 10 min-
utes. For example, the runtimes of PackIterative ranges
from 15-60 milliseconds for the instances with 195 cities and
1.2-13 seconds for instances with 11,849 cities, to 18-110 sec-
onds for the instances with 85,900 cities. Since S1 performs
only a single iteration of PackIterative, we can compare Figure 8: Percentage of unique tours found in repeated Lin-
the performance of this basic step with the other approaches Kernighan runs. Percentages >100 are possible as a single TSP
in Table 1. tour can be used in two different directions for TTP purposes.
As we can observe in the approximation ratios of S1 and
S5, the impact of initial tours on the final solution qual-
ity can be significant. On many instances, the restart ap- times, if 1,000 n < 10,000 we run it 1,000 times, and if
proach of S5 outperforms any other complex approach. This n 10,000 we run the heuristic 100 times (see Figure 8).
strongly indicates that, even though the local search routines In particular for TSP instances that are based on electronic
are problem-specific, their effect is limited. Given our short circuits, which exhibit regular grid like arrangements, often
computation time budget, even the iterative MIP approach the final tours are identical with the exception of a few nodes
achieves just comparable performance. that then belong to earlier or later parts of the tour.
The results also show that the routines Bitflip and In- Summarizing the results the following conclusion can be
sertion can help to improve the solutions, in particular made: while problem understanding can help, it is surprising
when we compare the ratios of the complex algorithms C1 how well a greedy approach with low computational com-
C6 with that of S1. The drawback of these routines, how- plexity performs compared to more complex ones.
ever, is their computational complexity. To increase their
effectiveness, fast and particular heuristics are necessary to
prevent the exhaustive search that both routines currently
perform. 7. CONCLUDING REMARKS
Additional noteworthy observations include, amongst oth- As discovered from the literature and as observed in our
ers: experiments, there does not yet seem to be a single best algo-
The mixed-integer approach performs second best on rithm paradigm for the TTP. So far, constructive heuristics,
average, if we do not consider the instances with simple and complex hill-climbers, and also more sophisti-
n =85,900 cities. cated co-evolutionary approaches have been applied to the
TTP. With each study, more successful approaches are iden-
MATLS cleary outperforms our approaches on a few tified however further investigation is needed to enable un-
instances. On average, however, it is not amongst the derstanding to solve the TTP. The interdependence of the
best-performing algorithms. TTP is rarely considered, and minimally problem-specific
Since generating tours can be very time consuming for local searches that alternate between solving the TSP and
very large problem instances, it would be an obvious im- KP components perform best.
provement to pre-compute many TSP tours and to randomly It appears that the near future in TTP research will
pick from these. In practice, the decision to pre-compute mostly be driven by experiments. Maybe research similar
can be reasonable, in cases where the locations of delivery to that in [8, 9, 13], where the difficulty of TSP instances
or pick-up spots rarely change. In fact, a large number of is systematically analyzed, will contribute to the theoreti-
slightly different tours can be achieved by running CLK mul- cal understanding of the TTP. Computational complexity
tiple times. To investigate this further, we repeatedly run analyses of simple approaches on simple instances may also
CLK: if the number of cities n <1,000 then we run it 10,000 provide insights.
n m t F S1 S5 C3 C4 C5 C6 MIP MATLS Acknowledgements
3 88.1 99.6 99.4 99.4 99.6 99.5 100 96.3

usw unc bsc usw unc bsc usw unc bsc usw unc bsc usw unc bsc usw unc bsc usw unc bsc usw unc bsc usw unc bsc usw unc bsc usw unc bsc usw unc bsc
7 88.0 99.2 99.2 99.2 99.2 99.2 99.2 95.6 This work has been supported by the ARC Discovery Project
3 98.2 99.2 99.3 99.3 99.3 99.3 99.3 99.5
582
DP130104395.
7 99.2 99.9 100 100 100 100 100 99.8
3 96.1 98.6 99.0 98.9 99.3 99.0 99.5 98.5
7 98.2 99.1 99.2 99.2 99.3 99.2 99.3 99.2 References
195

3 89.6 99.9 99.9 99.9 99.9 99.9 100 98.3

7 89.2 97.7 97.1 97.5 97.7 97.6 98.1 97.0 [1] TTP Test Data. See http://cs.adelaide.edu.au/
1940

3 96.0 99.1 98.7 98.7 99.3 99.1 99.1 99.0 optlog/research/ttp.php.

7 96.3 98.6 97.7 97.7 98.7 98.5 98.8 99.2
3 88.4 91.3 91.3 91.6 91.5 91.7 91.4 97.0 [2] D. Applegate, W. J. Cook, and A. Rohe. Chained Lin-
7 92.6 96.3 95.6 95.6 96.4 96.0 96.9 99.4 Kernighan for large traveling salesman problems. IN-
3 97.8 99.7 99.4 99.4 99.6 99.4 99.7 96.6
7 95.5 99.3 98.7 98.6 99.1 98.8 99.0 96.6
FORMS Journal on Computing, 15(1):8292, 2003.
2346

3 95.9 98.9 98.5 98.5 98.8 98.5 98.7 98.8 [3] M. R. Bonyadi, Z. Michalewicz, and L. Barone. The
7 96.3 97.9 97.6 97.7 97.9 97.7 97.8 98.6 travelling thief problem: The first step in the transi-
3 95.3 99.1 99.2 99.2 99.5 99.3 99.5 98.7
7 96.0 99.7 99.6 99.5 99.8 99.5 99.7 98.7 tion from theoretical problems to realistic problems. In
783

3 98.0 99.7 99.6 99.7 99.4 99.5 99.8 94.8 IEEE Congress on Evolutionary Computation (CEC),
7 97.0 99.5 99.4 99.4 99.3 99.1 99.5 94.5 pages 10371044. IEEE, 2013.
7820

3 96.8 99.3 99.2 99.1 99.2 98.7 99.3 98.5

7 97.9 99.5 99.4 99.3 99.3 99.1 99.4 99.0 [4] M. R. Bonyadi, Z. Michalewicz, M. R. Przybylek, and
3 96.0 99.3 99.6 99.6 99.4 99.0 99.6 97.7 A. Wierzbicki. Socially inspired algorithms for the trav-
7 95.9 99.3 99.2 99.2 99.2 98.4 99.4 98.1
3 97.9 99.5 99.1 99.1 98.1 98.0 99.1 93.9
elling thief problem. In Genetic and Evolutionary Com-
7 97.6 99.4 99.0 99.0 97.7 97.4 98.8 94.4 putation Conference (GECCO), pages 421428, New
9111

3 98.0 99.7 99.4 99.4 98.5 98.0 99.5 99.0 York, NY, USA, 2014. ACM.
7 98.3 99.7 99.5 99.4 98.9 98.5 99.6 99.4
3 97.0 99.1 99.2 99.1 97.2 97.2 99.2 98.2 [5] S. Martello, D. Pisinger, and P. Toth. Dynamic pro-
3038

7 97.6 99.6 99.3 99.2 98.4 97.7 99.3 99.0 gramming and strong bounds for the 0-1 knapsack prob-
3 98.1 99.6 99.3 99.3 99.0 99.0 99.3 96.7 lem. Management Science, 45(3):414424, Mar. 1999.
7 97.0 99.2 98.7 98.8 98.6 98.2 98.9 95.8
30370

3 97.1 99.6 99.2 99.1 98.9 98.8 99.3 99.0 [6] Y. Mei, X. Li, and X. Yao. Improving efficiency of
7 97.8 99.5 99.3 99.3 99.2 98.9 99.3 99.2 heuristics for the large scale traveling thief problem.
3 94.8 98.9 98.2 98.3 97.6 97.6 98.6 98.3 In Simulated Evolution and Learning (SEAL), volume
7 96.2 99.1 98.6 98.4 98.5 97.9 98.6 98.6
3 97.1 99.2 98.4 98.6 97.3 97.4 97.5 93.5 8886 of LNCS, pages 631643. Springer, 2014.
7 96.7 98.9 97.9 98.1 96.6 96.7 96.7 93.9 [7] Y. Mei, X. Li, and X. Yao. On investigation of interde-
35544

3 97.4 99.0 98.4 98.5 97.6 97.8 98.0 98.4

7 97.9 99.5 98.9 99.0 98.0 98.3 98.4 99.3 pendence between sub-problems of the travelling thief
3 96.3 98.6 97.8 98.0 96.2 96.5 97.2 97.6 problem. Soft Computing, pages 116, 2014.
11849

7 97.1 99.0 98.5 98.5 97.0 97.3 97.3 98.7

3 96.7 99.0 98.4 98.3 96.9 97.0 97.9 93.6 [8] O. Mersmann, B. Bischl, H. Trautmann, M. Wagner,
7 96.2 99.2 98.1 98.3 96.2 96.4 97.4 94.0 J. Bossek, and F. Neumann. A novel feature-based ap-
35544

3 97.2 99.2 98.6 98.7 97.4 97.6 98.3 98.4 proach to characterize algorithm performance for the
7 97.4 99.2 98.6 98.4 97.9 97.8 98.5 98.8 traveling salesperson problem. Annals of Mathematics
3 95.3 98.3 97.8 97.8 95.6 95.9 97.1 97.6
7 96.2 98.9 98.1 98.0 96.7 96.7 97.9 98.5 and Artificial Intelligence, 69(2):151182, 2013.
3 91.3 97.9 95.5 94.0 93.9 92.0 98.3 94.4 [9] S. Nallaperuma, M. Wagner, and F. Neumann. Param-
7 91.0 97.9 94.2 95.3 93.8 91.7 96.5 94.1
101427

3 70.6 73.5 71.4 71.5 71.2 70.9 73.3 75.8 eter prediction based on features of evolved instances
7 95.1 98.2 96.4 96.0 95.3 95.5 99.9 98.4 for ant colony optimization and the traveling salesper-
3 90.4 97.5 93.7 93.3 92.5 91.8 96.2 95.9 son problem. In Parallel Problem Solving from Na-
33810

7 92.2 98.0 94.7 93.9 93.9 93.5 98.1 97.4 ture PPSN XIII, volume 8672 of LNCS, pages 100109.
3 92.2 97.3 93.8 93.3 92.5 92.4 99.1 93.9
7 92.6 97.1 94.9 94.3 92.6 93.3 96.9 94.6 Springer, 2014.
338090

3 94.7 98.3 95.3 95.5 95.8 95.0 97.8 98.0 [10] S. Polyakovskiy, M. R. Bonyadi, M. Wagner,
7 95.0 98.4 96.0 96.1 96.2 95.7 98.5 98.7
3 91.3 97.7 93.5 92.8 92.1 92.3 98.3 96.4 Z. Michalewicz, and F. Neumann. A comprehensive
7 93.9 98.3 94.4 95.1 94.1 94.6 99.5 98.3 benchmark set and heuristics for the traveling thief
3 95.8 98.3 96.3 95.8 95.9 96.4 97.6 - problem. In Genetic and Evolutionary Computation
7 96.1 97.8 96.8 95.9 96.3 97.1 98.4 - Conference (GECCO), pages 477484. ACM, 2014.
338090

3 97.4 98.9 94.2 94.1 97.8 97.7 - -

7 97.6 98.6 95.6 95.4 98.0 98.2 98.1 - [11] S. Polyakovskiy and F. Neumann. Packing while trav-
3 95.1 97.6 92.6 92.3 96.1 95.2 - - eling: Mixed integer programming for a class of non-
85900

7 95.8 97.4 93.4 93.3 96.4 96.0 97.9 -

3 95.9 96.8 96.2 97.1 95.6 96.3 - - linear knapsack problems. In Integration of AI and OR
7 96.6 97.2 97.0 97.6 96.6 96.3 - 94.1 Techniques in Constraint Programming, volume 9075 of
858990

3 97.6 97.5 92.1 92.0 97.6 97.3 - - LNCS, pages 330344. Springer, 2015.
7 97.9 97.9 94.6 94.5 97.8 97.7 - 98.5
3 95.7 97.5 91.8 92.7 96.3 95.3 - - [12] G. Reinelt. TSPLIB - A Traveling Salesman Problem
7 96.6 96.9 93.2 93.2 96.5 96.3 - 97.9 Library. ORSA Journal on Computing, 3(4):376384,
avg 95.2 98.2 97.0 96.9 96.9 96.8 87.2 84.9 1991.
avg-85900 95.0 98.3 97.5 97.4 97.0 96.8 98.1 97.0
[13] K. Smith-Miles, J. van Hemert, and X. Y. Lim. Un-
Table 1: Approximation ratios achieved. n is the number of derstanding TSP difficulty by learning from evolved
cities, m the number of items, t stands for the three KP types,
and F stands for the KP size. avg is the average ratio achieved
instances. In Learning and Intelligent Optimization
across all 72 instances, avg-85900 across the top 60 instances. (LION), pages 266280. Springer, 2010.