Analysis of Baseline Evolutionary Algorithms for the Packing While Travelling Problem

TL;DR

This paper analyzes the performance of various evolutionary algorithms on the non-linear Packing While Traveling problem, providing theoretical runtime bounds and experimental insights into their efficiency.

Contribution

It offers the first theoretical analysis of EAs on the non-linear PWT problem, including new algorithms and expected runtime bounds.

Findings

RLS_swap finds optimal solutions in O(n^3) expected time.

Enhanced GSEMO finds the Pareto front in the same asymptotic time.

(1+1) EA finds optimal solutions in O(n^2 log(max{n,p_max})) expected time.

Abstract

The performance of base-line Evolutionary Algorithms (EAs) on combinatorial problems has been studied rigorously. From the theoretical viewpoint, the literature extensively investigates the linear problems, while the theoretical analysis of the non-linear problems is still far behind. In this paper, variations of the Packing While Travelling (PWT) -- also known as the non-linear knapsack problem -- are studied as an attempt to analyse the behaviour of EAs on non-linear problems from theoretical perspective. We investigate PWT for two cities and $n$ items with correlated weights and profits, using single-objective and multi-objective algorithms. Our results show that RLS\_swap, which differs from the classical RLS by having the ability to swap two bits in one iteration, finds the optimal solution in $O(n^3)$ expected time. We also study an enhanced version of GSEMO, which a specific selection operator to deal with exponential population size, and prove that it finds the Pareto front in the same asymptotic expected time. In the case of uniform weights, (1+1)~EA is able to find the optimal solution in expected time $O(n^2\log{(\max\{n,p_{\max}\})})$, where $p_{\max}$ is the largest profit of the given items. We also perform an experimental analysis to complement our theoretical investigations and provide additional insights into the runtime behavior.

Equations

$$P(s)=\sum _{i=1}^m\sum _{j=1}^{n_i}{p}_{ij}{x}_{ij}$$

$$T(s)=\sum _{i=1}^m\frac{d_i}{v_{\max }-\nu {\sum }_{k=1}^i{\sum }_{j=1}^{n_k}{w}_{kj}{x}_{kj}}\text{,}$$

$$B(s)=P(s)-R\cdot T(s)\text{,}$$

$$B(s)=\sum _{i=1}^n{x}_i\cdot p_i-\frac{Rd}{v_{\max }-\nu {\sum }_{i=1}^n{x}_i\cdot w_i}\text{,}$$

$$F(s)=(q(s),B(s))$$

$$B(s^{\prime })-B(s)$$

$$=p_i-Rd\left(\frac{1}{v_{\max }-\nu (W(s)+w_i)}-\frac{1}{v_{\max }-\nu W(s)}\right)$$

$$=p_i-\frac{Rd\nu w_i}{(v_{\max }-\nu (W(s)+w_i))\cdot (v_{\max }-\nu W(s))}\text{.}$$

$$B(s^{\prime })-B(s)\ge 0⟺W(s)\le \stackrel{w_{e_i}}{\overbrace{\frac{v_{\max }}{\nu }-\frac{w_i}{2}\left(1+\sqrt{1+\frac{4Rd}{\nu w_i{p}_i}}\right)}}\text{.}$$

$$B(s^{\prime })-B(s)\ge 0⟺W(s)$$

$$\ge w_{e_i}+w_i\text{.}$$

$$p_i\ge p_j\wedge w_i\le w_j⟹w_{e_i}\ge w_{e_j}\text{.}$$

$$w_{e_i}+w_i>w_{e_j}+w_j\text{.}$$

$$B(s_0)<\cdots <B(s_o)\ge B(s_{o+1})>\cdots >B(s_n)\text{.}$$

$$h_t=\max \{0\le i\le k\mid x_0=x_1=\cdots =x_i=1\wedge W(s^t)<w_{e_i}+w_i\}\text{,}$$

$$W(s^{\prime })-w_x\le w_{e_x}\Rightarrow W(s^{\prime })\le w_{e_x}+w_x\text{.}$$

$$y=\max \left\{h_t,\min \{i\mid h_t<i\le n\wedge x_i=1\}\right\}\text{,}$$

$$A_i=\left\{s\mid s=s_0\right\}$$

$$A_i=\left\{s\mid W(s_{i-1})<W(s)\le W(s_i)\right\}$$

$$E[{\Delta }_t]\ge \frac{g_1(s)}{m_1}\cdot \frac{m_1}{en}\ge \frac{g_1(s)}{en}\ge \frac{g(s)}{2en}\text{.}$$

$$E[{\Delta }_t]\ge \frac{g_2(s)}{m_2}\cdot \frac{m_2}{2e{n}^2}\ge \frac{g_2(s)}{2e{n}^2}\ge \frac{g(s)}{4e{n}^2}\text{.}$$

$$E[T|X_0]\le 4e{n}^2\ln (n\cdot p_{\max }\cdot n^q)=O(n^2\max \{\log n,\log p_{\max }\})\text{.}$$

Full text

K****eywords Evolutionary algorithms  $\cdot$ Packing while travelling problem $\cdot$ Runtime analysis $\cdot$ (1+1) EA

1 Introduction

Evolutionary algorithms (EAs) are general problem solvers which have been widely applied to many combinatorial optimisation and engineering problems [1]. Similar to other bio-inspired algorithms, EAs aim to improve the current solution iteratively by imitating the evolution process in nature.

Random decision making plays an essential role in EAs’ basic operations, such as selection and mutation. The area of runtime analysis aims to theoretically investigate the performance of EAs as a specific class of randomised algorithms and many significant contributions have been achieved along this 20 year old path [2, 3, 4]. Remarkable attention has been devoted to the baseline evolutionary algorithms, such as RLS, (1+1) EA and GSEMO, since they can present a general insight into the performance of more complicated EAs. Interestingly, it has been proven that they perform efficiently in many cases [5, 4]. These analyses help to understand the performance of more complicated algorithms facing realistic environments.

Following Droste et al., who considered the performance of (1+1) EA on a linear class of problems in 1998 [6], many studies also considered linear functions [7, 8]. Friedrich et al. proved that (1+1) EA finds the optimal solution for any linear pseudo-boolean function under the uniform constraint in $O(n^{2}\log{(B\cdot p_{\max})})$, where $B$ is the constraint and $p_{\max}$ is the maximum profit of the given items [9]. More recently, Neumann et al. improved this bound to $O(n^{2}\log{B})$ expected time and to $O(n^{2}\log{n})$ with high probability [10]. They also proved a tight bound of $\Theta(n^{2})$ for RLS.

While a number of simple nonlinear problems, such as trap functions and LeadingOnes, have been deeply studied from theoretical and practical aspects [11, 12, 13], the literature is not equally rich for investigations of EAs on non-linear functions. Specifically, multi-component problems have gained a lot of attention during recent years due to their appearance in many real-world applications [14]. Multi-component problems consist of different components integrating with each other in a way that it is essential to deal with all the components simultaneously to find good quality solutions. Examples include the Generalised Minimum Spanning Tree problem (GMST) and the Generalised Travelling Salesman Problem (GTSP) in which clusters of nodes exist and the problem is to chose one node from each cluster and solve the MST and TSP on the selected nodes, respectively. These problems can be decomposed into a node selection component and a MST/TSP component, and hierarchical approaches for solving them are investigated theoretically in [15] and [16].

The Travelling Thief Problem (TTP), introduced by Bonyadi et al., is another example of an $\mathcal{NP}$-hard multi-component problem that combines the travelling salesman problem and the knapsack problem as the components [17]. In this problem, there are a number of items distributed between the nodes of a graph and the goal is to find a Hamiltonian cycle and choose the items from the visited nodes such that the benefit function is maximised. The integration of these components in a non-linear objective function is done in a way that optimising one component does not necessarily result in a near optimal solution. Using the same formulation, Polyakovskiy and Neumann introduced the Packing While Travelling problem (PWT), which is actually the packing version of TTP with a fixed travelling path [18]. A vehicle with a specified capacity wants to visit all the nodes in a specific order, pick the items such that the benefit function is maximised, and the capacity constraint is not violated. The benefit function has a direct relationship with the profit of packed items while the relationship with velocity is inverse. The velocity between each of the two cities is determined by the weight of the vehicle such that the more weight the vehicle carries, the less velocity it has. They prove that this problem, for even two cities, is also $\mathcal{NP}$-hard. Later, in [19], Neumann et al. presented an exact dynamic programming approach for PWT. They also proved that there is no polynomial time algorithm with constant approximation ratio for PWT problem unless $\mathcal{P}=\mathcal{NP}$ and presented an FPTAS for maximising the objective value over the baseline travel cost in which the vehicle travels the path empty.

In this paper, we theoretically analyse the performance of three baseline evolutionary algorithms, RLS_swap, (1+1) EA and GSEMO, on variations of the packing while travelling problem and prove upper bounds for the expected running times. We prove that for the instances with correlated weights and profits, RLS_swap and GSEMO find the optimal solution in expected time $O(n^{3})$. Furthermore, we consider the instances with uniform weights and prove that (1+1) EA finds the optimal solution in expected time $O(n^{2}\log(\max\{n,p_{\max}\})$. We also investigate the performance of these algorithms in addition to two other multi-objective algorithms, which are introduced in section 4, from the experimental point of view.

The rest of the paper is organised as follows. Section 2 presents the detailed definition of considered PWT problem and the algorithms used in this study. In Section 3, we investigate the problem theoretically for correlated weights and uniform weights in Sections 3.1 and 3.2, respectively. Our experimental analyses are presented in Section 4, followed by a conclusion in Section 5.

2 Preliminaries

In this section we present the definition of Packing While Travelling problem and the details of algorithms we analyse in this paper.

2.1 Problem Definition

The general PWT problem proposed in 2016 by Polyakovskiy and Neumann can be seen as a TTP with a fixed path [20]. Given a set of $m+1$ ordered cities, distances $d_{i}$ from city $i$ to $i+1$ ($1\leq i\leq m$) and a set of items $N=\cup_{i=1}^{m}{N_{i}}$ distributed over first $m$ cities such that city $1\leq i\leq m$ contains items $N_{i}$. Let $|N_{i}|=n_{i}$ denote the number of items in city $i$. Positive integers profit $p_{ij}$ and weight $w_{ij}$ are assigned to each item $e_{ij}\in N_{i}$, $1\leq j\leq n_{i}$. Path $M=(1,2,\dots,m+1)$ is travelled by a vehicle with velocity $v=[v_{\min},v_{\max}]$ and capacity $C$. A solution vector $s=(x_{11}x_{12}\dots x_{1{n_{1}}}\dots x_{m{n_{m}}})$ represents a set of selected items $S\subseteq N$ such that variable $x_{ij}\in\{0,1\}$ indicates whether item $e_{ij}$ is selected or not. Let $W(s)$ denote the sum of weights of items in $s$. As such, $s$ is feasible if $W(s)\leq C$. Let

[TABLE]

be the total profit and

[TABLE]

where $\nu=\frac{v_{\max}-v_{\min}}{C}$ is a constant, be the total travel time for vehicle carrying items of $s$. The denominator of $T(s)$ is such that picking an item in city $i$ only affects the time to travel from city $i$ to the end. Thus, the benefit value of $s$ is computed as

[TABLE]

where $R$ is a given renting rate. The aim is to find a feasible solution $s^{*}=\max_{s\in\{0,1\}^{n}}B(s)$.

The effect of different values for $R$ on the benefit function has been considered previously [21]. Generally speaking, $R=0$ changes PWT to the 0-1 knapsack problem while a larger $R$ forces the optimal solution to pick fewer items. This problem is proven to be $\mathcal{NP}$-hard by reducing the subset sum problem to the decision variant of unconstrained PWT [18].

In this paper we consider another version of this problem where there are only two cities and $n$ items that are located in the first city. In addition, the weights of the given items are favourably correlated with the profits, i.e. for any two item $e_{i}$ and $e_{j}$, $p_{i}>p_{j}$ implies $w_{i}<w_{j}$. Hence, for a bit string solution $s=(x_{1}\cdots x_{n})\in\{0,1\}^{n}$, we have

[TABLE]

where $d$ is the distance between the two cities.

We assume there are no items with the exact same weight and profit, however, all the proofs can be extended to include these cases and achieve the same results. Moreover, without loss of generality, in the rest of the paper we assume that items are indexed in a way that $p_{1}\geq p_{2}\cdots\geq p_{n}$ and $w_{1}\leq w_{2}\cdots\leq w_{n}$. We also consider another version of the problem in which all the weights are uniform and equal to one.

2.2 Algorithms

In this paper we study the behaviour of three algorithms. The first one, described in Algorithm 1, is a Random Local Search (RLS) variant called RLS_swap, which is able to do a swap (flip a zero bit and a one bit simultaneously), in addition to the usual one-bit flip. This modification of the classical RLS has been previously considered for the MST problem in [22]. In each iteration, if the current solution is all zeros or ones, it flips a randomly chosen bit of the solution. Otherwise, with probability of $1/2$, it either does a one-bit flip as described or chooses a one and a zero uniformly at random and flips both of them. The generated offspring replaces the current solution if it is at least as good as its parent with respect to the fitness function. This swap mutation is added in RLS_swap because there are some situations when optimising PWT in which no one-bit flip is able to pass the local optima.

Another algorithm we consider is (1+1) EA (Algorithm 2). This algorithm flips each bit of the current solution with probability of $1/n$ in each mutation step. Similar to RLS_swap, it compares the parent and the offspring and picks the better one for the next generation.

In RLS_swap and (1+1) EA, which are single-objective algorithms, the comparisons between solutions is based on the fitness function

[TABLE]

where $q(s)=\min\{C-w(s),0\}$. According to $q(s)$, $s$ is infeasible if and only if $q(s)<0$ and the absolute value of $q(s)$ denotes the amount of constraint violation. The goal is to maximise $F(s)$ with respect to lexicographical order, i.e. $s_{1}$ is better than $s_{2}$ ($F(s_{1})\geq F(s_{2})$) if and only if $\left(q(s_{1})>q(s_{2})\right)\lor\left(q(s_{1})=q(s_{2})\land B(s_{1})\geq B(s_{2})\right)$. This implies that any feasible solution has better fitness than any infeasible solution. Moreover, between two infeasible solutions, the one with smaller constraint violation is better.

We also consider PWT with a multi-objective algorithm using a variant of GSEMO, which uses a specific selection function to deal with the exponential size of the population (Algorithm 3). Neumann and Sutton suggested this version of GSEMO for the Knapsack Problem (KP) with correlated weights and profit to avoid an exponential population size [23]. We use the same approach since PWT easily changes to KP when $R=0$. As the objectives, we use the weight function ($W(s)$) and the previously defined fitness function ($F(s)$). The aim is to minimise $W(s)$ while maximising $F(s)$. Between two solutions $s_{1}$ and $s_{2}$, we say $s_{1}$ (weakly) dominates $s_{2}$, denoted by $s_{1}\succeq s_{2}$, if and only if $W(s_{1})\leq W(s_{2})\land F(s_{1})\geq F(s_{2})$. The dominance is called strong, denoted by $s_{1}\succ s_{2}$, when at least one of the inequalities strictly holds. Note that based on this definition, similar to the single-objective fitness function, each feasible solution dominates all infeasible solutions and an infeasible solution closer to the constraint bound dominates the more distant ones.

3 Theoretical Analysis

In this section, we theoretically investigate the performance of RLS_swap, GSEMO and (1+1) EA on different versions of the PWT problem by using the running time analysis. We first consider RLS_swap and GSEMO on the PWT with correlated weights and profits. Next, the behaviour of (1+1) EA on the PWT problem with uniform weights is analysed.

To study the PWT problem, we need to investigate the properties of an optimal solution and the impact of adding or removing an item on the benefit function. For this reason, in the following lemma we prove that the weight of the current solution, $w_{i}$, and $p_{i}$ determine if item $e_{i}$ is worth adding to or removing from the current solution.

Lemma 1**.**

For each item $e_{i}$ there is a unique threshold $w_{e_{i}}$ such that adding $e_{i}$ to the current solution $s$ improves the benefit function if and only if $W(s)<w_{e_{i}}$. Moreover, $W(s)>w_{e_{i}}+w_{i}$ if and only if removing $e_{i}$ increases the benefit function.

Proof.

Assume that the current solution $s$ does not include item $e_{i}$ and $s^{\prime}=s\cup{e_{i}}$. Hence, we have

[TABLE]

Adding $e_{i}$ to $s$ increases $B(s)$ only if the value of Expression 1 is greater than zero. Solving this equation we have

[TABLE]

By solving Equation 1 for each $e_{i}\,\text{,}\;1\leq i\leq n$, we can find $w_{e_{i}}$ such that adding $e_{i}$ to $s$ improves $B(s)$ if and only if $W(s)<w_{e_{i}}$. Considering the case that $e_{i}\in s$ and $s^{\prime}=s\setminus\{e_{i}\}$, a similar calculation implies that

[TABLE]

In other words, removing $e_{i}$ from $s$ increases the benefit function if and only if $W(s)>w_{e_{i}}+w_{i}$, which completes the proof. ∎

A direct result from Equations 2 and 3 is that

[TABLE]

Therefore, we have $w_{e_{1}}>w_{e_{2}}>\cdots>w_{e_{n}}$. Moreover, if the weight of solution $s$ equals $w_{e_{i}}$ then $B(s)=B(s\cup e_{i})$. Note that for any item $e_{i}$ and $e_{j}$, $i<j$, if removing $e_{i}$ is beneficial, then it is the same for $e_{j}$ because of the correlated weights and profits. Hence, for any $1\leq i<j\leq n$, we also have

[TABLE]

Now we discuss the optimal solution of the PWT problem. Let $s_{i}=<1^{i},0^{n-i}>$ denote the solution that only includes the first $i$ items and $s_{0}=<0^{n}>$. Consider the case that for some $i$, we have $w_{e_{i}}>W(s_{i-1})$. Hence, by Lemma 1, adding $e_{i}$ to $s_{i-1}$ improves the benefit function and $B(s_{i})>B(s_{i-1})$. Moreover, since $w_{e_{1}}\geq\cdots\geq w_{e_{i}}$, we have $B(s_{i})\geq\cdots\geq B(s_{1})$. The claim is that for a given set of items, there is a unique $k$ such that the optimal solution of the PWT problem is packing either $k$ or $k\land(k+1)$ items with the lowest indices. In the second case, $s_{k}$ and $s_{k+1}$ are both optimal and have the same benefit value. The following lemma proves this claim.

Lemma 2**.**

The optimal solution for the Packing While Travelling problem is the set of $k$ or $k\land(k+1)$ items with highest profits and lowest weights where $k$ is unique and depends on the given set of items.

Proof.

First, we assume that $w_{e_{n}}>W(s_{n-1})$. In this case, we have $B(s_{n})>B(s_{n-1})$ and $s_{n}$ is the optimal solution. On the other hand, if $w_{e_{1}}<0$ then the optimal solution is $s_{0}$. In the rest of the proof, we assume that neither of these cases happen.

Let $o=\min\{i\mid W(s_{i})>w_{e_{(i+1)}},{0\leq i\leq n-1}\}$. According to the definition of $o$ and $w_{e_{o+1}}$, adding any item to $s_{o}$ decreases the benefit function. Moreover, we have $W(s_{o-1})<w_{e_{o}}$, which implies $W(s_{o-1})+w_{o}=W(s_{o})<w_{e_{o}}+w_{o}$. Hence, removing any item from $s_{o}$ also reduces the benefit function. Therefore, the following equation holds:

[TABLE]

The equality $B(s_{o})=B(s_{o+1})$ holds only when $w_{e_{o+1}}=W(s_{o})$. However, all other inequalities are strict according to Lemma 1.

To prove that $s_{o}$ or $s_{o}\land s_{o+1}$ are the only optimums, it is now enough to show that for any $i$, $s_{i}$ has the highest benefit value among other solutions with $i$ items. This is also true since the items in $s_{i}$ have the highest profits and the lowest weights, which result in the highest benefit value.

Involving the capacity constraint $C$, however, may change the optimal solution. We define $s_{k}$, $k=\max\{j\mid W(s_{j})\leq C,{0\leq j\leq o}\}$, the feasible solution with the highest benefit function, which is the actual optimal solution with respect to $C$. This finalises the proof. ∎

From this point, we denote the optimal solution by $s^{*}$ and $k=|s^{*}|$ denotes the number of selected items in the optimal solution.

3.1 Correlated Weights and Profits

In this section, we consider the instances of the PWT problem in which the weights are strongly correlated with the profits. We calculate the performance of RLS_swap and GSEMO for this type of PWT.

3.1.1 RLS_swap

Using the result of Lemma 2, we analyse the performance of RLS_swap finding the optimal solution of the PWT problem in terms of the number of evaluations. We refer to the first $k$ bits of $s^{*}$ as the first block and the rest as the second block. Let $l$ and $r$ denote the number of zeros in the first block and the number of ones in the second block, respectively. For technical reason, we assume item $e_{0}$ exists where $w_{e_{0}}>\sum_{i=1}^{n}w_{i}$ and $x_{0}=1$. We denote the solution achieved by RLS_swap after $t$ generations as $s^{t}$. Consequently, we define

[TABLE]

to be the index of a specific bit of $s^{t}$. The following lemma and theorem consider the performance of RLS_swap on the PWT problem with correlated weights.

Lemma 3**.**

Having obtained a solution $s^{t}$, RLS_swap does not accept a solution $s^{\prime}=<x^{\prime}_{1},\cdots,x^{\prime}_{n}>$ in which $\exists i\leq h_{t}:x^{\prime}_{i}=0$.

Proof.

Since the weights and profits are correlated, it is enough to prove that RLS_swap does not remove $e_{h_{t}}$. Let $s^{\prime}$ denote the solution in generation $t^{\prime}>t$ such that $W(s^{\prime})\geq w_{e_{h_{t}}}+w_{h_{t}}$ for the first time after $t$, i.e. RLS_swap is able to remove $e_{h_{t}}$ from $s^{\prime}$. Note that all the items $e_{i}$, $i\leq h_{t}$, are still in $s^{\prime}$ at time $t^{\prime}$. Furthermore, no swap mutation can remove $e_{h_{t}}$ since it has a higher profit value and less weight than other missed items. Hence, there exists an item $e_{x}$, $x>h_{t}$, that has been added to $s^{\prime}$ with a one-bit flip in iteration $t^{\prime}-1$ such that $W(s^{\prime})-w_{x}<w_{e_{h_{t}}}+w_{h_{t}}$ , $C\geq W(s^{\prime})\geq w_{e_{h_{t}}}+w_{h_{t}}$ and $B(s^{\prime})\geq B(s^{\prime}\setminus e_{x})\text{.}$ From the benefit inequality and Lemma 1, we have

[TABLE]

Since $x>h_{t}$, according to Inequality 4, we have $w_{e_{h_{t}}}+w_{h_{t}}>w_{e_{x}}+w_{x}$. Hence, $W(s^{\prime})<w_{e_{h_{t}}}+w_{h_{t}}$ which contradicts with the assumption that it is beneficial to remove $e_{h_{t}}$ from $s^{\prime}$ and completes the proof. ∎

According to the definition of $h_{t}$, the weight of the accepted solutions after generation $t$ is lower bounded by $W(s_{h_{t}})$, in which the first $h_{t}$ items are selected. This shows that the maximum possible value for $h_{t}$ is $k$, otherwise $s^{*}$ is not the optimal solution (Lemma 2). Let

[TABLE]

be the index of the first one bit after a sequence of zeros after $h_{t}$. Let $y=h_{t}$ if there is no one bit after $h_{t}$. Similarly to the proof of Lemma 3, the following corollary holds.

Corollary 1**.**

Obtaining a solution $s$ with $W(s)<w_{e_{y}}+w_{y}$, RLS_swap does not remove $e_{y}$ except by reducing the value of $y$.

Reducing the value of $y$ to $y^{\prime}<y$ is either caused by swapping $e_{y}$ with item $e_{y^{\prime}}$ or inserting $e_{y^{\prime}}$ with a one-bit flip. In the first case, due to Inequality 4, and in the second case, due to Lemma 1, we have $W(s^{\prime})<w_{e_{y^{\prime}}}+w_{y^{\prime}}$, i. e. Corollary 1 holds for $y^{\prime}$.

Theorem 1**.**

RLS_swap finds the optimal solution for the Packing While Travelling problem with correlated weights and profits in $O(n^{3})$ expected time.

Proof.

Let RLS_swap start with a random solution $s^{0}$. We analyse the optimisation process in three main phases. In the first phase, RLS_swap finds a feasible solution. The second phase is to obtain $h_{t}=k$ and the third phase is to remove the remaining items from the second block to achieve the optimal solution.

If $W(s^{0})\leq C$ the first phase is already complete. Therefore, let $W(s^{0})>C$. Using a fitness level argument, Neumann and Sutton proved that (1+1) EA, which uses a fitness function with strictly higher priority in weight constraint satisfaction, finds a feasible solution for KP with correlated weights and profits in $O(n^{2})$ expected time (Theorem 3 in [23]). Their proof also holds for RLS_swap since the constraint is linear and RLS_swap is able to do a one-bit flip in $O(n)$ expected time. Hence, RLS_swap finds a feasible solution $s$ in $O(n^{2})$ expected time and completes the first phase.

In the second phase, we analyse the expected time needed to increase the value of $h_{t}$ to $h_{t}=k$. To do this, we need to calculate the expected time to find a solution $s$ such that $x_{h_{t}+1}=1$ and $W(s)\leq w_{e_{h_{t}+1}}+w_{h_{t}+1}$. Let $s$ denote the current solution. According to Lemma 1 and 2, if $W(s)\geq w_{e_{k+1}}+w_{k+1}$, removing any item from the second block improves the benefit function. Moreover, adding any item to the second block decreases the benefit. The probability of a one-bit flip, which removes an item from the second block, is $r/(2n)$ and it happens in expected time $O(2n/r)$. Since there are at most $n$ items to be removed, RLS_swap obtains $s$ with $W(s)<w_{e_{k+1}}+w_{k+1}$ in $2n\left(\sum_{i=1}^{r}1/i\right)=O(n\log{n})$ expected time. Note that after this point, no item can be removed from $s$ with a one-bit flip.

Now we examine the value of $y$ as defined in Equation 5. Let $y>h_{t}$. Since there is no accepted one-bit flip that removes an item, we have $W(s)<w_{e_{y}}+w_{y}$ and Corollary 1 holds. Otherwise, we have $y=h_{t}$ and there are two cases: $y=h_{t}=k$ or $y=h_{t}<k$. Let $y=h_{t}=k$. In this case, $s$ includes of all the items in the first block and there is no item in the second block to be removed. Therefore, RLS_swap has found $s^{*}$ which is the optimal solution. In the other case, that $y=h_{t}<k$, adding $e_{h_{t}+1}$ is beneficial and there exists at least one acceptable one-bit flip that adds an item to the solution $s$ in expected time $O(n)$. Let $y>h_{t}$ be the first item added. Since this bit flip is beneficial, we have $W(s)+w_{y}<w_{e_{y}}+w_{y}$ and Corollary 1 holds. Thus in $O(n)$ we have a solution in which $y>h_{t}$ and RLS_swap cannot remove $e_{y}$. At this stage, any two-bit flip that swaps $e_{y}$ and $e_{h_{t}+1}$ improves $h_{t}$ by one. This swap takes place in $O(n^{2})$ expected time. Thus in expected time $O(n^{2})$ RLS_swap increases $h_{t}$ by one. Since the maximum value of $h_{t}$ is $k\leq n$, RLS_swap achieves $h_{t}=k$ in expected time $O(n^{3})$.

Finally in the third phase, RLS_swap needs to remove the remaining items from the second block. Note that the first $k$ items are now selected and cannot be removed anymore. Each item can be removed with a one-bit flip which results in $O(n\log n)$ expected time for this phase.

Therefore we can conclude that RLS_swap finds the optimal solution for the PWT with correlated weights and profits in $O(n^{3})$ expected time. ∎

3.1.2 GSEMO

In this section we consider the time performance of GSEMO on the PWT problem with correlated weights and profits. The two objectives used in this algorithm are the weight function and the lexicographical fitness function, denoted by $W(s)$ and $F(s)$, respectively. We say solution $s_{1}$ weakly dominates solution $s_{2}$, denoted by $s_{1}\succeq s_{2}$, if $W(s_{1})\leq W(s_{2})\land F(s_{1})\geq F(s_{2})$. In the case of at least one strict inequality, it is called strong dominance. In our analysis, which is inspired by [23], we use a fitness level argument on the weights of the solution and compute the expected time needed to find at least one Pareto solution. Next, we calculate the time for finding the entire Pareto front. Due to Lemma 2, we can observe the following corollary that describes the Pareto front structure.

Corollary 2**.**

The Pareto set corresponding to the Packing While Travelling problem with correlated weights and profits is the solution set $\{s_{0},\cdots,s_{k}=s^{*}\}$.

Proof.

As it is explained in the proof of Lemma 1, $s_{i}$, $i\leq n$, dominates all the solutions with size $i$. On the other hand, we have $B(s_{0})\leq\cdots\leq B(s_{k})$ while $W(s_{0})\leq\cdots\leq W(s_{k})$, which implies that $\{s_{0},\cdots,s_{k}\}$ do not dominate each other. Furthermore, $s_{k}$ dominates every solution $s_{i}$, $i>k$, since it has a higher fitness value and less weight. Thus, there exists no solution dominating $\{s_{0},\cdots,s_{k}=s^{*}\}$, which completes the proof. ∎

The following theorem proves that the expected time for GSEMO to find the entire Pareto front of the PWT problem with correlated weights and profits is $O(n^{3})$.

Theorem 2**.**

GSEMO finds all the non-dominated solutions of the Packing While Travelling problem with correlated weights and profits in $O(n^{3})$ expected time.

Proof.

The proof consists of two phases. In the first phase, GSEMO finds the Pareto solution $\{0\}^{n}$. In the second phase, GSEMO finds other Pareto solutions based on the assumption of having at least one optimal solution.

Note that according to the definition of $F(s)$, an infeasible solution with less constraint violation always dominates the other ones, even in this two-objective space. Hence, while GSEMO has not achieved a feasible solution, the size of its population remains one. Therefore, it behaves exactly the same as (1+1) EA until it finds a feasible solution, which is argued in first phase of Theorem 1, and takes $O(n^{2})$ expected time. In the rest of the analysis of the first phase, we assume that GSEMO has found a feasible solution.

To analyse the first phase, we define $n$ fitness levels $A_{i}$, $0\leq i\leq n-1$, based on the weight objective $W(s)$ as follows:

[TABLE]

According to the correlation of the weights, this definition guarantees that if a solution $s$ belongs to level $A_{i}$, $1\leq i\leq n$, then $s$ includes at least one of the items $e_{j}$ where $j\geq i$. Moreover, removing $e_{j}$ from $s$ moves it to a lower level. Now assume that $P$ denotes the population in step $t$ of GSEMO. Let $A_{u}$ denote the lowest level that has been achieved until step $t$ and $s\in A_{u}$ has the highest fitness among the solutions in level $A_{u}$. GSEMO chooses this solution by choosing $|s|_{1}$ from $I$, which happens with the probability of $1/|I|\geq 1/n$. Furthermore, there exists item $e_{x}$ in $s$ such that $x\geq u$ and removing it produces a solution in a lower level. This solution will be accepted since it has the lowest weight. The one-bit flip that removes $e_{x}$ from $s$ happens with the probability of $1/(en)$. Thus, GSEMO reduces $u$ with probability of $1/(en^{2})$ in step $t$. In other words, GSEMO reduces $u$, at least by one, in expected time $O(n^{2})$. On the other hand, $s_{0}$, which is the only solution of level $A_{0}$, is a Pareto solution since it has the lowest possible weight. Thus, if the algorithm achieves $A_{0}$ then the first phase is accomplished. Since the maximum possible value of $u$ is $n$ and $u$ is reduced by one in every $O(n^{2})$ expected iterations, GSEMO finishes the first phase in expected time of $O(n^{3})$.

In the second phase, we assume $s_{i}\in P$, $i\leq k$ exists such that $s_{i}$ is Pareto solution by Corollary 2, and either $s_{i-1}$ or $s_{i+1}$, which are also Pareto solutions, do not exist in $P$. Otherwise, the second phase is already finished. Adding $e_{i+1}$ to or removing $e_{i}$ from $s_{i}$ results in $s_{i+1}$ or $s_{i-1}$, respectively. For such a step, the algorithm must choose $i\in I$ and flip the correct bit, which happens with the probability $1/n$ and $1/(en)$, respectively. Hence, the algorithm finds a new Pareto solution from $s_{i}$ in $O(n^{2})$ expected iterations. Based on Corollary 2, the size of the Pareto set is $k+1\leq n$. Therefore, GSEMO finds all the $k+1$ Pareto solutions of the PWT problem with correlated weights and profits in $O(n^{3})$ expected time. ∎

3.2 Uniform Weights

In this section, we analyse the performance of (1+1) EA on another version of the Packing While Travelling problem. Here we assume that weights of all the items are one and the profits are arbitrary. Similar to the previous instances, we assume items $\{e_{1},\cdots,e_{n}\}$ are indexed such that $p_{1}\geq\cdots\geq p_{n}$. Note that the results of Lemmata 1 and 2 also holds for the uniform weights. Moreover, since correlated weights and profits are actually the more general version of the uniform weights, the results for GSEMO and RLS_swap also holds.

The analysis of (1+1) EA is based on the following Lemma which proves the existence of a set of one-bit flips and two-bit flips which transform an arbitrary solution to the optimal solution.

Lemma 4**.**

Let $W(s^{*})$ be the weight of the optimal solution and the current solution $s$ is feasible. There exists a set of one-bit flips and two-bit flips that transform $s$ to an optimal solution if they happen in any order.

Proof.

Assume that $W(s)\leq W(s^{*})$. This implies that $i=|s|_{1}\leq k$, where $i$ is the number of selected items in $s$. In this case, any two-bit flips that swap a one bit from the second block and a zero bit from the first block will be accepted by the algorithm. If there is no one bit in the second block, then all the one-bit flips that change a zero bit in the first block are accepted and this set leads $s$ to the optimal solution $s^{*}$. Note that all defined one-bit flips will be accepted (Lemma 1 and Lemma 2) since $i\leq k$ and the weights are one. Hence, it is not necessary for the bit flips to happen in a special order. The other case, that $C\geq W(s)>W(s^{*})$, is similar to the first one. Any two-bit flips that swap a zero bits in the first block with a one bit in the second block and any one-bit flips that remove ones from the second block are accepted by the algorithm. Thus, in this case, there also exists a set of one-bit flips and two-bit flips that, if they occure in any order, transform $s$ into the optimal solution. ∎

Here we present some more definitions that help us with analysis of the performance of (1+1) EA on the PWT problem. Assume $M$ is the set of $m_{1}$ one-bit flips and $m_{2}$ two-bit flips that transform the current solution $s$ to an optimal solution and $|M|=m_{1}+m_{2}$. Moreover, let $g(s)=B(s^{*})-B(s)$ be the difference between the benefit of $s$ and the optimal solution. Therefore, we can denote the contribution of one-bit flips and two-bit flips in $g(s)$ by $g_{1}(s)$ and $g_{2}(s)$, respectively, such that $g(s)=g_{1}(s)+g_{2}(s)$. In the next theorem, we calculate the expected time for (1+1) EA to find the optimal solution of the PWT problem with unifrom weights.

Theorem 3**.**

The expected time for (1+1) EA to find the optimal solution for the Packing While Travelling problem with uniform weights is $O(n^{2}\max\{\log{n},\log{p_{\max}}\})$.

Proof.

As mentioned in the proof of Theorem 1, it is proven in Theorem 3 in [23] that (1+1) EA finds a feasible solution in $O(n^{2})$ expected time. Thus, we assume that (1+1) EA has already found a feasible solution $s$. Let $\Delta_{t}=g(s)-g(s^{\prime})=B(s^{\prime})-B(s)$ denote the improvement of (1+1) EA in iteration $t$ which transforms $s$ to $s^{\prime}$. We partition the proof into two cases. Firstly, let the overall contribution of one-bit flips in $g(s)$ be more than the total improvement that could be achieved by two-bit flips. Hence, we have $g_{1}(s)\geq\frac{g(s)}{2}$. Since there are $m_{1}$ one-bit flips in $M$, each of them happens with the probability of $\frac{m_{1}}{en}$ and improves the solution in average by $\frac{g_{1}(s)}{m_{1}}$. Thus, in this case we have :

[TABLE]

In the second case, the sum of improvements by two-bit flips in $M$ is more than the total improvement of one-bit flips and we have $g_{2}(s)\geq\frac{g(s)}{2}$. Here, the average improvement of each two-bit flip is $\frac{g_{2}(s)}{m_{2}}$ and each takes place with a probability of $\frac{m_{2}}{2en^{2}}$. Therefore, we have:

[TABLE]

We can conclude that the expected improvement at step $t$ is at least $E[\Delta_{t}]\geq\frac{g(s)}{4en^{2}}$. On the other hand, $B(s^{*})\leq n\cdot p_{\max}$ is the maximum possible benefit value, ignoring the cost function. To use the multiplicative drift, it is only necessary to calculate the minimum possible amount of $g(s)$.

Let $s^{l}$ be the last solution that turned into an optimal solution with a bit flip. We need to find the minimum of $B(s^{*})-B(s^{l})$ which happens when $B(s^{l})$ is maximized. There are three possibilities in which $s^{l}$ is the closest solution to the optimal solution. If the last bit flip is a two-bit flip, to maximize $B(s^{l})$, $s^{l}=s_{k-1}\cup e_{k+1}$. In this case, we have $g(s^{l})=p_{k}-p_{k+1}\geq 1$, since all the profits are integers. If the last bit flip is a one-bit and it adds an item to $s^{l}$, then the maximum benefit of $s^{l}$ is achieved when $s^{l}=s_{k-1}$. Therefore, we have $g(s^{l})=p_{k}-\frac{Rd\nu}{(v_{\max}-\nu(k-1))(v_{\max}-\nu k)}$. Considering $R,d,v_{\min}\text{ and }v_{\max}$ as constants, $g(s)=O(n^{-q})$ for some constant $q\geq 1$. The same result holds for the third case where the final bit flip removes $e_{k+1}$ from $s^{l}=s_{k+1}$.

Finally, using the multiplicative drift with $X_{0}=n\cdot p_{\max}$, $x_{\min}=n^{-q}$ and $\delta=\frac{1}{4en^{2}}$, the expected first hitting time $T$ that (1+1) EA finds the optimal solution for the PWT problem with uniform weights is:

[TABLE]

∎

4 Experiments

In this section, we experimentally investigate the performance of our algorithms. Our goal is to complement the theoretical analysis to gain additional insight into the behaviour of the algorithms during the optimisation process. Moreover, by analysing the running time of our algorithms on random instances with different sizes, we present a clearer view of how they perform.

In the previous section, we showed that the classical RLS cannot find the optimal solution by doing only one-bit flips and it is essential to do a two-bit flip to escape local optima. However, what happens if the classical RLS is enhaced with a population? To answer this question, we also consider another two multi-objective algorithms called SEMO and SEMO_swap. They are different from GSEMO (Algorithm 3) only in the mutation step. The mutation step in SEMO_swap is the same as Algorithm 1. SEMO, on the other hand, only chooses one bit, uniformly at random, and flips it. Our experiments show that SEMO avoids the classical RLS weakness by using the population and performs even better than the other multi-objective algorithms.

4.1 Benchmarking and Experimental Setting

To compare the practical performance of different algorithms in different types of PWT, we used thirty different instances where each instance consists of 300 items. Each instance of size $n$ for the correlated PWT is generated by choosing $n$ integer profits uniformly at random within [1,1000] and assigning them to $p_{1},\cdots,p_{n}$ in descending order. Similarly, $n$ uniformly random integers within the same interval are generated and sorted in ascending order as the weights $w_{1},\cdots,w_{n}$. Hence, for any item $e_{i},e_{j}:i<j$ we have $p_{i}\geq p_{i}$ and $w_{i}\leq w_{j}$. For the instances with uniform weights, we use the same profits as correlated instances but change the weights to one. We set the constant values in all the instances as follows: $n=300$, $d=50$, $R=70$, $v_{\max}=1$ and $v_{\min}=0.1$. $C=8000$ is the capacity chosen for correlated instances. To calculate the proper capacity for uniform instances, we use the average of the maximum number of items with correlated weights that fit in $C=8000$, which results in $C=72$ for the uniform instances. Furthermore, for all the experiments, algorithms start with the zero solution.

We use these instances in the first experiment, in which we show how the algorithms converge to the optimal solution for the correlated and uniform instances. We run each algorithm for all thirty instances, record the best found solution in each generation and normalise its benefit value to the interval [0,1] with respect to the optimal solution for each instance. We plot the average of normalised values as the success rate for each algorithm (Figure 1). Hence, this value is one when an algorithm finds the optimal solution for all thirty different instances.

In the last experiments, in which we consider the optimisation time for algorithms, we run each algorithm on instances with seven different sizes, $n=100,200,500,1000,2000,5000,10000$. For each $n$, we have thirty different instances which are created with the same constants as the previous ones. For each algorithm, we record the average number of evaluations to find the optimal solution for the thirty instances with the same $n$ as its optimisation time. Hence, for each algorithm, we have seven points to estimate the performance (Figure 2). We only do this analysis with the correlated instances.

In our results for (1+1) EA and GSEMO, we only count the generations that an actual bit flip has happened in mutation steps. The same approach has been used in [24]. This causes the analysis to be fair since RLS_swap guarantees to create a new solution in each mutation step but (1+1) EA and GSEMO do not flip any of the bits with the probability of $1/e$ (36.7% of times).

4.2 Analysis

In this section, we analyse the performance of the algorithms based on the experimental results. Figure 1 illustrates how the algorithms converge to the optimal solutions for all the instances on average. In both types of the instances, it can be observed that (1+1) EA and RLS get close to the optimal solutions much faster than the multi-objective algorithms, which demonstrates that using population slows down the convergence rate significantly. (1+1) EA, however, has major problems in finding the optimal solutions when it is close to the optimum and only a few bit flips are needed. The reason is that (1+1) EA is able to flip more than one bit. Hence, it is likely to improve the benefit value, but increase the hamming distance between the current solution and the optimal solution in the same time. In other words, (1+1) EA is able to improve the benefit function while the improved solution needs more bit flips to reach the optimal solution than before. Note that Figure 1 is plotted with a logarithmic x scale to make it easier to distinguish the difference betweem the first $10^{5}$ generations. While the other algorithms almost achieve the optimal solution in the first $10^{5}$ generations, (1+1) EA performs two times worse than the others.

Looking into the multi-objective algorithms, Figure 1 illustrates that GSEMO and SEMO_swap behave almost identically while SEMO outperforms both. This shows that although SEMO can flip only one bit in each generation, the population enables the algorithm to bypass the local optima and find a better solution. In other words, using population and dominance concepts is another method to escape local optima with only one-bit flips. The reason, as described in the proof of Theorem 3.7, is that one-bit flips can always reduce the weight of the solution. Using weight as an objective in population-based multi-objective algorithms makes it possible for SEMO to obtain the zero solution, which is a Pareto optimal solution, by using only one-bit flips. From that point, the algorithm can gradually find all the other Pareto optimal solutions, including the general optimal solution, by adding the correct item to the previous optimal solution. Generally speaking, RLS_swap and SEMO, which enhance versions of the classical RLS to avoid the local optima, perform better for this Packing While Travelling problem variation.

The results of the final experiment are presented in Figure 2. We run each algorithm for instances with seven different sizes, and for each specific size, we have thirty different instances. Figure 2 shows the average of running times for each instance size. It validates the results in Figure 1, in which RLS_swap has a better performance than the other algorithms while multi-objective algorithms outperform (1+1) EA. This data can also be used to give an insight into the expected optimisation time for each algorithm. Figure 2 presents the data for $n^{2}$ and $n\log{n}$ expressions which suggests that the order of magnitude for the running times for these algorithms on random instances is close to $n^{2}$ or $n\log{n}$.

5 Conclusion

Evolutionary algorithms are known as general problem solvers which can provide good quality solutions to many problems. While these algorithms have been thoroughly studied in solving linear functions, their performance on non-linear problems is not clear. In this paper, we study the performance of three base-line EAs, from a theoretical viewpoint, on the Packing While Travelling problem, which is also known as a non-linear knapsack problem. We prove that RLS_swap and GSEMO find the optimal solution in $O(n^{3})$ expected time for instances with correlated weights and profits. In addition, we show that (1+1) EA finds the optimal solution for instances with uniform weights in $O(n^{2}\log(\max\{n,p_{\max}\}))$, where $p_{\max}$ is the highest profit of the given items. We also empirically investigate these algorithms and, based on our investigations, we conjecture an upper bound of $O(n^{2})$. We aim to extend our results for the PWT with more than two cities with correlated items and items with uniform weights. However, the case in which the items are not correlated and are correlated in each city separately might be as hard as the general case.

Acknowledgements

This work has been supported by the Australian Research Council through grant DP160102401. Furthermore, Frank Neumann has been supported by the Alexander von Humboldt Foundation through a Humboldt Fellowship for Experienced Researchers.