On the Constrained Least-cost Tour Problem

TL;DR

This paper introduces the Constrained Least-cost Tour problem, proves its NP-hardness, and develops heuristics for finding low-cost, weight-feasible routes, with applications in urban pollution exposure reduction.

Contribution

It defines the CLT problem, proves its NP-hardness, and proposes heuristics including relaxations and cycle-finding algorithms for practical solutions.

Findings

Proved CLT is NP-hard even on simple paths.

Developed heuristics using relaxations and Suurballe's algorithm.

Demonstrated algorithms on real-world urban pollution routing.

Abstract

We introduce the Constrained Least-cost Tour (CLT) problem: given an undirected graph with weight and cost functions on the edges, minimise the total cost of a tour rooted at a start vertex such that the total weight lies within a given range. CLT is related to the family of Travelling Salesman Problems with Profits, but differs by defining the weight function on edges instead of vertices, and by requiring the total weight to be within a range instead of being at least some quota. We prove CLT is $\mathcal{NP}$-hard, even in the simple case when the input graph is a path. We derive an informative lower bound by relaxing the integrality of edges and propose a heuristic motivated by this relaxation. For the case that requires the tour to be a simple cycle, we develop two heuristics which exploit Suurballe's algorithm to find low-cost, weight-feasible cycles. We demonstrate our algorithms by addressing a real-world problem that affects urban populations: finding routes that minimise air pollution exposure for walking, running and cycling in the city of London.

Tables

Table 1. Table 1 : Summary of CLT and TSP-wP s. Cost on edges c : E ​ ( G ) → ℕ : 𝑐 → 𝐸 𝐺 ℕ c:E(G)\to\mathbb{N} ; weight on edges w : E ​ ( G ) → ℕ : 𝑤 → 𝐸 𝐺 ℕ w:E(G)\to\mathbb{N} ; profit on vertices p : V ​ ( G ) → ℕ : 𝑝 → 𝑉 𝐺 ℕ p:V(G)\to\mathbb{N} ; resource on vertices r : V ​ ( G ) → ℕ : 𝑟 → 𝑉 𝐺 ℕ r:V(G)\to\mathbb{N} ; threshold Z ∈ ℕ 𝑍 ℕ Z\in\mathbb{N} .

Problem	$c$	$w$	$p$	$r$	Objective	Constraints
CLT	yes	yes	no	no	$\min \left\{c\left(𝒯\right)\right\}$	$W_1\le w\left(𝒯\right)\le W_2$
OP	yes	no	yes	no	$\max \left\{p\left(𝒯\right)\right\}$	$c\left(𝒯\right)\le Z$
Pc-TSP	yes	no	yes	yes	$\min \left\{c\left(𝒯\right)-p\left(𝒯\right)\right\}$	$r\left(𝒯\right)\ge Z$
Q-TSP	yes	no	yes	no	$\min \left\{c\left(𝒯\right)\right\}$	$p\left(𝒯\right)\ge Z$

Table 2. Table 2 : Mean overshoot (extra weight beyond W 1 subscript 𝑊 1 W_{1} ), mean margin of error (how far away is the heuristic to the applicable lower bound). Lower bounds (relaxations) are marked by ∗ .

	Air Quality		The Crucible
Algorithm	Overshoot	$\%$ error	Overshoot	$\%$ error
Continuous relaxation (CR)∗	0.00	0.00	0.00	0.00
Déjà Vu heuristic (DjV)	34.20	1.18	0.16	0.81
Connectivity relaxation (XR)∗	17.16	0.00	0.00	0.00
Adaptive heuristic (AH)	41.77	1.96	0.00	2.22
Suurballe’s heuristic (SH)	120.98	4.57	1.98	4.68

Equations

$$w(\mathcal{T})$$

$$c(\mathcal{T})$$

$$\varphi (\mathcal{T},e)=f\left(\frac{W_1-2w(\Pi (s^{\star },x))}{w(e)}\right)$$

$$w(\mathcal{T})$$

$$=2\sum _{i\in [n]}{y}_i\cdot w(e_i)+2\sum _{i\in [n]}w(e_i)+2w(e_{n+1})$$

$$=2\stackrel{Z}{\overbrace{\sum _{i\in [n]}{y}_i\cdot f(z_i)}}+2\sum _{i\in [n]}w(e_i)+2w(e_{n+1})=W_1$$

$$c(\mathcal{T})$$

$$=2\sum _{i\in [n]}{y}_i\cdot w(e_i)+2\sum _{i\in [n]}w(e_i)+\stackrel{2c(e_{n+1})}{\overbrace{2Z+2\sum _{i\in [n]}w(e_i)}}$$

$$=2\stackrel{Z}{\overbrace{\sum _{i\in [n]}{y}_i\cdot f(z_i)}}+2\sum _{i\in [n]}w(e_i)+2Z+2\sum _{i\in [n]}w(e_i)=C$$

$$w(\mathcal{T})$$

$$2w(e_{n+1})+\sum _{i\in [n]}\varphi (\mathcal{T},e_i)\cdot w(e_i)$$

$$\sum _{i\in [n]}2(y_i+2)w(e_i)$$

$$\sum _{i\in [n]}{y}_i\cdot f(z_i)$$

$$c(\mathcal{T})$$

$$2c(e_{n+1})+\sum _{i\in [n]}\varphi (\mathcal{T},e_i)c(e_i)$$

$$2Z+2\sum _{i\in [n]}w(e_i)+\sum _{i\in [n]}2(y_i+2)w(e_i)$$

$$2\sum _{i\in [n]}{y}_i\cdot w(e_i)+2\sum _{i\in [n]}w(e_i)$$

$$\sum _{i\in [n]}{y}_i\cdot f(e_i)$$

$$\sum _{e_{ij}\in E(G)}{x}_{ij}\cdot c(e_{ij})$$

$$W_1\le \sum _{e_{ij}\in E(G)}{x}_{ij}\cdot w(e_{ij})\le W_2$$

$$x({\mathcal{A}}_{s^{\star }})=2$$

$$\frac{1}{2}x({\mathcal{A}}_i)\in \{0,1\}$$

$$x_{ij}\in \{0,1\}$$

$$\forall S\in \Phi (i,j),\forall i,j\in V:x(S)\ge x({\mathcal{A}}_i)+x({\mathcal{A}}_j)-2$$

Full text

1 Introduction

Large scale graph optimisation problems are at the heart of urban science, computational sustainability [12] and human wellbeing. Examples include computing connected subgraphs to design wildlife corridors [6] and planning methods for bike sharing systems in New York [8]. With $91\%$ of the world population exposed to particulate matter (PM2.5) concentrations that are above the annual mean World Health Organization air quality guideline levels [22], we are motivated by the interesting and challenging problem of finding running routes that minimise air pollution in a city.

Consider a runner planning a route which starts and ends at the same location. The runner would like the route to be sufficiently long but they do not want to run too far. However, running without considering the air quality in the local area is a suboptimal approach. Air pollution has an adverse effect on the cardio-respiratory system, which can be exacerbated by increased inhalation during exercise [10]. Moreover, air pollution in urban environments is highly localised because factors such as transportation, industry and construction largely contribute to the poor air quality [20]. In order to minimise the exposure to air pollution, the runner could use a mobile or web application to request and view an appropriate route. An algorithm which computes such a running route efficiently is therefore highly desirable.

With the above motivation in mind, we study the Constrained Least-cost Tour (CLT) problem. The input is an undirected graph representing the road network with edge weights (distance) and edge costs (air pollution). We are given a lower weight threshold $W_{1}$ and an upper weight threshold $W_{2}$. We are also given a specially annotated vertex called the origin representing the start and end location of the run. The objective is to minimise the total cost of a tour starting and ending at the origin such that the total weight of the tour is weight-feasible. A weight-feasible tour means that the total weight of the tour is at least $W_{1}$ and at most $W_{2}$. In the context of a running route, weight-feasible means that the route is sufficiently long (at least $W_{1}$) but is not too far for the runner (at most $W_{2}$).

The CLT problem is most closely related to the family of Travelling Salesman Problems with Profits (TSP-wP). Table 1 summarises the similarities and differences between CLT and some TSP-wP family members. This family of TSPs does not require the tour to visit every vertex in the graph and may be rooted (tour must start and end at a given vertex) or unrooted. In a review by Feillet et al. [7], the TSP-wP family is split into three classes: Quota TSP (Q-TSP), Selective TSP (S-TSP) and Profitable Tour Problems (PTP). The Orienteering Problem (OP) [11; 13] is a well-known S-TSP and the Prize-collecting TSP (Pc-TSP) [3] is an important PTP. However, the more similar TSP-wP class to the CLT probem is Q-TSP [2].

In Q-TSP, we are given an undirected graph with a profit function on the vertices, a cost function on the edges and a quota $Z\in{\mathbb{N}}$. The goal of Q-TSP is to minimise the total cost of a tour such that the total collected profit is at least $Z$. There are three key differences between the CLT Problem and the Q-TSP. First, the profit function in Q-TSP is on the vertices of the graph whereas the weight function in the CLT Problem is on the edges of the graph. Second, there is no upper profit threshold in Q-TSP, where as the CLT Problem defines an upper weight threshold $W_{2}$. Third, the limited existing literature [2] for Q-TSP assumes the triangle inequality holds on the cost function and obtains an approximation by doubling a $k$-Minimum Spanning Tree [9]. However, the cost function (air pollution exposure) in our real-world application does not follow this inequality.

TSP-wPs such as Q-TSP may ask for a weak tour (vertex repetition is not constrained) or a strong tour (vertices are repeated at most once, thus the tour is a simple cycle). We investigate both the weak and strong variants of the CLT problem. In the remainder of this paper, we refer to the weak variant as the CLT problem, and the strong variant as the Constrained Least-cost Cycle (CLC) Problem.

Our contributions are as follows. In Section 3, we prove that the CLT problem is $\mathcal{NP}$-hard, even in the case when the input graph is a path. A simple reduction from the Hamiltonian Cycle problem shows that if the triangle inequality does not hold on the cost function, then the CLC problem does not have an $\alpha$-approximation algorithm for any $\alpha\geq 1$ (assuming ${\cal P}\neq{\mathcal{N}P}$). Thus, we will focus on heuristic approaches to the problem which find sufficiently good solutions in polynomial-time (Section 5). First, we introduce the Déjà Vu heuristic (DjV) to find weak tours for the CLT problem. Next, we propose Suurballe’s heuristic (SH), which calls on Suurballe’s algorithm [19] to find solutions to the CLC problem. Finally, we develop the Adaptive heuristic (AH) that extends SH by exploring a greater proportion of the solution space. We analyse the performance of our heuristics on two datasets by comparing them against the continuous and connectivity relaxations of the CLT and CLC problems respectively.

2 Problem definition

Definition 1**.**

A tour $\mathcal{T}=(v_{1},\ldots,v_{n})$ is a sequence of vertices starting and ending at the same vertex, where every two consecutive vertices in the sequence are adjacent to each other in the graph.

In the CLT problem, we are given an undirected graph $G$ where $V(G)$ denotes the set of vertices and $E(G)$ denotes the set of edges. Each edge has a weight function defined by $w:E(G)\to\mathbb{N}$ and a cost function defined by $c:E(G)\to\mathbb{N}$. We are also given a vertex $s^{\star}\in V(G)$ and weight thresholds $W_{1},W_{2}\in{\mathbb{N}}$ where $W_{1}\leq W_{2}$. Let $\phi(\mathcal{T},e)$ denote the number of times edge $e\in E(G)$ is repeated in tour $\mathcal{T}$. We denote the total cost and weight of a tour $\mathcal{T}$ by $c(\mathcal{T})=\sum_{e\in\mathcal{T}}~{}{\phi(\mathcal{T},e)\cdot c(e)}$ and $w(\mathcal{T})=\sum_{e\in\mathcal{T}}~{}{\phi(\mathcal{T},e)\cdot w(e)}$. We say a tour ${\cal T}$ is weight-feasible if and only if $W_{1}\leq w({\cal T})\leq W_{2}$.

The goal of the CLT problem is to minimise the total cost of a tour starting and ending at $s^{\star}$ such that the tour is weight-feasible. That is, the goal is to minimise $c(\mathcal{T})$ subject to $W_{1}\leq w(\mathcal{T})\leq W_{2}$ and $s^{\star}=v_{1}=v_{n}$. In the CLT Decision problem, we ask if there is a tour $\mathcal{T}=(v_{1},\ldots,v_{n})$ such that $W_{1}\leq w(\mathcal{T})\leq W_{2}$ and $c(\mathcal{T})\leq C$ where $C\in{\mathbb{N}}$. Finally, we define the Constrained Least-cost Cycle (CLC) problem, which has the same objective function and constraints as CLT, but adds the requirement that the tour must be a simple cycle that visits vertices at most once.

3 $\mathcal{NP}$-hardness

We prove that CLT Decision is $\mathcal{NP}$-hard by reducing from the unbounded subset sum problem, which is known to be $\mathcal{NP}$-hard [14; 15]. For brevity, we continue to refer to this variant as Subset Sum. We construct an instance of CLT Decision on a path, starting from an instance of Subset Sum. We show that an instance of Subset Sum is a Yes-instance if and only if our constructed instance of CLT Decision is a Yes-instance.

Definition 2**.**

In the Subset Sum problem, we are given a set of $n$ items ${\cal X}=\{z_{1},\dots,z_{n}\}$, a target value $Z\in{\mathbb{N}}$ and weight function $f:{\cal X}\to{\mathbb{N}}$, and want to decide whether there is a vector $(y_{1},\dots,y_{n})\in({\mathbb{N}_{\geq 0}})^{n}$ such that $Z=\sum_{i\in[n]}~{}y_{i}\cdot f(z_{i})$.

Theorem 1**.**

The Constrained Least-cost Tour problem is $\mathcal{NP}$-hard, even if the input graph is a path.

Proof 1*.*

Let $I=({\cal X}=\{z_{1},\dots,z_{n}\},Z,f)$ be an instance of Subset Sum. We construct an instance of CLT Decision as follows. Let $G$ denote the graph on vertex set $v_{1},\dots,v_{n+2}$ and edge set $\{e_{1},\dots,e_{n+1}\}$ where $e_{i}$ has endpoints $v_{i}$ and $v_{i+1}$ for every $i\in[n+1]$. In other words, $G$ is a path on $n+2$ vertices. For all $i\in[n]$, we define the weight function $w:E(G)\to{\mathbb{N}}$ as $w(e_{i})=f(z_{i})$ and the cost function $c:E(G)\to{\mathbb{N}}$ as $c(e_{i})=f(z_{i})$. For the last edge $e_{n+1}$, we set $w(e_{n+1})$ to be $(4Z+4\sum_{i\in[n]}w(e_{i}))^{2}$ and $c(e_{n+1})$ to be $\frac{1}{2}\cdot(2Z+2\sum_{i\in[n]}w(e_{i}))$. We set $C$ to be $4Z+4\sum_{i\in[n]}w(e_{i})$, $W_{1}$ to be $2Z+2w(e_{n+1})+2\sum_{i\in[n]}w(e_{i})$ and $W_{2}$ to be any positive integer such that $W_{1}\leq W_{2}$. Finally, we assign $s^{\star}=v_{1}$. This completes the construction of the CLT Decision instance. Clearly, the reduction is polynomial-time. We now argue that $I$ is a Yes-instance of Subset Sum if and only if the constructed instance is a Yes-instance of CLT Decision.

Suppose that $I$ is a Yes-instance of Subset Sum and let $(y_{1},\dots,y_{n})$ be the solution. Consider the “natural" tour $\mathcal{T}$ in $G$ starting at $v_{1}$, traversing every $e_{i}$ ($i\in[n]$) exactly $2y_{i}+2$ times and the edge $e_{n+1}$ exactly twice. Then, the values of $w(\mathcal{T})$ and $c(\mathcal{T})$ are precisely the following:

[TABLE]

Hence, we conclude that if $I$ is a Yes-instance, then the constructed instance of CLT Decision is a Yes-instance. Conversely, suppose that the constructed instance of CLT Decision is a Yes instance. This implies a tour $\mathcal{T}$ in $G$ starting at $v_{1}$ such that $W_{1}\leq w(\mathcal{T})\leq W_{2}$ and $c(\mathcal{T})\leq C$.

Claim 1**.**

$\mathcal{T}$* traverses every edge of $G$ at least twice and the edge $e_{n+1}$ exactly twice.*

Proof 2*.*

Observe that in order to prove the claim, it is sufficient to prove that $\mathcal{T}$ traverses $e_{n+1}$ exactly twice. ${\cal T}$ must traverse $e_{n+1}$ at least twice, since $e_{n+1}$ cannot be traversed once, and not traversing $e_{n+1}$ would contradict our assumption that $c(\mathcal{T})\leq C$. $\mathcal{T}$ must traverse $e_{n+1}$ at most twice, since otherwise ${\cal T}$ traverses $e_{n+1}$ at least four times, and we obtain $c({\cal T})>4\cdot c(e_{n+1})$ and $c({\cal T})\leq C$ which is a contradiction.

We now describe the solution vector $(y_{1},\dots,y_{n})$ for the Subset Sum instance. Recall we have already proved that for all $e\in E(G)$, $\phi(\mathcal{T},e)\geq 2$, $\phi(\mathcal{T},e)$ is even, and $\phi(\mathcal{T},e_{n+1})=2$. For every $i\in[n]$, define $y_{i}=\frac{1}{2}\phi(\mathcal{T},e_{i})-2.$ Clearly, $y_{i}\in{\mathbb{N}}\cup\{0\}$ for all $i\in[n]$ as required in the description of Subset Sum and since $\mathcal{T}$ traverses $e_{n+1}$ exactly twice, we conclude that $\sum_{i\in[n]}y_{i}\cdot w(z_{i})=Z$. Here, we use the fact that $w(\mathcal{T})\geq W_{1}$ to imply that $\sum_{i\in[n]}y_{i}\cdot w(z_{i})\geq Z$ and use $c(\mathcal{T})\leq C$ to infer that $\sum_{i\in[n]}y_{i}\cdot w(z_{i})\leq Z$. This completes the proof in the converse direction.

Theorem 1 proves CLT is ${\mathcal{N}P}$-hard when the input graph is a path, so clearly CLT is ${\mathcal{N}P}$-hard on a general graph. The CLC problem can also be shown to be ${\mathcal{N}P}$-hard by reducing from the Hamiltonian Cycle problem. We further note that if the cost function does not satisfy the triangle inequality, then CLC does not have an $\alpha$-approximation algorithm for any $\alpha\geq 1$ (assuming ${\cal P}\neq{\mathcal{N}P}$). 111See appendix for complete proofs.

4 Relaxations

Relaxing $\mathcal{NP}$-hard problems often provides useful insights about the optimal solution to the original problem and provides a lower bound we can compare our heuristics against. In this work, we consider two relaxations. Firstly, we show that on continuous graphs, the CLT problem has a polynomial-time algorithm that finds the optimal solution. In a continuous graph each edge is viewed as infinitely many vertices of degree two with infinitesimally small edges (formally the continuous graph is the geometric realisation of the graph topology). This is equivalent to saying that the multiplicity of an edge can be any positive real value ($\phi(\mathcal{T},e)\in{\mathbb{R}}^{+}$). Secondly, we give an integer programming formulation of CLC and relax the constraint that the solution must be connected.

4.1 Continuous relaxation

Let $G_{c}$ denote a continuous graph. We define the induced graph $H_{c}$ over a tour $\mathcal{T}_{c}$ of $G_{c}$ as follows. A vertex $v$ is in $H_{c}$ if $v\in\mathcal{T}_{c}$. An edge $e$ is in $H_{c}$ if the multiplicity of the edge in $\mathcal{T}_{c}$ is greater than zero. If $H_{c}$ is a path $v_{1},\dots,v_{n}$ where $v_{1}$ is the origin and $e_{i}=(v_{i},v_{i+1})$ for each $i\in[n-1]$, then we call the edge $e_{n-1}$ the head of the tour, and the remaining edges the tail of the tour. We argue that in this relaxation, we may assume that the optimal tour induces a path in $G_{c}$.

Lemma 1**.**

On a continuous graph, the induced graph of the optimal tour is a path.

Proof 3*.*

Take an optimal tour ${\cal T}^{*}_{c}$ and let $e=(u,v)$ be an edge in the induced graph $H_{c}^{*}$ which has the least cost per unit weight among the edges in $H_{c}^{*}$. Without loss of generality, suppose that $u$ is the first vertex of $e$ which is visited by ${\cal T}^{*}_{c}$ in the traversal starting from $s^{\star}$. Let $P$ denote a minimum cost path in $G_{c}$ from $s^{\star}$ to $u$. On the one hand, $w(P)$ may already be greater than $w({\cal T}^{*}_{c})$, in which case we can simply find another tour contained within $P$, of same weight as $w({\cal T}^{*}_{c})$ and at most the same cost as $c(P)$, which in turn must be at most $c({\cal T}^{*}_{c})$. But, $w(P)$ may be less than $w({\cal T}^{*}_{c})$. However, the cost of any subtour of ${\cal T}^{*}_{c}$ which starts at $s^{\star}$ and visits $u$ must still have cost at least that of $P$.

Now, consider the tour obtained by starting at $s^{\star}$, traversing $P$ and arriving at $u$, followed by taking $e$ with multiplicity $\frac{1}{w(e)}(w({\cal T}^{*}_{c})-2w(P))$, followed by taking $P$ all the way back to $s^{\star}$. Call this tour ${\cal D}^{*}_{c}$. By definition, $w({\cal D}^{*}_{c})=w({\cal T}^{*}_{C})$. Moreover, it is straightforward to see that $c({\cal D}^{*}_{c})\leq c({\cal T}^{*}_{c})$.

Thus, we can compute an optimal solution to the continuous relaxation in polynomial-time by running Dijkstra’s algorithm [5], computing the multiplicity of the head for every edge $e\in G_{c}$, and returning the least-cost solution. We also have a lower bound on the cost of an optimal discrete solution:

Corollary 1**.**

The cost of the optimal constrained least-cost tour $\mathcal{T}_{c}^{*}$ on graph $G_{c}$ is less than or equal to the cost of the optimal constrained least-cost tour $\mathcal{T}$ on $G$.

4.2 Connectivity relaxation

We first turn our attention to an integer programming (IP) formulation for the CLC problem. Let $e_{ij}\in E(G)$ be an edge between vertex $i$ and $j$. We place the variable $x_{ij}\in\{0,1\}$ on the edges of the graph. The objective function is to minimise $\sum_{ij}~{}{x_{ij}\cdot c(e_{ij})}$ subject to $W_{1}\leq\sum_{ij}~{}{x_{ij}\cdot w(e_{ij})}\leq W_{2}$ for all $e_{ij}\in E(G)$. Let $x(S)=\sum_{ij}~{}{x_{ij}}$ for a subset $S\in E(G)$ and $\mathcal{A}_{i}\subset E(G)$ be the set of edges $e_{ij}$ adjacent to vertex $i$. We add the constraints $x(\mathcal{A}_{s})=2$ to enforce $\mathcal{T}$ starts and ends at the origin $s^{\star}$, and $\forall i\in V(G):\frac{1}{2}x(\mathcal{A}_{i})\in\{0,1\}$ to ensure $\mathcal{T}$ is closed. Finally, we add the sub-tour elimination constraint [4; 16] to enforce connectivity. Optimally solving an IP that enforces connectivity is not be practical in our application of a runner requesting a route, since the user might have to wait for too long as the size of the graph and length of the requested run increase. Thus we relax the connectivity constraint and use the resulting IP as a lower bound on the optimal solution of CLC to compare our heuristic against.

5 Heuristics

Our approach is to develop heuristics that run in polynomial-time and return close to optimal solutions in real-world environments. Fig. 1 shows examples for each algorithm. First, we present the Déjà Vu (DjV) heuristic for the CLT problem that exploits the continuous relaxation.222The repetitive nature of the low-cost edge is where the name “Déjà Vu” comes from. Next, we propose Suurballe’s heuristic (SH) that finds low-cost cycles for the CLC problem. Finally, we introduce the Adaptive heuristic (AH) which extends SH to explore a greater proportion of the solution space.

5.1 Déjà Vu Heuristic

Our Déjà Vu (DjV) heuristic exploits the intuition that the optimal solution to CLT on a continuous graph is a good indicator of a low-cost solution to CLT on a discrete graph. DjV walks along a path to an edge with low cost, repeats this edge with some positive even multiplicity, then walks back along the same path to the origin.

DjV computes the least-cost tree rooted at $s^{\star}$. We store the parent $\pi_{v}$ and cost $l_{v}$ of the least-cost path $\Pi(s^{\star},v)$ from $s^{\star}$ to $v$. For each edge $e\in E(G)$, we extract $\Pi(s^{\star},x)$ where $x$ is the endpoint of $e$ with least $l_{x}$. If $2w(\Pi(s^{\star},x))+2w(e)\leq W_{2}$, then the multiplicity of edge $e$ in tour $\mathcal{T}$ is

[TABLE]

where $f$ rounds up to the closest positive even integer. The time-complexity of DjV is ${\cal O}(n\log n)$.

5.2 Suurballe’s heuristic

We now propose Suurballe’s heuristic (SH) which uses the fact that a pair of vertex-disjoint simple paths between two vertices $u$ and $v$ form a simple cycle ${\cal C}$. Suurballe’s algorithm [18; 19] solves the Shortest Pairs of disjoint paths problem: given a directed, weighted graph $G^{\prime}$, find a pair of edge-disjoint paths with minimum total cost from a source vertex $s^{\star}$ to a sink vertex $v$, for every possible sink $v\in G^{\prime}$. Suurballe and Tarjan [19] give an algorithm for Shortest Pairs with time complexity ${\cal O}(m\log n)$. Their algorithm requires $G^{\prime}$ to be asymmetric, that is if $(x,y)$ is an arc in $G^{\prime}$, then $(y,x)$ is not in $G^{\prime}$. To construct a directed, asymmetric graph $G^{\prime}$ from our undirected graph $G$, we use the vertex splitting transformation as described by Suurballe and Tarjan. The splitting transformation also allows us to compute vertex-disjoint paths on $G^{\prime}$ using Suurballe and Tarjan’s edge-disjoint algorithm.

Given $G^{\prime}$, SH runs Suurballe’s algorithm and computes the cost of the shortest pairs of vertex-disjoint paths $\Lambda(s^{\star},v)$ from $s^{\star}$ to every vertex $v\in V(G^{\prime})$. From $\Lambda(s^{\star},v)$, we construct a simple cycle ${\cal C}$ containing $s^{\star}$ and $v$. We return the least-cost simple cycle ${\cal C}$ that is weight-feasible ($W_{1}\leq w({\cal C})\leq W_{2}$). The time complexity of the heuristic is ${\cal O}(m\log n)$ under the assumption that the number of vertices in ${\cal C}$ is much smaller than the number of edges in the graph. The weakness of SH is it only considers a small subset of the solution space to CLC. This subset covers all cycles which can be constructed by finding the least-cost pair of vertex-disjoint paths from $s^{\star}$ to a vertex $v$ in the graph.

5.3 Adaptive heuristic

The Adaptive heuristic (AH) extends SH by exploring a larger solution space. This space encompasses all cycles containing the origin that are formed by computing the least-cost pair of vertex-disjoint paths between every pair of vertices in the graph. Thus the solution space of SH is a subset of the solution space of AH. Psuedocode for AH is given by Algorithm 1. The time-complexity of AH is ${\cal O}(n\cdot m\log n)$ because we must compute Suurballe and Tarjan’s algorithm [19] at most $n=|V(G)|$ times. The increase in time-complexity is the price to pay for exploring more solutions.

6 Experiments

We now present the results from running our heuristics on two datasets and comparing them against our relaxations.333AH = adaptive heuristic, CR = continuous relaxation, XR = connectivity relaxation, SH = Suurballe’s heuristic, DjV = Déjà Vu heuristic. Code available at \urlhttps://patrickohara.github.io/CLT-problem/. DjV is compared against CR. SH and AH are compared against XR. Every algorithm is tested at 10 different weight thresholds and 10 random origins. The gap between $W_{1}$ and $W_{2}$ is kept constant at 250 meters for the pollution dataset and 5 units for the Crucible dataset. Experiments for the heuristics and continuous relaxation are computed on a Microsoft Azure virtual machine with four CPUs and 14GB of memory running Linux. The connectivity relaxation is computed using the IBM Decision Optimisation Cloud service with 10 cores and 60GB of memory. We set the maximum time limit for IP to solve the connectivity relaxation to one hour. We reduce the size of our input graph with two pre-processing steps. The first removes vertices which cannot be reached from $s^{\star}$ within $W_{2}/2$. The second removes all leaves from the graph when solving the CLC problem, and so is only applied to SH, AH and XR.

Figs. 2 and 3 show the effect of increasing the weight thresholds. Figs 4 and 5 display examples of routes computed by our heuristics for the Crucible and air quality dataset respectively. Table 2 summarises the overshoot and margin of error. The overshoot of a tour ${\cal T}$ is defined as $w({\cal T})-W_{1}$. The margin of error of a heuristic ${\cal H}$ against its relaxation ${\cal R}$ is defined as $100\times(c({\cal H})-c({\cal R}))/c({\cal R})$444Further details of our pre-processing, methodology and datasets are available in Section D of the appendix..

6.1 Datasets

We conduct experiments on two different datasets to show our methods work in different environments. The air quality dataset contains around $12000$ vertices and $16000$ edges. The Crucible dataset contains $260000$ vertices and $150000$ edges. These datasets are pre-procecessed as described above, thus reducing the size of the input graph before we execute our algorithms.

Air quality in London: The goal is to minimise air pollution exposure of a runner in London such that the total distance of the route is within a given range. We assume people run on the London road network. Vertices in $G$ represent road intersections and edges represent the roads. The weight of an edge is the distance of a road and the cost of an edge is the total pollution a runner is exposed to by running along the road. The air quality model of London is a non-stationary mixture of Gaussian Processes [21; 1] that predicts air quality (nitrogen dioxide) from data such as sensors, road traffic and weather. We note that our methods are not dependent on the type of model used. The output of the model is a two-dimensional grid which overlays the road network. The cost of an edge $e$ is the mean pollution of the grid squares intersecting $e$ in space multiplied by the weight of $e$. We assume the pollution (cost) is uniformly distributed along an edge.

The Crucible: Our second application finds tours which seek a diverse variety of environment types in “The Crucible” map from the game Warcraft III [17]. The map consists of grid squares (512 by 512) belonging to one of the following five environment types (classes): normal ground (1), shallow water (2), trees (3), water (4) and out of bounds (5). An agent moving in the environment can only traverse normal ground, thus classes 2-5 trees are all defined as impassable for an agent. Let a vertex in $G$ represents a grid square in the map. If a grid square is surrounded by a diverse variety of environment types, then the representative vertex will have high entropy. We define the entropy of a vertex $v$ by $\mathcal{E}(v)=\sum_{c=1}^{C}~{}{-P_{c}\log P_{c}}$ where $C$ is the number of classes and $P_{c}$ is the probability of class $c$ appearing in a 7 by 7 grid centered on vertex $v$. A unit weight edge $e_{u,v}$ exists between vertex $u$ and $v$ if both $u$ and $v$ are passable. The cost of an edge is defined by $c(e_{u,v})=1-\frac{1}{2}(\mathcal{E}(u)+\mathcal{E}(v))$.

6.2 Discussion

CLT: DjV yields consistently low-cost tours which have error $\approx 1\%$ on both datasets (Table 2) when compared to the CR lower bound. Fig. 4 demonstrates the algorithm traversing a path to an edge with low-cost, repeating this edge 18 times (the long, flat line on right of Fig. 4), before returning to the origin. DjV traverses every edge with even multiplicity so the total weight of every tour will be even (assuming $w:E(G)\to\mathbb{N}$). Thus DjV does not consider low-cost solutions with odd weight, so if $W_{1}=W_{2}$ and $W_{1},W_{2}$ are odd integers, then DjV will not return a solution. However, the ${\cal O}(n\log n)$ time-complexity means DjV is fast (right of Figs. 2 and 3) and the algorithm works well for a general $W_{1},W_{2}$ in practise.

CLC: AH significantly outperforms SH on both datasets because it explores a larger proportion of the solution space. SH also significantly overshoots the lower weight threshold compared to AH (Table 2), resulting in SH traversing more weight and thus (in general) more cost. However, the trade-off for lower cost solutions is the ${\cal O}(n\cdot m\log n)$ time-complexity of AH compared to the ${\cal O}(m\log n)$ running time of SH. The right of Figs. 2 and 3 clearly show this difference in time, and also highlights how long it takes for the integer program (IP) to optimally solve XR. Indeed, the drop off in cost in Fig. 2 (left) for XR correlates with the point where the IP is no longer solving instances optimally because the running time is cut-off at 1 hour (Fig. 2 right). In Fig. 3 (right), the IP quickly hits the cut-off time limit because the size of the Crucible graph is bigger, so the IP only returns a bound and not the optimal solution for $W_{1}>20$. Thus for $W_{1}>2500m$ in the pollution dataset and $W_{1}>20$ for the Crucible dataset, the XR lower bound is actually larger than the given value, and so we are slightly over-estimating the error for AH and SH.

7 Final remarks

We have introduced the Constrained Least-cost Tour problem: an $\mathcal{NP}$-hard routing problem with the motivating application of finding running routes that minimise air pollution exposure in a city (see Fig. 5). We have derived relaxations and proposed heuristics for weak tours (CLT) and strong tours (CLC). Experiments on both datasets show our algorithms perform competitively when compared to our derived lower bounds. Finally, the motivating application of “running from air pollution" has a rich problem structure that we plan to further exploit; multiple pollutants, varying human sensitivities to different pollutants and uncertainty of the forecasting models.

Acknowledgements

Patrick O’Hara and Theodoros Damoulas are funded by the Lloyds Register Foundation programme on Data Centric Engineering through the London Air Quality project. This work was furthermore supported by The Alan Turing Institute for Data Science and AI under EPSRC grant EP/N510129/1 in collaboration with the Greater London Authority. Patrick O’Hara was previously supported by the Warwick Impact Fund. We would like to thank Oliver Hamelijnck (The Alan Turing Institute) for providing the air quality predictions of London and further thank the anonamous reviewers of IJCAI for their useful feedback.

Appendix A ${\mathcal{N}P}$-hardness

For completeness we give full proofs of Theorem 1, the ${\mathcal{N}P}$-hardness of CLC and the approximation of CLC.

A.1 The CLT Problem

We expand upon the proof of Theorem 1 in the paper. In particular, we expand on Claim 1.

Theorem**.**

The Constrained Least-cost Tour Problem is ${\mathcal{N}P}$-hard, even when the input graph is a path.

Proof.

Recall from the paper that we construct an instance of CLT Decision from an instance $I$ of Subset Sum. We argue that $I$ is a Yes-instance of Subset Sum if and only if the constructed instance is a Yes-instance of CLT Decision.

Suppose that $I$ is a Yes-instance of Subset Sum and let $(y_{1},\dots,y_{n})$ be the solution. Consider the “natural" tour $\mathcal{T}$ in $G$ starting at $v_{1}$. For every $i\in[n]$, ${\cal T}$ traverses $e_{i}$ exactly $2y_{i}+2$ times. The edge $e_{n+1}$ is traversed exactly twice. Thus, the value of $w(\mathcal{T})$ is precisely the following:

[TABLE]

Similarly the value of $c(\mathcal{T})$ is:

[TABLE]

Hence, we conclude that if $I$ is a Yes-instance, then the constructed instance of CLT Decision is a Yes-instance.

Conversely, suppose that the constructed instance of CLT Decision is a Yes instance. This implies we have a tour $\mathcal{T}$ in $G$ starting at $v_{1}$ such that $W_{1}\leq w(\mathcal{T})\leq W_{2}$ and $c(\mathcal{T})\leq C$.

Claim**.**

$\mathcal{T}$* traverses every edge of $G$ at least twice and the edge $e_{n+1}$ exactly twice.*

Proof.

Observe that in order to prove the claim, it is sufficient to prove that $\mathcal{T}$ traverses $e_{n+1}$ exactly twice. This is because $G$ is a path and any tour containing $v_{1}$ and $v_{n+2}$ must traverse every edge of $G$ at least once and any tour in $G$ containing $v_{1}$ must traverse every edge of $G$ an even number of times. Consequently, we now focus on proving that $\mathcal{T}$ traverses $e_{n+1}$ exactly twice.

We first show that $\mathcal{T}$ traverses $e_{n+1}$ at least twice. Suppose not. Then, $\mathcal{T}$ does not traverse $e_{n+1}$ at all. Note that we have defined $W_{1}$ such that $W_{1}\geq 2w(e_{n+1})$ and since $\mathcal{T}$ is a solution for the instance of CLT Decision, we know that $w(\mathcal{T})\geq W_{1}$. Then, by the pigeonhole principle, there must be an edge $e_{i}\in\{e_{1},\dots,e_{n}\}$ such that the multiplicity of $e_{i}$ in $\mathcal{T}$ is greater than $W_{1}/w(e_{i})$ and hence greater than $4Z+4\sum_{i\in[n]}w(e_{i})$, which is precisely the value of $C$. This contradicts our assumption that $c(\mathcal{T})\leq C$. Hence we conclude that $\mathcal{T}$ traverses $e_{n+1}$ at least twice.

It remains to argue that $\mathcal{T}$ traverses $e_{n+1}$ at most twice. Suppose that this is not the case and that the edge $e_{n+1}$ occurs at least 3 times in $\mathcal{T}$. Then, it must be the case that $e_{n+1}$ appears at least 4 times in $\mathcal{T}$. In this case, $c(\mathcal{T})>4\cdot c(e_{n+1})$ and $c(\mathcal{T})\leq C$, which is a contradiction since we chose $c(e_{n+1})$ in such a way that $C=4c(e_{n+1})$. Hence we conclude that $\mathcal{T}$ traverses $e_{n+1}$ at most twice. ∎

We now describe the solution vector $(y_{1},\dots,y_{n})$ for the Subset Sum instance. Recall we have already proved that for all $e\in E(G)$: $\phi(\mathcal{T},e)\geq 2$ and $\phi(\mathcal{T},e)$ is even. For the last edge: $\phi(\mathcal{T},e_{n+1})=2$. For every $i\in[n]$, define $y_{i}=\frac{1}{2}\phi(\mathcal{T},e_{i})-2.$ Clearly, $y_{i}\in{\mathbb{N}}\cup\{0\}$ for all $i\in[n]$ as required in the description of Subset Sum.

It remains to argue that $\sum_{i\in[n]}~{}{y_{i}\cdot f(z_{i})}=Z$. Since $\mathcal{T}$ traverses $e_{n+1}$ exactly twice, we first use the fact that $w(\mathcal{T})\geq W_{1}$ to conclude that $\sum_{i\in[n]}y_{i}\cdot f(z_{i})\geq Z$:

[TABLE]

and use $c(\mathcal{T})\leq C$ to infer that $\sum_{i\in[n]}y_{i}\cdot w(z_{i})\leq Z$:

[TABLE]

This completes the proof in the converse direction, and thus the proof of the theorem. ∎

A.2 The CLC Problem

Definition**.**

Given an undirected graph $G$ with vertices $V(G)$ and edges $E(G)$, the Hamiltonian Cycle (HC) problem is to find a cycle ${\cal C}$ that visits every vertex in the graph exactly once.

Given a graph $G$ with a weight function $w:E(G)\to\mathbb{N}$ and cost function $c:E(G)\to\mathbb{N}$ on the edges; a start vertex $s^{\star}\in V(G)$; two weight thresholds $W_{1},W_{2}\in\mathbb{N}$ and a cost threshold $C\in\mathbb{N}$, the CLC-Decision problem asks is there a strong tour ${\cal T}$ starting and ending at $s^{\star}$ such that $W_{1}\leq w({\cal T})\leq W_{2}$ and $c({\cal T})=C$.

Theorem**.**

The Constrained Least-cost Cycle (CLC) Problem is ${\mathcal{N}P}$-hard.

Proof 4*.*

To prove CLC-Decision is ${\mathcal{N}P}$-hard, we find a polynomial-time reduction from HC. We note that HC is ${\mathcal{N}P}$-complete. Let $I$ be an instance of HC on a graph $G$ with vertices $V(G)=\{v_{1},\ldots,v_{n}\}$ and edges $E(G)$. We construct an instance of CLC-Decision as follows. Let the cost and the weight of every edge be 1. Set $W_{1}=W_{2}=C=n$ where $n$ is the number of vertices in $G$. Let $s^{\star}=v_{1}$. The reduction is clearly polynomial. We prove that $I$ is a Yes-instance of HC if and only the constructed instance of CLC-Decision is a Yes-instance.

Suppose $I$ is a Yes-instance. Then $I$ is a simple cycle ${\cal C}$ that visits every vertex in the graph (including $v_{1}$) exactly once. The cycle is a strong tour ${\cal T}$ that traverses exactly $n$ edges and includes the start vertex $v_{1}$. Thus the total weight of ${\cal T}$ on the constructed instance of CLC-Decision is $w({\cal T})=n=W_{1}=W_{2}$ and the total cost is $c({\cal T})=n=C$. Hence we conclude the constructed instance is a Yes-instance.

Now suppose the constructed instance of CLC-Decision is a Yes-instance. Then we have a strong tour ${\cal T}$ that starts at the origin $v_{1}$, visits every vertex at most once, and has total weight $n=W_{1}=W_{2}$ and total cost $n=C$. We need to show that ${\cal T}$ visits every vertex exactly once. Suppose otherwise. Then there must exist a vertex $u$ that has not been visited by ${\cal T}$, which implies ${\cal T}$ is a simple cycle on at most $n-1$ vertices that has total weight and total cost of $n$. This is clearly not possible since edges have unit weight and unit cost. Thus we conclude that ${\cal T}$ visits every vertex exactly once and the strong tour is a Hamiltonian cycle.

A.3 Approximation of CLC

Definition**.**

Let OPT be the cost of the optimal solution to a problem and $\alpha\in{\mathbb{R}}$ be greater than or equal to 1. An algorithm is an $\alpha$-approximation algorithm if and only if for every instance of the problem it returns a solution within a factor $\alpha$ of OPT.

When referring to an $\alpha$-approximation algorithm, we shall mean that the algorithm must run in polynomial-time.

Lemma**.**

For CLC without the triangle inequality assumption, there does not exist an $\alpha$-approximation algorithm for any $\alpha\geq 1$, provided ${\cal P}\neq{\mathcal{N}P}$.

Proof 5*.*

Given an instance $G$ of HC with vertices $V(G)$ and edges $E(G)$, construct an instance of CLC on a complete graph ${\cal K}$ as follows. For all $e\in E(G)$, let $c(e)=w(e)=1$ in ${\cal K}$. For all pairs of vertices $i,j\in V(G)$ for which $e_{ij}\notin E(G)$ and $i\neq j$, let $c(e_{ij})=\alpha\cdot n$ and $w(e_{ij})=1$. Let $W_{1}=W_{2}=n$ where $n$ is the number of vertices. Assume there exists an $\alpha$-approximation algorithm (Apx) for CLC. We show that such an algorithm can be used to solve HC in polynomial time.

First suppose there exists a Hamiltonian cycle in $G$. Then the optimal solution OPT for CLC will have cost $n$ and weight $n$, so $c(\text{\sc Apx})\leq\alpha\cdot n$. Now suppose there does not exists a Hamiltonian cycle in $G$. Then OPT must use one edge not in $G$ with cost $\alpha\cdot n$. The cost of OPT will therefore be $c(OPT)\geq n-1+\alpha\cdot n$.

Hence we conclude that $G$ has a Hamiltonian cycle if and only if the cost of Apx is at most $\alpha\cdot n$.

Appendix B An Integer Programming Formulation of the CLC Problem

Recall that $x_{ij}$ is a 0-1 variable placed on the edges in graph $G$, ${\cal A}_{i}$ is the set of edges adjacent to vertex $i$, and $x(S)$ is the sum of $x_{ij}$ variables on edge set $S\subset E(G)$.

[TABLE]

There are several ways to define the subtour elimination constraint. We give one such formulation using cutsets:

[TABLE]

where $\Phi(i,j)$ is the set of minimal $ij$-edge cuts. That is, each cut in $\Phi(i,j)$ is a minimal set of edges that if removed would disconnect $i$ and $j$ in the graph. The connectivity relaxation uses the objective function (1) with contraints (2)-(5) from the IP formulation above, but relaxes constraint (6).

Appendix C Suurballe’s Algorithm

In the CLT/CLC problem, we are given an undirected graph $G$ with vertices $V(G)$ and edges $E(G)$. Edges have a weight function $w:E(G)\to\mathbb{N}$ and a cost function $c:E(G)\to\mathbb{N}$. However, Suurballe’s algorithm requires a directed input graph that is asymmetric, that is if $(x,y)$ is an arc in the graph, then $(y,x)$ is not in the graph.

We construct a directed, asymmetric graph $G^{\prime}$ from the undirected graph $G$ as follows. For each vertex $v\in V(G)$, split $v$ into two vertices $v_{1}$ and $v_{2}$ and add them to $V(G^{\prime})$. Add a directed split arc from $v_{1}$ to $v_{2}$ in $G^{\prime}$ with zero cost and zero weight. For every undirected edge $e_{u,v}$ adjacent to $v$ in $G$, add a directed arc from $v_{2}$ to $u_{1}$ in $G^{\prime}$ with the same weight and cost as $e_{u,v}$ in $G$. The construction requires $O(m+n)$ time and space complexity.

Appendix D Experiments

In this section, we expand upon the pre-processsing algorithms, methodology and datasets uses for the experiments. To run our algorithms on the same datasets, please refer to our GitHub repository555\urlhttps://patrickohara.github.io/CLT-problem/.

D.1 Pre-processing

We use two pre-processing methods to reduce the size of the graph. The time taken for pre-processing is not included when timing the algorithms on the right of Figures 2 and 3. The first pre-processing algorithm removes vertices from the graph that cannot be reached from the origin within weight $\frac{W_{2}}{2}$, that is, if the weight of the shortest path from the origin to a vertex $u$ is greater than $\frac{W_{2}}{2}$, then remove $u$ from the graph (see Algorithm 2). The second removes vertices with degree one (leaves) and is given in Algorithm 3. It uses a recursive depth first search to remove leaves from the graph.

D.2 Datasets

We compare our heuristics on two different datasets to show that our methods can be applied in different contexts. The contrast between the air quality (AQ) dataset and the Crucible dataset is also interesting. Firstly, the structure of the graph in the Crucible is a grid, whereas the AQ graph is a road network. Running heuristics on different types of graphs can often highlight strengths of weaknesses, although in our experiments there were no such notable strengths or weaknesses. Secondly, the cost function on edges in the two datasets is spatially distributed in a very different way. In the Crucible, there are large areas of space where in all edges will have uniform cost. Compare this to AQ in which there are large areas of space with relatively low air pollution (cost) with localised peaks of highly polluted air. Despite these differences, our heuristics have a similar margin of error on both datasets when compared to their respective relaxations (Table 2).

Air quality in London

The road network of London was downloaded from the Ordnance Survey666\urlhttps://www.ordnancesurvey.co.uk. The air quality prediction shown in Fig. 6 are a snapshot from an AQ model of London. The model is currently under development at the Alan Turing Institute. We emphasise that our algorithms are not dependent upon the model of air quality. The road network was pruned using an SQL PostGIS query to return all roads that intersect with the prediction area of the AQ model.

The Crucible

Fig. 7 shows the Crucible dataset which can be downloaded from Moving AI777\urlhttps://www.movingai.com/benchmarks/wc3maps512/index.html. The aim of the agent is to find a tour that visits a diverse range of environment types. The original dataset is shown in Fig. 7(a) and the diversity of environment types is shown in Fig. 7(b). The agent will seek the darker areas of Fig. 7(b). The darker areas show borders between different environment types, for example where the normal ground (class 1) meets trees (class 3).

D.3 Additional details

The heuristics and relaxations are coded using Python. Specifically, we use the networkx library to store the graph datastucture. The machines used to compute the results are given in the paper: the first was an Azure virtual machine (VM) for the heuristics and the continuous relaxation (CR); and the second was an IBM Cloud machine running the CPLEX library for the connectivity relaxation (XR). Using a more powerful machine for the XR means that the time taken to compute a result is not comparible to the time taken to compute a result for heuristics and CR. However, Figs. 2 and 3 [right] show that even with a more powerful machine, XR still takes substantially more time to find an solution that any of the heuristics or CR. Further, the important algorithms to compare in terms of time are the Adaptive heuristic and Suurballe’s heuristic, since they are the two competing algorithms for the CLC problem.

For each dataset, 10 vertices were chosen randomly from a uniform distribution. Each dataset was given 10 weight thresholds Each heuristic and each relaxation were tested for each configuration. For each solution to a relaxation, we record the total weight, total cost, number of vertices in the solution, the overshoot, number of vertices and edges in the pre-processed input graph and the time taken in seconds. In addition to the above quantities, we calculate the margin of error for each heuristic compared to the appropriate relaxation.