Clustering in Discrete Path Planning for Approximating Minimum Length Paths

TL;DR

This paper introduces Gamma-Clustering, a method for discrete robot path planning on graphs that reduces computational complexity while maintaining near-optimal solutions, demonstrated through traveling salesman problem instances.

Contribution

The paper presents a novel clustering approach for graph-based path planning that balances solution quality and search space reduction, with an efficient algorithm for optimal clustering.

Findings

Significant reduction in computation time on TSP instances

Solutions remain close to optimal despite clustering

Optimal Gamma-Clusters are unique and efficiently found

Abstract

In this paper we consider discrete robot path planning problems on metric graphs. We propose a clustering method, Gamma-Clustering for the planning graph that significantly reduces the number of feasible solutions, yet retains a solution within a constant factor of the optimal. By increasing the input parameter Gamma, the constant factor can be decreased, but with less reduction in the search space. We provide a simple polynomial- time algorithm for finding optimal Gamma-Clusters, and show that for a given Gamma, this optimal is unique. We demonstrate the effectiveness of the clustering method on traveling salesman instances, showing that for many instances we obtain significant reductions in computation time with little to no reduction in solution quality.

Figures

Tables

Table 1. TABLE I: Experimental results for TspLib instances: | C | 𝐶 |C| reports the number of Γ Γ \Gamma -Clusters, % error reports the average error from optimal and time column reports the average solver time. The instances where the CTSP ∗ superscript CTSP \text{CT{\scriptsize SP}}^{*} approach outperforms the TSP approach are highlighted in bold. Results are sorted from least to most difficult for the non-clustered approach.

		TSP		${\text{CTSP}}^{\ast }$
	$\left|C\right|$	% Error	Time ($t$)	% Error	Time ($t$)
burma14	5	0.00	1	0.39	1
ulysses16	6	0.00	1	0.73	1
berlin52	17	0.00	1	0.06	1
swiss42	16	0.00	1	0.94	1
eil51	11	0.00	1	0.00	1
eil76	13	0.00	3	0.00	1
rat99	28	0.00	6	0.83	13
eil101	16	0.00	8	0.00	4
ulysses22	10	0.00	8	0.00	1
pr76	27	0.00	40	1.40	11
st70	23	0.00	45	0.44	13
lin105	42	0.00	225	0.00	8
kroE100	43	0.00	414	0.39	20
kroC100	46	0.00	445	0.00	12
kroA100	44	0.00	602	1.11	23
gr96	32	0.00	845	0.05	38
bier127	37	0.00	900	0.23	24
gr137	44	0.00	900	0.00	154
kroD100	42	0.00	900	0.57	471
kroB100	42	0.01	900	0.96	900
ch130	59	0.20	900	0.90	29
ch150	53	0.22	900	0.31	900
kroB150	65	0.35	900	0.35	395
kroA150	58	1.37	900	0.15	492
rat195	57	1.75	900	0.89	900
kroA200	82	5.59	900	1.38	900
pr124	18	5.78	900	4.24	900
gr202	74	8.56	900	0.64	703
pr136	48	9.78	900	4.88	900
kroB200	80	10.16	900	0.67	900
pr107	6	13.01	900	0.40	900
a280	11	20.11	900	20.46	900
pr144	40	24.40	900	20.03	900
tsp225	66	28.50	900	5.76	900
gr229	73	28.63	900	2.24	900
pr152	44	40.64	900	41.15	900
gil262	98	44.81	900	21.00	900

Equations

$${\alpha }_i$$

$${\beta }_i$$

$${\Gamma }_i$$

$$\Delta$$

$$\le c(v_a,v_b)+{\beta }_i+c(v_y,v_z)-c(v_a,v_b)-c(v_y,v_z)$$

$$\le {\beta }_i$$

$$\Delta$$

$$\le {\beta }_i+c(v_b,v_c)-c(v_b,v_c)$$

$$\le {\beta }_i$$

$$\hat{c}\ge c+2(n+1)\left(\frac{3}{2}\right){\beta }_i=c+3(n+1){\beta }_i$$

$${\hat{c}}^{\prime }\le c^{\prime }+2\left(\frac{3}{2}{\beta }_i\right)\le c+(2n+1){\beta }_i+3{\beta }_i.$$

$${\hat{c}}^{\prime }-\hat{c}$$

$$=2n{\beta }_i+{\beta }_i+3{\beta }_i-3n{\beta }_i-3{\beta }_i$$

$$={\beta }_i-n{\beta }_i$$

$$\hat{c}(p^{\prime })\le \hat{c}(p^{\ast })$$

$$\hat{c}(p^{\prime })\le \hat{c}(p^{\ast }).$$

$$\hat{c}(v_a,v_b)$$

$$=c(v_a,v_b)+\frac{3}{2}\max \left(\frac{{\alpha }_i}{{\Gamma }_i},\frac{{\alpha }_j}{{\Gamma }_j}\right)$$

$$\le \left(1+\frac{3}{2}\max \left(\frac{1}{{\Gamma }_i},\frac{1}{{\Gamma }_j}\right)\right)c(v_a,v_b)$$

$$\le \left(1+\frac{3}{2\Gamma }\right)c(v_a,v_b)$$

$$\hat{c}(p^{\ast })\le \left(1+\frac{3}{2\Gamma }\right)c(p^{\ast }).$$

$$(c^{\prime }{)}^{\ast }\le \hat{c}(p^{\ast }),$$

$$(c^{\prime }{)}^{\ast }\le c(p^{\prime })\le \hat{c}(p^{\prime })\le \hat{c}(p^{\ast }).$$

$$(c^{\prime }{)}^{\ast }\le \left(1+\frac{3}{2\Gamma }\right)c^{\ast }.$$

$$\underset{|V|\to \infty }{\lim }(c^{\prime }{)}^{\ast }=\left(1+\frac{2}{2\Gamma +1}\right)c^{\ast }.$$

$$p^{\ast }$$

$$c^{\ast }$$

$$=\left(n+1\right)\left(2\alpha +\beta \right)$$

$$=\left(n+1\right)\left(2+\frac{1}{\Gamma }\right)\alpha$$

$$(p^{\prime })\ast$$

$$(c^{\prime }{)}^{\ast }$$

$$=2\alpha +3\beta -2\beta +n(2\alpha +3\beta )$$

$$=(n+1)(2\alpha +3\beta )-2\beta$$

$$=\left((n+1)(2+\frac{3}{\Gamma })-\frac{2}{\Gamma }\right)\alpha$$

$$\underset{n\to \infty }{\lim }(c^{\prime }{)}^{\ast }$$

$$=\left(\frac{2+\frac{3}{\Gamma }}{2+\frac{1}{\Gamma }}\right)c^{\ast }$$

$$=\left(1+\frac{2}{2\Gamma +1}\right)c^{\ast }$$

$$r\equiv \frac{N_0}{N_1}=\frac{|V|!}{m!{\prod }_i^m|V_i|!}$$

$$r=\Omega \left((m!{)}^{x-1}\right),$$

$$|V|!$$

Full text

I Introduction

Discrete path planning is at the root of many robotic applications, from surveillance and monitoring for security, to pickup and delivery problems in automated warehouses. In such problems the environment is described as a graph, and the goal is to find a path in the graph that completes the task and minimizes the cost function. For example, in monitoring, a common problem is to compute a tour of the graph that visits all vertices and has minimum length [1]. These discrete planning problems are typically NP-hard [1, 2], and thus there is a fundamental trade off between solution quality and computation time. In this paper we propose a graph clustering method, called $\Gamma$-Clustering, that can be used to reduce the space of feasible solutions considered during the optimization. The parameter $\Gamma$ serves to trade-off the feasible solution space reduction (and typically computation time) with the quality of the resulting solution.

The idea behind $\Gamma$-Clustering is to group vertices together that are in close proximity to each other but are also far from all other vertices. Figure 1 shows an example of $\Gamma$-Clustering in an office environment. Given this clustering, we solve the path planning problem by restricting the path to visit vertices within each cluster consecutively (i.e., no path can visit any cluster more than once). This restriction reduces the number of possible solutions exponentially and thus reduces the amount of computational time needed to find good solutions.

Unlike other clustering methods, $\Gamma$-Clustering does not accept as input a desired number of clusters. This means that some instances will have no clusters, while others will have many. In this way, $\Gamma$-Clusters only explore natural structures within the problem instances instead of imposing structures onto the instance. Additionally, when the graph is metric, we establish that for a given $\Gamma$-Clustering, the optimal path of the clustered planning problem is within a constant factor (dependent on $\Gamma$) of the true optimal solution.

Related work

There are a number of clustering methods for Euclidean [3, 4] and discrete [5, 6, 7] environments. Typically the objective of these algorithms is to find a set of equal (or roughly equal) non-overlapping clusters that are grouped by similarity (close in proximity, little to no outgoing edges, etc …), where each location in the graph is assigned to one cluster. For these methods, the desired number of clusters is given as an input parameter. In contrast, in $\Gamma$-Clustering, the idea is to simply find a specific form of clustering within the environment, if it exists. These $\Gamma$-Clusters may be nested within one another.

There are other clustering methods that also look for specific structures within the graph such as community structures [8], which is based on a metric that captures the density of links within communities to that between communities. In contrast, our clustering method is specifically designed to find structures that yield desirable properties for path planning on road maps.

The use of clustering to save on processing/time is done in a variety of different fields such as data mining [9], parallel computer processing [10], image processing [11], and control [12] for path planning. In environments that have regions with a high degree of connectivity, such as electronic circuits, clustering is commonly used to identify these regions and then plan (nearly) independently in each cluster [13]. For path planning problems with repetitive tasks, one can cluster a set of popular robot action sequences into macros [14, 15], allowing the solver to quickly discover solutions that benefit from these action sequences. In applications such as sensor sweeping for coverage problems [16] or in the routing of multiple agents [17], clustering has been used to partition the environment into regions that can again be treated in a nearly independent manner, reducing computation time.

There is some prior work on partitioning in discrete path planning. Multilevel refinement [18] is the process of recursively coarsening the graph by aggregating the vertices together to create smaller and smaller instances, for which a plan can be found more easily. The plan is then recursively refined to obtain a solution to the original problem. The idea in coarsening a graph is that the new coarse edges should approximate the transition costs in the original graph. This differs from $\Gamma$-Clustering, which preserves the edges within the graph. There are a number of clustering approaches that aim to reduced the complexity of Euclidean and or planar TSP problems [19, 20]. $\Gamma$-Clustering is more general, in that it works on any graph, while the solution quality guarantees only hold for metric graphs.

Contributions

The main contribution of this paper is the introduction of $\Gamma$-Clustering, a clustering method for a class of discrete path planning problems. We establish that the solution to the corresponding clustered problem provides a $\min\left(2,1+\frac{3}{2\Gamma}\right)$-factor approximation to the optimal solution. We give some insight into the reduction of the search space as a function of the amount of clustering, and we provide an efficient algorithm for computing the optimal $\Gamma$-Clustering. We then use an integer programming formulation of the TSP problem to demonstrate that for many problem instances the clustering method reduces the computation time while still finding near-optimal solutions.

II Preliminaries in Discrete Path Planning

In this section we define the class of problems considered in this paper, review some semantics of clusters, review the traveling salesman problem (TSP) [21] and define its clustered variant, the general clustered traveling salesman problem ($\text{CT{\scriptsize SP}}^{*}$).

II-A Discrete Path Planning

Given a graph $G=\left\langle V,E,w\right\rangle$, we define a path as a non-repeating sequence of vertices in $V$, connected by edges in $E$. A cycle is a path in which the first and last vertex are equal, and for simplicity we will also refer to cycles as paths. Let $\mathcal{P}$ represent the set of all possible paths in $G$. Then, abstractly, a path planning constraint defines a subset $\mathcal{P}_{1}\subseteq\mathcal{P}$ of feasible paths. Given a set of constraints $\mathcal{P}_{1},\mathcal{P}_{2},\ldots,\mathcal{P}_{m}$, the set of all feasible paths is $\mathcal{P}_{1}\cap\mathcal{P}_{2}\cap\cdots\cap\mathcal{P}_{m}$. In this paper we restrict our attention to the following class of constraints and planning problems.

Definition II.1** (Order-Free Constraints).**

A constraint $\mathcal{P}_{1}$ is order-free if, given any $p\in\mathcal{P}_{1}$, then all paths obtained by permuting the vertices of $p$ are also in $\mathcal{P}_{1}$.

Problem II.2** (Discrete Path Planning Problem).**

Given a complete weighted graph $G=\left\langle V,E,w\right\rangle$ and a set of order-free constraints $\{\mathcal{P}_{1},\mathcal{P}_{2},\ldots,\mathcal{P}_{m}\}$, find the minimum length feasible path.

Many discrete path planning problems for single and multiple robots fall into this class, so long as they do not restrict the ordering of vertex visits (i.e., no constraints of the form “visit $A$ before $B$”). Some examples include single and multi-robot traveling salesman problems, point-to-point planning, and patrolling. As a specific example the GTSP is a problem where a robot is required to visit exactly one location in each non-overlapping set of locations [22]. This is naturally expressed in the above framework by having one constraint for each set: for each cluster $V_{i}$ we have a constraint stating that exactly one vertex in $V_{i}$ must be visited in the path.

A metric discrete path planning problem is one where the edge weights in the graph $G$ satisfy the triangle inequality: for $v_{a},v_{b},v_{c}\in V$, we have $w(v_{a},v_{c})\leq w(v_{a},v_{b})+w(v_{b},v_{c})$.

To describe the number of feasible paths for a given planning problem, we use the phrase search space size. For example, a problem where we must choose an ordering of $n$ locations has a search space size of $n!$, since there are $n!$ combinations that a path may take. Note that as more constraints are added to the problem, the search space size can only be reduced, since a feasible path must lie in the intersection of all constraints.

II-B Clusters

A cluster is a subset of the graph’s vertices, $V_{i}\subset V$. Given the clusters $V_{1}$ and $V_{2}$, we say $V_{1}$ is nested in $V_{2}$ if $V_{1}\subseteq V_{2}$. The clusters $V_{1}$ and $V_{2}$ are overlapping if $V_{1}\cap V_{2}\neq\emptyset$, $V_{1}\nsubseteq V_{2}$, and $V_{2}\nsubseteq V_{1}$. A set of clusters (or clustering) is denoted by $C=\{V_{1},\ldots,V_{m}\}$. A clustering $C=\{V_{1},V_{2},\ldots,V_{m}\}$ is a nested if there exists some $V_{i}\subseteq V_{j}$ for $V_{i},V_{j}\in C$.

In this paper we seek to add clustering constraints to a discrete planning problem that reduce its search space size, but also retains low-cost feasible paths. The clustering constraints we consider are of the following form.

Definition II.3** (Consecutive Visit Constraint).**

Given a graph $G=\left\langle V,E,w\right\rangle$ and a cluster $V_{i}\subseteq V$, a feasible path $p$ must visit the vertices within the cluster $V_{i}$ consecutively. Formally, the vertices visited by $p$, $V[p]$ are visited consecutively if there exists a path segment $p^{\prime}$ of $p$ that visits every vertex in $V_{i}\cap V[p]$ and is of length $\left|V_{i}\cap V[p]\right|$.

Note that in the above definition, it is not necessary for all of the vertices in $V_{i}$ to be visited. It is just necessary to visit the vertices consecutively in $V_{i}$ that are visited.

II-C Traveling Salesman Problems

The traveling salesman problem (TSP) is defined as follows: given a set of cities and distances between each pair of cities, find the shortest path that the salesman can take to visit each city exactly once and return to the first city (i.e., the shortest tour). A tour in a graph that visits each vertex exactly once is called a Hamiltonian cycle (regardless of path cost). The general clustered version of TSP is the extension that requires the solution to visit the vertices within the clusters consecutively. The definition of these problems is as follows:

Problem II.4** (Traveling Salesman Problem (TSP)).**

Given a complete graph $G=\left\langle V,E,w\right\rangle$ with edge weights $w:E\rightarrow\mathbb{R}_{\geq 0}$, find a Hamiltonian cycle of $G$ with minimum cost.

Problem II.5** (General-CTSP).**

Given a complete and weighted graph $G=\left\langle V,E,w\right\rangle$ along with a clustering $C=\{V_{1},\ldots,V_{m}\}$, find a Hamiltonian cycle of $G$ with minimum cost such that the vertices within each cluster $V_{i}$ are visited consecutively.

The traditional version of the CTSP restricts the clusters to be non-overlapping (and non-nested). For this paper we use the syntax $\text{CT{\scriptsize SP}}^{*}$ to emphasize when we are solving a General-CTSP problem CTSP to refer to the traditional problem.

III $\Gamma$-Clustering

In this section, we define $\Gamma$-Clustering and show that the $\Gamma$-Clustered path planning problem provides a $\min\left(2,1+\frac{3}{2\Gamma}\right)$ approximation of the original path planning problem. We then describe an algorithm for finding the optimal $\Gamma$-Clustering, and characterize the search space reductions.

III-A Definition of $\Gamma$-Clustering

Below we define the notion of $\Gamma$-Clusters, $\Gamma$-Clusterings, and the clustered discrete path planning problem. Then we pose the clustering problem as one of maximizing the search space reduction.

Definition III.1** ($\Gamma$-Metric of a cluster).**

Given a graph $G=\left\langle V,E,w\right\rangle$ and a cluster $V_{i}\subset V$, we define the following quantities for $V_{i}$ relative to $G$:

[TABLE]

where $\alpha_{i}$ represents the minimum weight edge entering or exiting the cluster $V_{i}$, and $\beta_{i}$ represents the maximum weight edge within $V_{i}$. The ratio $\Gamma_{i}$ is a measure of how separated the vertices in $V_{i}$ are from the remaining vertices in $G$.

Definition III.2** ($\Gamma$-Clustering).**

Given an input parameter $\Gamma\geq 0$ and a graph $G=\left\langle V,E,w\right\rangle$, a clustering $C=\{V_{1},V_{2},\ldots,V_{m}\}$ is said to be a $\Gamma$-Clustering if and only if $V$ is covered by $V_{1}\cup V_{2}\cup\cdots\cup V_{m}$; each $V_{i}\in C$ has a separation $\Gamma_{i}\geq\Gamma$; and the clusters are either nested ($V_{i}\subseteq V_{j}$ or $V_{j}\subseteq V_{i}$ for all $V_{i},V_{j}\in C$) or non-overlapping ($V_{i}\cap V_{j}=\emptyset$).

The search space reduction for path planning problems comes from restricting paths to visit the clusters consecutively and our goal is to maximize that reduction. Thus we are interested in the following two problems.

Definition III.3** (The Clustered Path Planning Problem).**

Given a discrete path planning problem $P$ and a clustering $C$, the clustered version of the problem $P^{\prime}$ has the constraint that the path must visit the vertices within each cluster consecutively, in addition to all the constraints of $P$.

Definition III.4** (The Clustering Problem).**

Given a graph $G=\left\langle V,E,w\right\rangle$ and a parameter $\Gamma>0$, find a $\Gamma$-Clustering $C^{*}$ such that the search space reduction is maximized.

Remark III.5* (Overlap).*

Note that in Definition III.2 overlapping clusters are not permitted. This is necessary for the problem in Definition III.3 to be well defined. In addition, we will see in the following section that clusters that have a separation of $\Gamma_{i}>1$ cannot overlap.

III-B Solution Quality Bounds

In this section, we show that when the graph $G$ is metric and $\Gamma>1$, then the solution to the $\Gamma$-clustered path planning problem provides a $\min\left(2,\left(1+\frac{3}{2\Gamma}\right)\right)$-factor approximation to the optimal.

Theorem III.6** (Approximation Factor).**

Given a metric discrete path planning problem $P$ with optimal solution $p^{*}$ and cost $c^{*}$, a $\Gamma$-Clustering $C=\{V_{1},V_{2},\ldots,V_{m}\}$ where $\Gamma>1$, then the optimal solution $(p^{\prime})^{*}$ to the clustered problem $P^{\prime}$ over the same set of vertices is a solution to $P$ with cost $(c^{\prime})^{*}\leq\min\left(2,1+\frac{3}{2\Gamma}\right)c^{*}$.

To prove the main result, we begin by proving the first half of the bound $(c^{\prime})^{*}\leq 2c^{*}$. We do this by using an minimum spanning tree (MST) to construct a feasible solution for $P^{\prime}$.

Lemma III.7** (Minimum Spanning Tree (MST)).**

Given a metric graph $G$ and a $\Gamma$-Clustering $C$, with $\Gamma>1$, every MST will have exactly one inter-set edge for each cluster $V_{i}\in C$.

Proof.

We prove the above result by contradiction. Suppose the MST has at least two inter-set edges connected to $V_{i}$. Thus, there are at least two sets of vertices in $V_{i}$ that are not connected to each other using intra-set edges. We can then lower the cost of the MST by removing one of these inter-set edges of weight $\geq\alpha_{i}$ and replace it with an intra-set edge of weight $\leq\beta_{i}<\alpha_{i}$. This highlights the contradiction and thus every MST will have exactly one inter-set edge for each cluster $V_{i}\in C$. ∎

Lemma III.8** (Two-Factor Approximation).**

Consider a metric discrete path planning problem $P$ with an optimal solution path $p^{*}$ and cost $c^{*}$. Then given a $\Gamma$-Clustering $C=\{V_{1},V_{2},\ldots,V_{m}\}$ with $\Gamma>1$, the optimal solution $(p^{\prime})^{*}$ for the clustered problem $P^{\prime}$ over the same set of vertices $V[p^{*}]$ is a solution to $P$ with cost $(c^{\prime})^{*}\leq 2c^{*}$.

Proof.

To prove the above result, we will use the MST approach described below and in [23] to construct a path $p^{\prime}$ over the set of vertices in $V[p^{*}]$. This approach yields a solution $p^{\prime}$ for $P^{\prime}$ that has our desired cost bound, $c^{\prime}\leq 2c^{*}$ [23]. The MST procedure is described below.

Find a minimum spanning tree for the vertices $V[p^{*}]$. 2. 2.

Duplicate each edge in the tree to create a Eulerian graph. 3. 3.

Find an Eulerian tour of the Eulerian graph. 4. 4.

Convert the tour to a TSP: if a vertex is visited more than once, after the first visit, create a shortcut from the vertex before to the one after, i.e., create a tour that visits the vertices in the order they first appeared in the tour.

What remains is to prove that the above tour is a feasible solution for $P^{\prime}$. First we note that the above approach yields a single tour of all the vertices in $V[p^{*}]$, i.e., there are no disconnected tours. Next we note that Lemma III.7 states that every MST uses exactly one inter-set edge for each cluster $V_{i}\in C$. Thus when the edges are duplicated and a Eulerian tour is found, there are only two inter-set edges used for each $V_{i}\in C$. Furthermore short-cutting the path does not change the number of inter-set edges used by the tour, thus the final solution $p^{\prime}$ only has one incoming and one outgoing edge for each cluster $V_{i}\in C$ and so it is a clustered solution for $P^{\prime}$ that satisfies the bound since the MST approach also yields a solution with cost $c^{\prime}\leq 2c^{*}$. ∎

Next we prove the second half of the bound $(c^{\prime})^{*}\leq\left(1+\frac{3}{2\Gamma}\right)c^{*}$ by using Algorithm 1 to construct a feasible solution $p^{\prime}$ for $P^{\prime}$. Additionally we use a modified graph $\hat{G}$ defined in Definition III.12 to show that the cost of this solution satisfies our desired bound.

Lemma III.9** (Correctness of Algorithm 1).**

Given a feasible path $p$ for $P$ and a cluster $V_{i}\in C$ that is not visited consecutively, then $p_{i}\leftarrow\textsc{deform}(p,V_{i})$ does visit $V_{i}$ consecutively and any subsequent deformed paths $p_{i+n+1}\leftarrow\textsc{deform}(p_{i+n},V_{i+n+1})$ also visit $V_{i}$ consecutively, for $n\in\mathbb{Z}_{>0}$.

Proof.

By construction $V_{i}$ is visited consecutively in $p_{i}\leftarrow\textsc{deform}(p,V_{i})$. The remaining claim that $V_{i}$ continues to be visited consecutively is proven by showing that the number of inter-set edges for $V_{i}$ in the subsequent paths remains the same.

We prove this result by contradiction. Suppose there is a sequence $\left\langle v_{a},v_{b}\right\rangle\in p_{j-1}$ for some $j>i$ such that $v_{a},v_{b}\in V_{i}$ and $v_{a}$ is no longer connected to $v_{b}$ in $p_{j}\leftarrow\textsc{deform}(p_{j-1},V_{j})$; that is, $\left\langle v_{a},v_{b}\right\rangle\not\in p_{j}$.

This would mean that one or more vertices were inserted in between $v_{a}$ and $v_{b}$, thus creating a new inter-set edge. In Algorithm 1, this cannot happen in lines 5-7 since the path for the $1^{st}$ vertex to the $k^{th}$ is unchanged. This also cannot happen in lines 8-9 since this part of the algorithm is only connecting vertices within the cluster $V_{j}$ together. Finally, this cannot happen in lines 11-13, since the path is not changing the order of the appearance of $v_{a}$ and $v_{b}$ (no insertions, just deletions).

Thus there are no additional inter-set edges created by Algorithm 1 for cluster $V_{i}$, which highlights our contradiction. Therefore all subsequent paths must also visit $V_{i}$ consecutively. ∎

Remark III.10* (Uniqueness).*

When Algorithm 1 is applied to $p^{*}$ iteratively for each $V_{i}\in C$ to generate the solution $p^{\prime}$, the solution is unique despite the order that $\textsc{deform}(p,V_{i})$ was called for all $V_{i}\in C$. Furthermore the order of the clusters is determined by their first appearance in $p$.

This follows from the method in which Algorithm 1 reorders the vertices within the tour. Specifically, the order of vertices within each cluster $V_{i}$ is preserved as $\textsc{deform}(p,V_{i})$ is called as is the ordering of the remaining vertices.

Lemma III.11** (Deformation cost in $G$).**

Consider a feasible path $p$ for $P$ that has $2(n+1)\geq 4$ inter-set edges for $\Gamma$-Cluster $V_{i}$ such that $\Gamma_{i}>1$ and $n\in\mathbb{Z}_{\geq 0}$. Then the cost to deform $p$ into $p^{\prime}\leftarrow\textsc{deform}(p,V_{i})$ is $c^{\prime}-c\leq(2n+1)\beta_{i}$.

Proof.

In this proof we analyze the cost to deform $p$ into $p^{\prime}$, which is a result of calling $p^{\prime}\leftarrow\textsc{deform}(p,V_{i})$ (Algorithm 1). There are three types of deformations that result from the algorithm: 1) there are short cuts created within the cluster; 2) there are short cuts created outside of the cluster; and 3) there is a new outgoing edge for the cluster. These deformations are illustrated in Figure 2 and a classification of the edges in the figure are as follows: 1) edges $\left\langle v_{3},v_{4}\right\rangle$ and $\left\langle v_{6},v_{7}\right\rangle$ are short cuts within the cluster; 2) edges $\left\langle v_{10},v_{11}\right\rangle$ and $\left\langle v_{12},v_{13}\right\rangle$ are short cuts outside of the cluster; and 3) edge $\left\langle v_{8},v_{9}\right\rangle$ is the new outgoing the edge for the cluster.

We start by examining the incurred cost to short cut paths within the cluster. Consider a path segment $\left\langle v_{a},v_{b},v_{c},\ldots,v_{x},v_{y},v_{z}\right\rangle$ of $p$ such that $v_{a}$ is directly connected to $v_{z}$ in $p^{\prime}$ with the edge $\left\langle v_{a},v_{z}\right\rangle$ and $v_{a},v_{z}\in V_{i}$. The incurred cost of each of these edges is $\leq\beta_{i}$ due to the fact that the cost of any intra-set edge has weight $\leq\beta_{i}$. There are $n$ such shortcuts of this nature incurred from performing deform$(p,V_{i})$ ($n$ captures the number of extra visits to the cluster), and so the total incurred cost for this type of shortcut is $\leq n\beta_{i}$.

Next we examine the incurred cost to short cut paths outside of the cluster. Consider a path segment $\left\langle v_{a},v_{b},v_{c},\ldots,v_{x},v_{y},v_{z}\right\rangle$ of $p$ such that $v_{a}$ is directly connected to $v_{z}$ in $p^{\prime}$ with the edge $\left\langle v_{a},v_{z}\right\rangle$, $v_{a},v_{z}\not\in V_{i}$ and $v_{b},v_{c},\ldots,v_{y}\in V_{i}$. The incurred cost for each of these short cuts is again $\leq\beta_{i}$. This is due to the metric property of $G$: The cost of the direct path from $v_{a}$ to $v_{z}$ is less than or equal to any path from $v_{a}$ to $v_{z}$, specifically $c(v_{a},v_{z})\leq c(v_{a},v_{b})+c(v_{b},v_{y})+c(v_{y},v_{z})\leq c(v_{a},v_{b})+\beta_{i}+c(v_{y},v_{z})$. Thus the incurred cost $\Delta$, of this shortcut is bounded by the difference between the cost of the new edges in $p^{\prime}$ and the removed edges in $p^{*}$, namely:

[TABLE]

There are $n$ such shortcuts of this nature incurred by deform$(p,V_{i})$, and so the total incurred cost for this type of shortcut is also $\leq n\beta_{i}$.

Lastly we examine the incurred cost of the new outgoing edge. Consider the path $\left\langle v_{a},v_{b},v_{c},\ldots,v_{x},v_{y},v_{z}\right\rangle$ of $p$ such that $\left\langle v_{b},v_{c}\right\rangle$ is the first outgoing edge of $V_{i}$ and $\left\langle v_{x},v_{y}\right\rangle$ is the last outgoing edge of $V_{i}$, thus $\left\langle v_{x},v_{c}\right\rangle$ is the new outgoing edge. Then due to the metric property we know that $c(v_{x},v_{c})\leq c(v_{x},v_{b})+c(v_{b},v_{c})\leq\beta_{i}+c(v_{b},v_{c})$. The incurred cost of this deformation is the difference between the cost of the new edge $\left\langle v_{x},v_{c}\right\rangle$ and the removed edge $\left\langle v_{b},v_{c}\right\rangle$ (this edge has not been considered in any previous incurred cost calculation):

[TABLE]

This accounts for all of the incurred costs, and so the total cost to deform $p$ into $p^{\prime}$ via deform$(p,V_{i})$ is $c^{\prime}-c\leq(2n+1)\beta_{i}$. ∎

We introduce the modified graph $\hat{G}$ in the following definition to aid with our ongoing proof of the bound.

Definition III.12** (The modified graph).**

Given a graph $G$ and a $\Gamma$-Clustering $C$, the modified graph $\hat{G}$ is a copy of $G$ with the following modifications: if $\left\langle v_{a},v_{b}\right\rangle$ is an inter-set edge with $v_{a}\in V_{i}$ and $v_{b}\in V_{j}$ then $\hat{c}(v_{a},v_{b})=c(v_{a},v_{b})+\frac{3}{2}\max(\beta_{i},\beta_{j})$, otherwise $\hat{c}(v_{a},v_{b})=c(v_{a},v_{b})$, where $\beta_{i}$ and $\beta_{j}$ are as defined in Definition III.1.

Lemma III.13** (Deformation cost in $\hat{G}$).**

Consider a feasible path $p$ for $P$ and a $\Gamma$-Cluster $V_{i}$ such that $\Gamma_{i}>1$. Then the cost to deform $p$ into $p^{\prime}\leftarrow\textsc{deform}(p,V_{i})$ in $\hat{G}$ is $\hat{c}^{\prime}-\hat{c}\leq 0$.

Proof.

In this proof we analyze the cost to deform $p$ into $p^{\prime}$in $\hat{G}$, which is a result of single call $p^{\prime}\leftarrow\textsc{deform}(p,V_{i})$ (Algorithm 1).

From Lemma III.11 we see that the cost to deform $p$ into $p^{\prime}$ with respect to $G$ is $c^{\prime}-c\leq(2n+1)\beta_{i}$, where there are $2(n+1)\geq 4$ inter-set edges for $V_{i}$ in $p$. The cost of $p$ in $\hat{G}$ is

[TABLE]

and the cost of $p^{\prime}$ in $\hat{G}$ is

[TABLE]

Thus

[TABLE]

and since $n\geq 1$ (otherwise we did not need to deform the path), then $\hat{c}^{\prime}-\hat{c}\leq 0$. ∎

Lemma III.14** (Approximation Factor).**

Given a metric discrete path planning problem $P$ with optimal solution cost $c^{*}$, $\Gamma>1$ and a $\Gamma$-Clustering $C=\{V_{1},V_{2},\ldots,V_{m}\}$, then the optimal solution $(p^{\prime})^{*}$ to the clustered problem $P^{\prime}$ over the same set of vertices is a solution to $P$ with cost $(c^{\prime})^{*}\leq(1+\frac{3}{2\Gamma})c^{*}$.

Proof.

To prove the above result we will work with the modified graph $\hat{G}$ (defined in Definition III.12) and use the result from Lemma III.13 to show that there exists a clustered solution in $\hat{G}$ that has the same cost or lower than $\hat{c}(p^{*})$. Then we will relate $(c^{\prime})^{*}$ to $c^{*}$.

First we show that there exists a clustered solution $p^{\prime}$ that satisfies the following:

[TABLE]

To find a solution $p^{\prime}$ that satisfies the above we will use Algorithm 1 to deform $p^{*}$ into $p^{\prime}$. The deform algorithm is called for each $V_{i}\in C$ in any order as $p_{i+1}=\textsc{deform}(p_{i},V_{i})$ to form a solution for $P^{\prime}$ (see Lemma III.9). For each call of $p_{i+1}=\textsc{deform}(p_{i},V_{i})$ the incurred cost $\hat{c}(p_{i})-\hat{c}(p_{i+1})\leq 0$ (see Lemma III.13). Thus after the series of calls, we have a clustered solution $p^{\prime}$ satisfying

[TABLE]

Next we relate $c(p^{*})$ to $\hat{c}(p^{*})$ by observing the following for an inter-set edge $\left\langle v_{a},v_{b}\right\rangle\in p^{*}$:

[TABLE]

The above inequality for $\hat{c}(p^{*})$ is true for each edge $\left\langle v_{a},v_{b}\right\rangle\in p^{*}$, inter-set edge or not. Therefore

[TABLE]

Due to the construction of $\hat{G}$ and how $\hat{c}(p^{\prime})\leq\hat{c}(p^{*})$ we deduce that

[TABLE]

since

[TABLE]

Therefore we have

[TABLE]

∎

The proof of the main result in Theorem III.6 directly follows from Lemma III.8 and Lemma III.14.

Remark III.15* (Tightness of Bound).*

We have not fully characterized the tightness of the bounds from Lemma III.8 and Lemma III.14, but we we have a lower bound, which is illustrated in Figure 3. In this example, the graph is scale-able (we can add vertices three at a time). The clustered and non-clustered solutions for this example have a cost relation of

[TABLE]

We also provide the graph in Figure 4 to show how the gap changes as $\Gamma$ varies.

The bound for this graph is obtained as follows. Let $n=\frac{|V|}{3}-1$ for $\frac{|V|}{3}\in\mathbb{Z}_{>0}$. Then the optimal non-clustered solution cost is (recall that $\Gamma=\frac{\alpha}{\beta}$):

[TABLE]

The optimal clustered solution is:

[TABLE]

As the instance grows ($|V|\rightarrow\infty$, which implies $n\rightarrow\infty$), we have the following:

[TABLE]

III-C Finding $\Gamma$-Clusters

Before we describe our method for finding optimal $\Gamma$-Clustering (s), we describe a few properties of $\Gamma$-Clusterings.

III-C1 Overlap

A special property of $\Gamma$-Clustering is that when $\Gamma>1$, there are no overlapping clusters. Specifically there are no two clusters $V_{i}$ and $V_{j}$ with $\Gamma_{i}>1$ and $\Gamma_{j}>1$ that have a non-zero intersection unless one cluster is a subset of the other.

Lemma III.16**.**

Given a graph $G$, clusters $V_{i}$ and $V_{j}$ with separations $\Gamma_{i}>1$ and $\Gamma_{j}>1$ (defined in Definition III.1), then $V_{i}\cap V_{j}$ is non-empty if and only if $V_{i}\subseteq V_{j}$ or $V_{j}\subseteq V_{i}$.

Proof.

We prove the above result by contradiction. Before we begin, recall that edges cut by the cluster $V_{i}$ have edge weights $\geq\alpha_{i}$ and edges within the cluster have edge weights $\leq\beta_{i}$. Let us assume that $V_{i}$ and $V_{j}$ overlap and are not nested. Without loss of generality let $\beta_{j}\leq\beta_{i}$. Then there exists an edge $\left\langle v_{a},v_{b}\right\rangle$ with weight $w(v_{a},v_{b})\leq\beta_{j}$ for $v_{a}\in V_{i}\cap V_{j}$ and $v_{b}\in V_{j}\setminus(V_{i}\cap V_{j})$. Since this edge does not exist in the cluster $V_{i}$ but it is cut by $V_{i}$, then it must be the case that $w(v_{a},v_{b})\geq\alpha_{i}$. However, this edge does exist in the cluster $V_{j}$ and so $\alpha_{i}\leq\beta_{j}$, since $w(v_{a},v_{b})\leq\beta_{j}$. This result highlights the contradiction: $\Gamma_{i}=\frac{\alpha_{i}}{\beta_{i}}\leq\frac{\beta_{j}}{\beta_{i}}\leq\frac{\beta_{i}}{\beta_{i}}=1$. ∎

III-C2 Uniqueness

The non-overlapping property for $\Gamma$-Clusterings with $\Gamma>1$ implies that there exists a unique maximal clustering set $C^{*}$ (more clusters equals more reductions in the search space size). This result follows from the simple property that if a cluster $V_{i}$ exists and does not exist in our clustering $C^{*}$, then we must be able to add it to $C^{*}$ to get additional search space reductions.

Proposition III.17**.**

Given graph $G$ and a parameter $\Gamma>1$, the problem of finding a $\Gamma$-Clustering $C^{*}$ that maximizes the search space reduction has a unique solution $C^{*}$. Furthermore $C^{*}$ contains all clusters $V_{i}$ with separation $\Gamma_{i}\geq\Gamma$.

Proof.

We use contradiction to prove that $C^{*}$ is unique. Suppose there exists two different $\Gamma$-Clusterings $C_{1}$ and $C_{2}$ that maximize the search space reductions for a given $\Gamma>1$. Then, there is a cluster $V_{1}$ that is in $C_{1}$ and not in $C_{2}$ (or vice versa). This implies that either $V_{1}$ is somehow incompatible with $C_{2}$, which we know is not the case due to Lemma III.16 (i.e., clusters do not overlap unless one is a subset of the other) or this cluster can be added to $C_{2}$. This is a contradiction, which proves the first result. The second result directly follows since adding a cluster can only further reduce the search space size of the problem. ∎

Corollary III.18**.**

Given a graph $G$ and two clustering parameters $\Gamma_{i}>\Gamma_{j}>1$, the optimal clustering $C^{*}_{j}$ for $\Gamma_{j}$ is a superset of any clustering for $\Gamma_{i}$.

Proof.

We prove this result by contradiction. Suppose we have a clustering $C_{i}$ for $\Gamma_{i}$ and the optimal clustering $C_{j}^{*}$ for $\Gamma_{j}$, for which there exists a cluster $V_{1}$ in $C_{i}$ that is not in $C_{j}^{*}$. Then by the definition of $\Gamma$-Clusters $V_{1}$ must satisfy $\Gamma_{1}\geq\Gamma_{i}$ and since $\Gamma_{i}>\Gamma_{j}$ then $\Gamma_{1}\geq\Gamma_{j}$, which makes $V_{i}$ a cluster that should be added to $C_{j}^{*}$. This contradicts Proposition III.17 and thus proves the result. ∎

Corollary III.19**.**

There exists a minimum $\Gamma^{*}>1$ and its optimal $\Gamma$-Clustering $C^{*}$ that is a superset of all other $\Gamma$-Clusters for $\Gamma>1$.

Proof.

This result follows directly from Corollary III.18, when we consider $\Gamma^{*}$ to be the smallest ratio of edge weights in the graph $G$ (find the two edges that give us the smallest ratio). Then for every cluster with a separation parameters $\Gamma_{i}>1$, it must also be greater than or equal to $\Gamma^{*}$ since $\Gamma_{i}$ itself is a ratio of existing edge weights in the graph $G$. Thus by Corollary III.18, $C^{*}$ must be superset of any other $\Gamma$-Clustering for some $\Gamma>1$. ∎

III-C3 An MST Approach For Finding $\Gamma$-Clusters

Given an input $\Gamma>1$, Algorithm 2 computes the optimal $\Gamma$-Clusterings, i.e., the $\Gamma$-Clustering with maximum search space reduction. Informally the algorithm deletes edges in the graph from largest to smallest (line 6-7) to look for $\Gamma$-Clusters. It uses a minimum spanning tree (MST) to keep track of when the graph becomes disconnected, and when it does the disconnected components are tested to see if they qualify as $\Gamma$-Clusters (line 9-11). Regardless, any non-trivial sized disconnected component ($\Gamma$-Cluster or not) is added back to the queue (line 13-14), so that it can be broken and tested again to find of all nested $\Gamma$-Clusters.

Theorem III.20**.**

Given $G$ and a $\Gamma>1$, Algorithm 2 finds the optimal $\Gamma$-Clustering $C^{*}$ in $O(|V|^{3})$ time.

Proof.

The proof is two fold, first we show that Algorithm 2 runs in polynomial time and second we show that it finds the optimal $\Gamma$-Clustering. For this proof let $n=|V|$.

Minimum spanning trees can be found $O(n^{2})$ time [24] (line 3). The rest of the algorithm modifies the MST from line 3, which originally has $n$ edges and so the while loop for the rest of the algorithm can only run at most $n$ times (we can’t remove more than $n$ edges). Finding the largest edge(s) and removing them in line 6 and 7 takes $O(n)$ time. Creating the induced subgraph and finding the maximum edge cost in lines 9 and 10 takes $O(n^{2})$ time. Testing if the subgraph is a clique (line 11) takes $O(n^{2})$ time. Thus lines 1 to 3 run in $O(n^{2})$ time and lines 4 to 14 run in $O(n\cdot n^{2})$, which means the entire algorithm runs in $O(n^{3})$ time or $O(|V|^{3})$.

Next we show that Algorithm 2 finds the optimal $\Gamma$-Clustering. To do so, we will show that $V[m^{\prime}]$ does indeed represent a $\Gamma$-Clustering with separation $\Gamma^{\prime}\equiv\frac{\alpha}{\beta}$ (line 11) as defined by Definition III.1 and then we finish by showing that the algorithm does not omit any candidate clusters, thus proving the theorem by leveraging Proposition III.17.

Let us start by understanding how to find $\Gamma$-Clusters and how we use MSTs in the algorithm. A $\Gamma$-Cluster with separation $\Gamma_{i}>1$ is a subgraph of $G$ that is connected with intra-edge weights less than the inter-edge weights connected to the rest of the graph. Thus one method of searching for $\Gamma$-Clusters is to delete all edges in the graph of weight $\geq\alpha$ and if there is a disconnected subgraph in $G$ then and only then is it a possible $\Gamma$-Cluster. We can use MSTs to more efficiently keep track of these deleted edges. By definition, an MST is tree that connects vertices within the graph with minimum edge weight. If we remove edges of size $\geq\alpha$ in the graph to search for disconnected sub-graphs, then the graph is disconnected if and only if the MST is disconnected. This follows by considering the cut needed to disconnect these two sub-graphs (the minimum weight edge cut, shares the same weight cut by the MST). Thus we can instead search for $\Gamma$-Clusters by disconnecting the MST. Furthermore if we disconnected the MST by incrementally removing the largest edge(s) of weight $\alpha$ from the tree then we know that induced sub-graphs of the newly disconnected trees have at least one inter-set edge of size $\alpha$. Line 9 in the Algorithm creates the induced subgraph $G^{\prime}$ of a disconnected tree ($m^{\prime}\in M^{\prime}$), line 10 measures its $\beta$, and if $G^{\prime}$ is a clique and meets the separation criterion ($\Gamma^{\prime}\geq\Gamma$) then $V[m^{\prime}]$ is indeed a $\Gamma$-Cluster (by definition), thus it is added to the clustering $C$ in line 12.

Next we show that the Algorithm did not omit any candidate clusters. We have already argued that only disconnected MST trees need to be considered for $\Gamma$-Clusters, thus what is left to show is that the algorithm tests every possible value of $\alpha$ to disconnect the MST tree. This is true since it considers every edge in the original MST. This is because every disconnected tree of size two or more is added back to $M$ in line 14 until every edge originally in the MST is removed in line 7.

Therefore this algorithm finds all of the candidate $\Gamma$-Clusters and Proposition III.17 tells us that it is the unique optimal $\Gamma$-Clustering for the given $\Gamma>1$. ∎

III-D Search Space Reduction

The last remaining question is to determine how much the clustering approach reduces the search space. In general, this is difficult to answer since it depends on the particular constraints of the path planning problem. However, to get an understanding of the search space reduction, consider the example of TSP with a non-nested clustering (nesting would result in further search space reductions). Let $r$ be the ratio of the non-clustered search space size $N_{0}$, to the clustered search space size $N_{1}$, for a graph with vertices $V$ and a clustering $C=\{V_{1},V_{2},\dots,V_{m}\}$. Then, the ratio (derived from counting the number of solutions) is as follows:

[TABLE]

To further simplify the ratio consider the case where all clusters are equally sized (for all $V_{i},V_{j}\in C$, $|V_{i}|=|V_{j}|$):

Proposition III.21** (Search Space Reduction).**

Given a graph $G$ and a clustering $C=\{V_{1},V_{2},\ldots,V_{m}\}$ such that $|V_{i}|=|V_{j}|$ for all $i,j\in[1,m]$ then the ratio $r$ of the search space size for the original TSP problem to the cluster TSP problem is 111The big-$\Omega$ notation states that for large enough $|V|$ the ratio $r$ is at least $k\dot{(}m!)^{x-1}$ for some constant $k$.

[TABLE]

where $x=|V|/m$.

Proof.

The number of solutions for the (directed) TSP problem is $N_{0}=|V|!$ and the number of solutions for the $\text{CT{\scriptsize SP}}^{*}$ problem is: $N_{1}=m!\left(\frac{|V|}{m}!\right)^{m}$ (these results come from counting the number of possible solutions). First let us bound $|V|!=(mx)!$:

[TABLE]

We now use the fact that $|V|!\geq(m!)^{x}(x!)^{m}$ to prove the main result:

[TABLE]

Thus $r=\Omega\left((m!)^{x-1}\right)$. ∎

To get an idea of the magnitude of $r$, consider an instance of size $|V|=100$ divided into four equal clusters. The clustered problem has a feasible solution space of size $N_{1}\approx 1.49\times 10^{-56}N_{0}$, where $N_{0}$ is the feasible solution space size of the non-clustered problem. However, $N_{1}$ is still extremely large at about $1.39\times 10^{102}$.

IV $\Gamma$-Clustering Experiments

In this section we present experimental results that demonstrate the effectiveness of $\Gamma$-Clustering for solving discrete path planning problems. We focus on metric TSP instances drawn from the established TSP library TspLib [25], which have a variety of TSP problem types (the first portion of the instance name indicates the type and the number indicates the size). The tests were conducted with $\Gamma=1.000001$, for which Theorem III.6 implies that the solution to the clustered problem gives a $\min\left(2,1+\frac{3}{2\Gamma}\right)$-factor approximation to the TSP instance. However, we will see that the observed gap in performance is considerably smaller.

To test the effectiveness of the clustering method, we perform $\Gamma$-Clustering on each TSP instance and recorded both the runtime and the number of clusters found. This gives us an idea of whether or not instances from TspLib have a structure that can be exploited by $\Gamma$-Clustering. Then, we use standard integer programming formulations for both the original TSP instance and the general clustered version of the instance ($\text{CT{\scriptsize SP}}^{*}$). We solve each instance three times using the solver Gurobi [26] and recorded the average solver time and solution quality. All instances were given a time budget of 900 seconds, after which they were terminated and the best solution found in that run was outputted. The TSP instances reported in this paper are the 37 instances that were solved to within 50% of optimal and have $\Gamma$-Clusters. The remaining instances are not reported as they would have required more than 900 seconds to provide a meaningful comparison.

Additionally we demonstrate $\Gamma$-Clustering on an office environment to gain insight into the structure of $\Gamma$-Clusters.

IV-A Integer Programming Formulation

The clustering algorithm was implemented in Python and run on an Intel Core i7-6700, 3.40GHz with 16GB of RAM. The integer programming (IP) expression of the TSP problem and clustered problem is solved on the same computer with Gurobi, also accessed through python. The results of both of these approaches is found in Table I and summarized in Figure 6.

The following is the IP expression used for the clustered and non-clustered path planning problems, where each variable $e_{a,b}\in\{0,1\}$:

[TABLE]

The formulation was adapted from a TSP IP formulation found in [27], where the Boolean variables $e_{a,b}$ represent the inclusion/exclusion of the edge $\left\langle v_{a},v_{b}\right\rangle$ from the solution.

Constraints 2 and 3 restricts the incoming and outgoing degree of each vertex to be exactly one (the vertex is visited exactly once). Similarly constraints  4 and  5 restrict the incoming and outgoing degree of each cluster to be exactly one (these constraints are only present in the clustered version of the problem). Constraint 6 is the subtour elimination constraint, which is lazily added to the formulation as conflicts occur due to the exponential number of these constraints. For each instance, we seed the solver with a random initial feasible solution.

IV-B Results

Figure 5 shows the ratio of time spent finding clusters with respect to total solver time. In all instances this time is less than 6% and most is less than 1%. Additionally as the total solver time grows, the ratio gets smaller (Time02 is for instances that use the full 900 seconds). This approach is able to find $\Gamma$-Clusters on 63 out of 70 TSP instances. In total it found 3700 non-trivial $\Gamma$-Clusters (i.e., clusters with $|V_{i}|\geq 2$), which is promising since the TspLib library contains a variety of different TSP applications.

Figure 6 and Table I, shows that for instances that do not time out the solution path costs found by the clustering approach are close to optimal (Cost01 is close to 1 in the figure and the instances from burma14 to pr107 are almost all within 1% error as shown in the table). Furthermore when the solver starts to time out (exceeds its 900 second time budget) the solution quality of the $\Gamma$-Clustering approach starts to surpass the solution quality of the non-clustered approach (as shown by Cost02 in the figure). We attribute this trend to the fact that the clustered approach needs less time to search its feasible solution space and thus is able to find better quality solutions faster than its counterpart. In instances gr202, kroB200, pr107, tsp225, and gr229 the clustering approach does very well compared to the non-clustering approach, enabling the solver to find solutions within 1% of optimal for the first three instances and solutions within 6% of optimal for the latter two instances, while the non-clustered approach exceeds 8% of optimal in the first three instances and 28% of optimal for the latter two instances.

On average the $\Gamma$-Clustering approach is more efficient than the non-clustered approach, which is highlighted in Figure 6 and Table I. For the results that do not time out (Time01 in the figure) we often save more than 50% of the computational time, while maintaining a near optimal solution quality (Cost01 in the figure). For instances that require most or all of the 900 seconds (harder instances) the time savings can be quite large. This is particularly clear from the table when we compare the easy instances burma14 up to st70 that have an average time savings of around 60% to the harder instances kroA100, gr96, bier127, and ch130, which all have a time savings of more than 95%. For the instances that both time out (Time02 in the figure), the time savings is not present since both solvers use the full 900 seconds.

From these results we can see that when the $\Gamma$-Clustering approach does not time out, we usually save time and when the approach does time out we often find better quality solutions as compared to the non-clustered approach.

Remark IV.1* (Discussion on using $\Gamma$-Clustering for TSP).*

It is worth emphasizing that we are not necessarily recommending solving TSP instances in this manner. We are simply using TSP as an illustrative example to show how $\Gamma$-Clustering can be used to reduce computation time in a given solver. Many discrete path planning problems are solved with IP solvers and as such we hope our results help provide some insight as to how $\Gamma$-Clustering would work on other path planning problems. In general unless the solver approach (IP or not) takes advantage of the clustering, there is no guarantee that a computation saving will be achieved.

IV-C Clustering Real-World Environments

As shown in Figure 1 we have also performed $\Gamma$-Clustering on real-world environments. The figure shows the floor-plan for a portion of one floor of the Engineering 5 building at the University of Waterloo. Red dots denote the locations of desks within the environment. We encoded the environment with a graph, where there is a vertex for each red dot and edge weights between vertices are given by the shortest axis-aligned obstacle free path between the locations (obstacle-free Manhattan distances). The figure shows the results of clustering for $\Gamma=1.000001$. We see that locations that are close together are formed into clusters unless there are other vertices in close proximity.

A path planning problem on this environment could be robotic mail delivery, where a subset of locations must be visited each day. The clusters could then be visited together (or visited using the same robot).

V Conclusion

In this paper we presented a new clustering approach called $\Gamma$-Clustering. We have shown how it can be used to approximate the discrete path planning problems to within a constant factor of $\min\left(2,1+\frac{3}{2\Gamma}\right)$, more efficiently than solving the original problem. We verify these findings with a set of experiments that show on average a time savings and a solution quality that is closer to the optimal solution than it is to the bound. For future directions we will be investigating other path planning applications, which includes online path planning with dynamic environments.