Heterogeneous Task Allocation and Sequencing via Decentralized Large Neighborhood Search

This paper focuses on decentralized task allocation and sequencing for multiple heterogeneous robots. Each task is deﬁned as visiting a point in a subset of the robot conﬁguration space – this deﬁnition captures a variety of tasks including inspection and servicing. The robots are heterogeneous in that they may be subject to diﬀerent diﬀerential motion constraints. Our approach is to transform the problem into a multi-vehicle generalized traveling salesman problem (GTSP). To solve the GTSP, we propose a novel decentralized implementation of large-neighborhood search (LNS). Our solution approach leverages the GTSP insertion methods proposed in [1] to repeatedly remove and reinsert tasks from each robot path. Decentralization is achieved using combinatorial-auctions between the robots on tasks removed from robot’s path. We provide bounds on the length of the dynamically feasible robot paths produced by the insertion methods. We also show that the number of bids in each combinatorial auction, a crucial factor in the runtime, scales linearly with the number of tasks. Finally, we present extensive benchmarking results to characterize both solution quality and runtime, which show improvements over existing decentralized task allocation methods.


Introduction
Task allocation and sequencing is a fundamental component of multi-robot operation and has been studied extensively [2,3].The problem consists of finding an assignment between tasks and robots along with an ordering of the tasks assigned to each robot.The objective is typically to minimize the average time, maximum time, or energy consumption of performing all tasks.A wide variety of task types and robot models have been considered in the literature, and are reviewed in [2,3].Our focus is on tasks that require a robot to visit a location in the workspace.In this area, the literature can be divided based on 1) single or multiple robot, 2) centralized or decentralized, and 3) vehicle dynamics or simple motion.
For a single robot the problem is simply one of task sequencing.If the robot does not have dynamics, then computing an ordering of task locations is a traveling salesman problem (TSP), for which very successful heuristic and approximation algorithms exist [4,5].A simple class of TSP algorithms are insertion heuristics [6], which operate by repeatedly inserting a new vertex into a partial tour.For metric graphs, two such heuristics, nearest and cheapest insertion, provide 2-factor approximations to the optimal tour [6].
For a single robot with dynamics, the Dubins vehicle model in which vehicle paths have bounded curvature is commonly studied.Early papers on the Dubins TSP include [7,8].In [9], a method for solving the Dubins TSP was proposed based on conversion to the generalized traveling salesman problem (GTSP).In the generalized traveling salesman problem, the cities are partitioned into disjoint sets, and he goal is to find a tour that visits one city in each set.The GTSP can be solved via a reduction to the TSP [10], or directly using GTSP solvers [11][12][13].A similar conversion to the GTSP was proposed for planning tours for a robotic arm in [14], for a single Dubins TSP with neighborhoods [15] and for high-level task sequencing problems [16].Sequencing problems have also been considered for differential drive and Reeds-Shepp models [17].
For multiple robots without dynamics, the centralized problem can be posed as a multi-vehicle TSP.In [18], a reduction is given from the multi-vehicle TSP to the single vehicle TSP for the min-sum objective.An approximation algorithm has also been recently developed for the objective of minimizing the maximum path length among vehicles [19].
The problem of computing multiple shortest tours through a set of disk neighborhoods in the plane was studied in [20].In [15], the more general problem of computing multiple shortest tours through arbitrary neighborhoods and with Dubins' vehicle dynamics was considered.The approach proposed for general neighborhoods was to discretize each neighborhood, and then convert the problem to an instance of the GTSP.In this paper we utilize a similar approach to discretizing neighborhoods, but we develop a decentralized algorithm that utilizes both auctions between robots, and local optimization of individual robot routes.
The decentralized problem for multiple robots without dynamics is commonly solved using market-based auctions [21][22][23].When there are an equal number of robots and tasks, the problem is commonly referred to as the assignment problem, which can be solved efficiently [24,25].When there are more tasks than robots, there are two main auction-based approaches: 1) allocating a single task per auction using independent bids on each task [23,26], or 2) bidding on subsets of tasks such that all tasks are allocated in a single auction, known as combinatorial auctions [27,28].In auction algorithms with bids on individual tasks, a bid is independent of the other tasks in the auction.Therefore, the winner determination problem in these auctions is easy to address.However, typically, the cost for a robot to complete a task depends on the other tasks in its route.By placing bids on subsets of tasks, robots can capture the true cost of a subset of tasks, which may differ from the sum of bids on the individual tasks [29].
The advantage of bidding on subsets of tasks is that all tasks are allocated in a single auction, while the main drawback is the additional computational complexity [21], since the number of subsets grows exponentially with the number of tasks.Moreover, winner determination in the combinatorial auction is in general an NP-hard problem [30].Therefore, there are several techniques to limit the number of subsets [27] and heuristics to approximate the winner determination problem [31].A successful auction-based approach that bids on subsets for allocation and sequencing is the consensus-based bundle algorithm (CBBA) [21], which uses consensus algorithms to spread bids between robots.Each robot generates a single subset of tasks and bid on the tasks in the subset.
For several task allocation algorithms [21,29], there are constant factor approximation guarantees that provide bounds on the worst-case performance.However, the performance of these algorithms are typically significantly better than their bounds in practice.In fact, a constant factor approximation can be achieved using very simple auction algorithms [29].Therefore, in this paper we not only seek to develop an auction algorithm that ensures a constant factor worst-case performance guarantee, but also propose a powerful local optimization technique that further improve the quality of each robot tour.Our approach utilizes an optimization framework called large neighborhood search (LNS) [32], which has been successfully applied to several vehicle routing problems [33,34] and the GTSP [13].The high-level idea is to begin with a candidate solution and then repeatedly perform destroy and repair procedures.If the cost of the new solution satisfies an acceptance criterion, then it is accepted and the procedure is repeated.
In this paper, we focus on the decentralized task allocation and sequencing for heterogeneous robots with differential motion constraints.The CAPT algorithm [35] provides a solution when the number of tasks equals the number of robots, and thus sequencing is not required.Existing studies on the decentralized task allocation for multiple robots with dynamics constraints propose decoupling the dynamic constraints from the task allocation problem [36,37].These algorithms consist of a task allocation phase in which robot dynamics are not considered.The allocation phase determines the tasks allocated to each robot and the sequence of performing the tasks.Since the resulting sequences may not be feasible under the dynamic constraints of the robots, the allocation phase is followed by a trajectory planning phase which converts the sequences to feasible tours.Although the decoupling of the task allocation and trajectory planning reduces the complexity, the resulting paths may suffer in the quality [38].
A key contribution of our decentralized auction-based approach is that it performs task allocation and trajectory planning concurrently, rather than decoupling the two stages.Tasks are defined as subsets of the robot configuration space, and a robot completes a task by visiting any point in the subset.Building on prior work [9,14], we transform the problem into a multi-vehicle GTSP.We leverage insertion methods for the GTSP in [1] as a bidding mechanism in the auctions.Moreover, we utilize the GTSP insertion methods to generate multiple tours for robots with dynamics, and we provide bounds on the performance of the insertion methods.In addition to the performance bound, the extensive set of experiments on the homogeneous and heterogeneous system of robots show improvement over the existing methods with decoupling approaches.
The paper is organized as follows.In Section 2, we provide background on combinatorial problems and vehicle models.In Section 3, we formulate the multi-robot task allocation problem and its relation to the GTSP.Section 4 presents insertion methods for the GTSP, along with bounds on their performance.In Section 6, we present an auction-based task allocation algorithm and in Section 7, we provide benchmarking results.

Preliminaries
In this section we give background on the TSP, GTSP, GTSP insertion methods and combinatorial auction problems, as well as standard vehicle models.

Combinatorial problems
A graph G = (V, E, c) consists of a set of vertices V , a set of edges E and edge costs c : E → R >0 .A path P in G is a non-repeating sequence of vertices connected by edges.A cycle or tour T in G is a path in which the first and last vertices are equal.We can think of a path or tour as a connected subgraph of G denoted P = (V P , E P ), where 39  The traveling salesman problem (TSP): Given a complete graph G = (V, E, c), the TSP is the problem of finding a tour T = (V, E T ) that minimizes the sum of the edge costs on the tour e∈E T c(e).
The generalized traveling salesman problem (GTSP): Given a complete graph G = (V, E, c) along with a partition of its vertex set into m mutually disjoint subsets (V 1 , V 2 , . . ., V m ), the GTSP is the problem of finding a tour T = (V T , E T ) that includes exactly one vertex from each subset V i (i.e., |V T ∩ V i | = 1 for each i ∈ {1, . . ., m}) and minimizes e∈E T c(e).
The multi-vehicle GTSP (mGTSP): Given a complete graph G = (V, E, c) with vertex partition (V 1 , V 2 , . . ., V m ) and a number of vehicles N v , the mGTSP, is the problem of finding N v tours that collectively visit each vertex set exactly once and with minimum total length.More precisely, the goal is to find tours The definition of the mGTSP also captures the multitraveling salesman problem (mTSP) where each vertex set V i consists of a single vertex.
Combinatorial auction problem: Given a set A = {a 1 , . . ., a m }, a set of subsets {S 1 , . . ., S n } where each S i ⊂ A, and non-negative price p i > 0 for each subset S i , the combinatorial auction problem is to find a set of subsets W that forms a partition of A and that maximizes the total value i|Si∈W p i .
In the task allocation problem, the elements of A are the tasks and a subset S i is a subset of tasks.A bid p i on a subset, offered by a robot, is the reward of accomplishing the tasks in the subset.The objective is to allocate a subset of tasks to each robot such that the robots collectively perform all the tasks and the revenue is maximized.

Insertion Methods
A class of insertion methods for constructing GTSP tours are presented in [1].The insertion methods are extensions of the class of insertion methods defined for constructing TSP tours in [6].These extensions are as follows.
Consider a GTSP graph G = (V, E, c), a sub-tour a T = (V T , E T ), a vertex set V i such that V i ∩ V T = ∅, and a vertex v ∈ V i .To insert v into T we find the edge (u, w) ∈ E T which minimizes the insertion cost, i.e., c(u, v) + c(v, w) − c(u, w), and construct a sub-tour, de-noted by TOUR(T, v), by deleting the edge (u, w) from T and adding the edges (u, v) and (v, w) to T .
In a GTSP graph with m vertex sets, an insertion method starts from a sub-tour T 1 with one vertex and creates a sequence of sub-tours T 1 , . . ., T m by inserting a vertex v ∈ V i , where V i ∩ T i = ∅ at each step, i.e., The final tour T m includes a vertex from each vertex set and the tour is an approximation of the optimal GTSP tour.For each insertion heuristic, a vertex set is chosen for insertion, and then the vertex in that vertex set with minimum insertion cost is inserted in the tour position that minimizes the insertion cost.To simplify the language, we refer to this insertion as "inserting a vertex set."Insertion Heuristics: Given a sub-tour T Nearest insertion inserts the vertex set V j not visited by the subtour containing the vertex with minimum distance from the tour: Cheapest insertion inserts the vertex set V j containing a vertex with minimum insertion cost: Farthest insertion inserts the vertex set V j whose closest vertex from the tour has the maximum distance from the tour: In this paper, we use a variation of the nearest insertion method where the method inserts the vertex set V j containing the vertex with the minimum distance from or to the tour, i.e., arg min Vj min v∈Vj ,u∈V T min{c(u, v), c(v, u)}, which is helpful for non-symmetric edge costs [13].
The runtime to compute a GTSP tour with each insertion method is provided in [13], and is a straightforward extension of the runtime analysis in [6] for the TSP insertion methods.The cheapest insertion method for GTSP can be implemented to run in O(|V |m log m), while nearest and farthest insertion have runtimes in O(|V |m).

Vehicle Dynamics
The following are three commonly-used vehicle models for which the shortest path between two configurations can be efficiently computed [40].
The Dubins vehicle model describes a forward moving vehicle with bounded turning radius.The equations of motion are ẋ = v cos θ, ẏ = v sin θ, θ = ω, a A sub-tour is a cycle that visits only some of the vertex sets.
where ω ∈ [−v/R min , v/R min ], (x, y) ∈ R 2 , R min is the minimum turning radius of the vehicle, and v is the constant velocity.
The Reeds-Shepp car extends the Dubins model to allow the vehicle to travel in reverse, and is a more realistic model of a four-wheeled vehicle such as an automobile.The equations of motion are ẋ = uv cos θ, ẏ = uv sin θ, θ = ω, where u ∈ {−1, 0, 1} is the control input representing the forward and reverse gears.
Finally, the differential drive robot (DD) actuates two wheels independently and is capable of changing its heading without translation.The equations of motion are where v r and v l , respectively, are the angular velocities of the right and left wheels, L is the distance between the wheels and r is the radius of the wheels.
In this paper, we use the term TSP with prefix of a vehicle model name (e.g., Dubins TSP) to denote a minimum length tour for the vehicle on a given set of vertices.

Problem Formulation and Approach
In this section, we present the task allocation problem and give a procedure for converting it into a GTSP instance.

Task Allocation and Sequencing Problem
Consider a group of N r robots with differential constraints on their motion, located in a planar workspace X ⊆ R 2 .The team is given a set of N t tasks to accomplish with minimum traveling distance.The location of a robot can be specified by an (x, y) location in X, and the configuration of the robot is a point in Q = X × Θ, where Θ describes the remaining states of the robot.For example, for the three models in Section 2.3, Θ = S 1 is the set of heading angles of the robot.We define a task t i as a subset of Q, consisting of a subset of locations X i ⊂ X and a subset of states Θ i ⊂ Θ: Several common tasks fit in this definition.For example, the simple task of visiting a location using any configuration (i.e., any heading) is captured when X i contains a single point and Θ i = Θ.A constrained version where Θ i ⊂ Θ captures tasks in which only certain configurations can be used to complete the task.This task type appears in the inspection missions where a robot observes an event and the sensor is constrained to be directed in a range of headings.The more general task type captured by the definition is the task of visiting a neighborhood using any configuration where X i ⊂ R 2 and Θ i = Θ.Finally, setting X i = {(x 0 , y 0 ), (x 1 , y 1 ), . . ., (x k , y k )} captures one-in-a-set tasks, where a robot can complete a task by visiting just one of several locations.The one-in-a-set tasks appear in pickup missions where an item can be picked up from multiple warehouses at different locations.
In this paper, we address the following problem: Suppose N r robots, each starting at a fixed configuration, are given N t tasks to perform collectively.The motion of the robots is governed with the models in Section 2.3.The robots communicate using a connected but possibly timevariant communication graph.The robots can swap tasks in their tours, only if there is an edge between the robots in the communication graph.The objective is to minimize the total time to perform all N t tasks.
In the next section, we cast this problem as a mGTSP and in Section 6 we introduce our combinatorial auctionbased decentralized method.We detail the construction of multiple tours by the GTSP insertion methods in Section 2.2.Finally, we leverage the GTSP insertion methods to create a decentralized method to swap tasks between the tours.

Conversion to GTSP
Our approach is to construct a GTSP graph that represents each task along with shortest tours between tasks.To do this, we discretize the configuration space at each task.The discretization of X i × Θ i for task i into n points is denoted by t n i .For example, in [9] the Dubins TSP-in which each for task i X i = (x i , y i )-is converted to a GTSP by selecting n equally spaced headings θ at the location (x i , y i ).Thus, the discretized task i for this example is defined as Given N r robots and N t tasks, we construct a GTSP instance as follows.We define a complete graph G = (V, E, c) and a partition of There is a single vertex in each vertex set V r , r ∈ {1, . . ., N r } representing the initial configuration of each robot, namely depot.Additionally, we let x u denote the location of the discretized configurations associated with the vertex u in the working space X.We will refer to x u simply as the location of the vertex u.The weight of the edge c(u, v) is the cost of the time optimal path between (x u , θ u ) and (x v , θ v ).The conversion to the GTSP relies on the efficient computation of optimal point-to-point paths between configurations, which can be performed for the three vehicle models in Section 2.3 [40].In a general workspace with obstacles and other vehicle models, close to optimal paths are provided by the sampling based point-to-point planners [41,42].The cost function c is symmetric for the DD robot and Reed-Shepp's car and it is asymmetric for the Dubins vehicle, i.e. c(u, v) = c(v, u).
Given the graph G, our objective is to find N r tours T i = (V T i , E T i ), i ∈ {1, . . ., N r } such that 1) each tour T i includes the vertex in V i , 2) the tours collectively visit the N t vertex sets exactly once and 3) the sum of the tour cost is minimized.In the next section we begin by addressing the centralized problem, and we develop a tour construction method that provides worst-case performance bounds and can be leveraged in the decentralized algorithm proposed in Section 6.

Constructing Tours By Insertion Methods
In this section, we analyze the performance of the GTSP insertion methods in Section 2.2 for construct tours for vehicles with differential motion constraints.We then provide an analysis of these methods for the mGTSP.Our analysis is an extension of that from [6] for the TSP, where it was shown that cheapest and nearest insertion provide 2approximations to the optimal tour, and farthest insertion provides a ln n + 1 approximation to the optimal.

Bounds on the GTSP Tour Constructed By Insertion Methods
In this section, we provide bounds on the cost of tours constructed by each of the GTSP insertion methods.Since each method is a generalization of the TSP insertion [6] to the GTSP, we extend the analysis in [6] to provide bounds.
The results for the TSP insertion method hold only when the distances between the vertices are symmetric.Also, the TSP is characterized simply by the ordering of the vertices.The challenge in extending the TSP results is to bound an asymmetric GTSP tour cost where the cost depends not only on the ordering, but also on the vertex selected in each vertex set.In order to provide approximation factors for the insertion methods, we require the following assumptions on the edge costs.

Assumption 4.2 (Bounded asymmetry in edge costs).
There exists a constant k such that for each pair of vertices u, v ∈ V , the edge cost from u to v is within a constant of the edge cost from v to u: Assumption 4.1 is the directed triangle inequality satisfied by the time optimal paths of the three vehicle models in Section 2.3.In Section 4.2, we show that Assumption 4.2 also holds for the time optimal paths of the three vehicle models.Note that k = 1 for symmetric GTSP instances.

Definition 4.3 (Task location density).
We define d to be the maximum distance between the vertices in the same vertex set and to be the minimum Euclidean distance between vertices in different vertex sets.Then, we define the parameter ρ = d to capture the density of the task locations.
In the problem of path planning with motion constraints, d is the maximum time to travel between the discretized configurations at a task location.Therefore, the density parameter represents the distribution of the tasks in an environment with respect to the motion constraints of the robots.Given Assumptions 4.1, 4.2 and the density parameter, we can establish bounds on a tour constructed by the GTSP insertion methods.Proposition 4.4 (Bound on GTSP insertions).Suppose an insertion method, and let INSERT(G) be the cost of the GTSP tour constructed by an insertion method on G.Then, Proof.Recall the directed-weighted graph G = (V, E, c) from Section 2.2, and let S ⊆ V be the set of vertices selected by an insertion method.Consider another complete symmetric weighted graph G = (S, E , c ) on the vertex set S. Define the cost of the edge (s i , s j ) in G as c (s i , s j ) = min{c(s i , s j ), c(s j , s i )}.
Let TSP(G ) be the cost of the optimal TSP tour in G .Theorem 3 in [6] states that the TSP tour on G constructed via any insertion method (i.e., using any insertion ordering, but inserting each vertex into its best edge of the sub-tour) is not greater than ( log m + 1)TSP(G ).Note that by Assumption 4.2 each edge c(u, v) in the constructed tour is bounded by the k min{c(u, v), c(v, u)}.Therefore, the GTSP tour constructed on the graph G with any insertion heuristic is Let GTSP(G) be the cost of the optimal GTSP tour in G and GTSP(S) be the cost of the GTSP tour in G obtained by including the vertices in S but using the vertex set ordering of the optimal GTSP tour.Then we have With the definition of , we know that GTSP(G) ≥ m .Combining this with inequalities (1) and (2) we have, For nearest and cheapest insertion methods we can improve the bound.Proposition 4.5.Let INSERT (G) be the cost of the tour constructed using either nearest or cheapest insertion.Then Prior to the proof of the proposition, we establish a property of the nearest and cheapest insertions.Let T i be the tour after i insertion steps and s i ∈ V i be the vertex that the nearest insertion for the GTSP inserts at the step i.Let v i be the vertex in V i which has the closest distance from or to the tour.Without loss of generality assume that u is the closest vertex in the tour, then the cost of inserting v i into tour T i is at most equal to the cost of inserting v i between u and w, i.e.
Proof.Consider the set S and the graph G .The nearest and cheapest insertions insert the vertex in V i with the minimum insertion cost, then we have, Then, by Assumptions 4.2 and 4.1 we have, Since, v i is the closest vertex from or to the tour, then following inequality holds for the each step of insertions, From inequalities (3) and (4), we conclude the lemma.
Recall that the cheapest insertion inserts a vertex to the sub-tour with the minimum insertion cost.The cost of inserting a vertex by the cheapest insertion into the sub-tour T i is at most cost(T i , s i ), thus the bound on the insertion cost in Lemma 4.6 holds for the cheapest insertion.
Further, we need a modification of a result in [6] for GTSP insertions as follows.The proof follows directly from the proof of Lemma 3 in [6].
Lemma 4.7 (Modified Lemma 3 in [6]).Suppose an insertion method inserting vertex s i in sub-tour Now we can establish the approximation factors in Proposition 4.5 for the nearest and cheapest insertions.
Proof.[Proof of Proposition 4.5] By Lemma 4.6, each insertion using the nearest or cheapest insertion methods satisfy the condition in Lemma 4.7.Therefore, the cost of the tour constructed by the insertions is not greater than (1 + k)MST(G ).Then, we have Since, the edge costs for graph G satisfies c (u, v) ≤ c(u, v), ∀u, v ∈ S, then, TSP(G ) is a lower bound on the cost of the tour in G, consisting of the vertices in S and with the vertex ordering of the optimal GTSP tour.Therefore, we have,

Bound on Vehicle Tour Cost
The following result gives an upper-bound on the optimal path cost between two configurations for each of the three vehicle models in Section 2. The Dubins' bound (i) was conjectured in [8] and established in [43], while the Reeds-Shepp and DD bounds are, to the best of our knowledge, new results.The proof of Lemma 4.8 (i) can be found in [43], while the proof of (ii) and (iii) are given in Appendix 1. Recall that the Dubins' and Reeds-Shepp's cars are characterized with the minimum turning radius R min and forward velocity v, and the parameters characterizing motion of DD robot are wheel radius r, distance between the wheels L and forward velocity.

Lemma 4.8 (Distance of robot configurations).
Consider a robot whose dynamics are governed by one of the three vehicle models (Dubins, Reeds-Shepp, DD), v forward velocity and two robot configurations q 1 and q 2 .Then, the travel time from q 1 to q 2 , denoted dist(q 1 , q 2 ) satisfies dist(q 1 , q 2 ) ≤ Euc(q 1 , q 2 ) + C, where Euc is the time to travel then Euclidean distance between the points (x q1 , y q1 ) and (x q2 , y q2 ).C is defined in terms of the vehicle model as for Differential Drive; and (iii) C = π v R min for Reeds-Shepp.To compare the performance bound on the insertion methods to the existing approximation in Lemma 4.8 we assume that each task consists of a single workspace location, i.e., |X i | = 1.In this case, the Euclidean distance between the vertices inside the same vertex set is zero, and thus d min = C and ρ = C .For the case of a Dubins vehicle, the distance bounds from Lemma 4.8 allow us to provide tighter performance bounds.To this end, we redefine the edge costs in the graph G to the Euclidean distance between the vertices, i.e., c (s i , s j ) = Euc(x si , x sj ).
Then the constant k in Assumption 4.2 becomes 1+ρ.Thus, the bound in (1) becomes Let VTSP be the optimal tour cost for a vehicle model in Section 2.3 in a workspace X = R 2 , then we have the following result.
Corollary 4.9.The total tour cost constructed by the nearest or cheapest insertion is bounded by Proof.From Lemma 4.8 and inequality (3), the cost of inserting any vertex in the tour at step i by the nearest and cheapest insertion is From Lemma 4.7, we have, The MST(G ) are the minimum spanning tree and the optimal TSP in the graph G , respectively.The minimum spanning tree and the optimal tour on the task locations are shorter than the optimal tour between the locations for the vehicles VTSP.Finally, the approximation factor for our cheapest and nearest insertion methods is as follows: Note that for environments with large values of ρ and m ≥ 5 this bound becomes 2(1 + ρ), which is an improvement over the bound for the Dubins TSP method in [9], which was In the case that the minimum turning radius for the Dubins and the Reeds-Shepp's models and distance between the wheels for the DD robot are negligible compared to the distances between task location i.e. ρ ≈ 0, the problem becomes the TSP on the task locations, and both nearest and cheapest insertion provide 2-approximations to the optimal.

Bounds on the Tours of Multiple Robots
In Section 4.2, we provided the approximation factors of the insertion methods for a single robot.In this section, we extend the analysis to multiple robots with various motion dynamics.The high-level idea is to reduce the mGTSP problem to a GTSP problem and construct a tour using the insertion methods.

Transformation of mGTSP to GTP
The problem of allocating tasks to multiple robots is formulated as an mGTSP in [44,45], and transformations are given from mGTSP to single GTSP problem.The transformation creates a GTSP instance consisting of duplicates of tasks for each robot and a duplicate of each depot.In this subsection, for completeness, we present the transformation from [44].Our presentation includes a slight modification, by adding a dummy vertex, which we require to establish bounds on the cost of multiple tours constructed by cheapest and nearest insertion methods.
Recall from Section 3.1 that a vertex in the GTSP graph represents a configuration at a task.However, in a heterogeneous system of robots, the discretized configurations and the time to travel between two configurations are, in general, different for each robot.Therefore, we let V r i denote the vertex set consisting of the configurations of robot r at task i.Each vertex u is a associated with a configuration of a robot, and we let model(u) denote the model governing the motion of the robot.Two vertices u, v in V r i and V k i are considered equal if and only if they represent an identical configuration and model(u) = model(v).Since, only one configuration should be visited at task i, the vertex set V i is defined as . ., V Nr } denote the set of depots for the robots.Each V r is a vertex set consisting of the discretization of the configuration space at the depot location of robot r.Also, the replicas of the vertices at the depots are defined in the set V = {V 1 , . . ., V Nr }.With a slight modification, we introduce a dummy vertex as a starting point for the insertions.
Let dist : (V ∪V )×(V ∪V ) → R record the distance between any two robot configurations (at tasks or depots).For u ∈ V ∪ V and v ∈ V ∪ V such that model(u) = model(v), we define dist(u, v) to be the minimum time required to travel from u to v using model(u).For all other pairs of vertices, we set the distance to a large number M that exceeds the total length of all robot tours: The transformation of the multi-robot task allocation to the single GTSP problem is as follows.We define a complete weighted graph G = (W, E, c) where and finally (vii) zero if u ∈ V r , v ∈ V r and r ∈ {1, . . ., N r } .For all other edges, the cost c(u, v) = M .Figure 1 shows an example of the G graph for a system of two heterogeneous robots and two tasks.The vertices associated with the configurations of each robot are represented with similar shapes to the depots.For clarity, edges with cost M are not included and the zero cost edges are represented with dashed lines.
dummy Fig. 1.Graph G, without cost M edges, for an instance with two heterogeneous robots and two tasks.Similar shapes are used to represent the depots and the configurations at task locations for each robot.The dashed edges represent the zero cost edges in G.

Constructing Multiple Tours with Insertion Methods
Let INSERT(G) be the cost of the tour generated by the nearest or cheapest insertions on G and TSP be the total cost of the optimal tours.Let S be the set of vertex sets selected by an insertion method.Now, we define a complete symmetric weighted graph G = (S, E , c ) where the edge cost c (u, v) for u, v ∈ S is set to (v) zero if v = dummy, u ∈ V r and r ∈ {1, . . ., N r }; (vi) zero if u ∈ V r , v ∈ V r+1 and r ∈ {1, . . ., N r − 1}; and finally (vii) zero if u ∈ V r , v ∈ V r and r ∈ {1, . . ., N r } .For all other edges, the cost is set to M .
Prior to providing the bounds on the tours constructed by the nearest and cheapest insertion methods for multiple robots we first establish a result on lower bounds for optimal tours.
Let mVTSP be the minimum total cost of the tours for multiple robots with differential constraints in a workspace X = R 2 , and let TOUR be the set of optimal tours with optimal allocation, ordering and configurations.Then we have, Lemma 5.1 (Lower bound on optimal tours).The length of the minimum spanning tree MST(G ) on the graph G is less than or equal to mVTSP.
Proof.Deleting an edge from each optimal tour in TOUR result in a set N r trees.These trees collectively visit all the depots and the tasks with optimal configurations.Connecting these trees with zero costs edges to a dummy vertex creates a spanning tree on the optimal configurations.Note that the spanning tree is a lower bound on the total cost of the optimal tours.Note that for every edge (u, v) in the constructed minimum spanning tree, the cost c(u, v) is lower-bounded by the Euc(x u , x v ).Therefore, MST(G ) is at most equal to the cost of the spanning tree on the optimal configurations.In Section 4.2, we defined ρ for three vehicle dynamics.Let ρ max be the maximum ρ in the set of multiple heterogeneous robots.Theorem 5.2 (Total cost of multiple tours).The total tour cost constructed by the nearest or cheapest insertion is bounded by Proof.Consider tour T i as the sub-tour constructed by the nearest or cheapest insertions at step i on graph G. Starting from the dummy vertex, the nearest insertion method inserts the vertex at the first depot u ∈ V 1 with distance zero from the dummy vertex (since this is the only outgoing edge from dummy at distance zero).At the next step, the closest vertex set to the tour is the replica of the previously selected depot with zero cost.The nearest insertion method selects the replica of u in ∈ V i , namely u , and inserts u in the tour (recall c(u, u ) = 0).
The nearest insertion continues to insert a vertex in each depot and again inserts the replica of the vertex afterward.Since the vertices are inserted in a position in the sub-tour with the minimum insertion cost, each vertex u ∈ V i is adjacent to the vertex u ∈ V i in the sub-tour.Otherwise, the insertion cost in each insertion is M .
The nearest insertion creates a sub-tour consisting of all the depots and their replicas with zero cost edges.Therefore, the total sub-tour cost after adding all the depots and their replicas is zero.Note that the cheapest insertion constructs the same sub-tour by inserting vertices with zero insertion cost.Also, note that, by the definition of the zero costs edges in the graph G, the u ∈ V r in the sub-tour is adjacent to the vertex in V r+1 .Proceeding in the process of inserting the tasks, the nearest insertion inserts the vertices in V to the tour.Note that, by the definition of the edge costs in G, the insertion cost of a task in V between V r and V r+1 is 2M .Similarly, the cost of inserting a vertex in between V i and the dummy vertex is 2M .Therefore, the nearest or cheapest insertion methods only insert tasks in between depots and their replicas, i.e. between V r and V r , r ∈ {1, . . ., N r }.Suppose, at the step ith of insertions, the insertion methods insert s i in between V r and V r .By Lemma 4.6, at each insertion of the nearest and cheapest insertion methods we have, By Lemma 4.7, the inequality ( 6) is sufficient to show that the sum of the right-hand side of Equation ( 6) is INSERT(G), and the sum of the left-hand side is the minimum-spanning tree on G .Therefore, from Lemma 5.1 and inequality (6) we conclude the bound on INSERT(G).
Obtaining N r tours from the tour constructed by the insertion methods in G consists of two steps.First, deleting the zero cost edges and the dummy vertex outputs N r paths.Second, deleting the vertices in the replicas of the depots and closing the paths by adding the edge from the last vertex of each path to the vertices of the depots result in N r tours.Note that the total tour length is preserved under the extraction of N r tours, since the added edge costs to close the paths are equal to the edge costs of the deleted edges.
So far, the algorithms of creating tours by the insertion methods were centralized.In the next section, we propose a decentralized algorithm for constructing the tours.

A Decentralized Auction-Based Algorithm
We now present a decentralized algorithm for task allocation and sequencing.The algorithm leverages the GTSP insertion mechanisms presented in Section 4 in a manner similar to large neighborhood search (LNS) [32].

Large Neighborhood Search (LNS)
The large neighborhood search (LNS) meta-heuristic is a framework initially introduced for the routing problems [32].In LNS, the solution is repeatedly improved through destroy (deletion) and repair (insertion) operations.This method is a form of local search where at each iteration an improving solution is found by searching in a "large neighborhood" of the current solution.Typically, by searching in a larger neighborhood one is able to find higher quality locally optimal solutions.The neighborhood is defined by the heuristics used to destroy and repair solutions (in our case, the heuristics used to remove and reinsert vertices in the tour).The basic idea is to perform repeated rounds of insertions to improve the tour.First, an initial insertion method (e.g., nearest or farthest insertion from Section 2.2) is chosen and a tour is constructed.Second, a subset of vertices on the tour are deleted and then the corrosponding vertex sets are reinserted into the tour using a chosen insertion method.The insertion method is chosen by a criterion (e.g., an adaptive probability density function as in [13]).In this paper, the insertion methods are chosen via the roulette wheel random selection algorithm [33].This procedure is repeated, accepting tours when they pass an acceptance criterion (for example, if the new tour has smaller cost).In practice, one can perform LNS heuristic on the tours constructed in Section 4.1 to improve the tour quality.Recently a solver for the GTSP problem is proposed in [13] based on the LNS method.In contrast the proposed method in this paper is decentralized and addresses the multiple GTSP problem.Algorithm 1 shows a high-level description of LNS for the GTSP problem.
Algorithm 1 The LNS Framework for the GTSP Input: A GTSP instance G Output: A GTSP tour T on G 1: T ← Create an initial tour 2: while stopping criteria not met : Select an insertion method I for the GTSP

4:
Delete a set of vertices in the tour T

5:
Create T new by reinserting vertices into T via I 6: if cost(T new ) ≤ cost(T ) : T ← T new

LNS-Auction Algorithm
The high-level idea of our decentralized implementation of LNS, namely LNS-Auction, is to delete a set of tasks from a robot's tour and then reinsert them in new robot tours via an auction.We assume that there is an initial assignment of tasks to robots that is conflict-free, i.e., each task is assigned to one robot, and that the communication graph between robots is connected for all time.In the literature, conflicts are solved by an additional consensus algorithm.The high-level description of the auction procedure is as follows: (i) A robot randomly decides to begin an auction by selecting a set of robots in its communication range.(ii) The robot randomly selects a set of tasks and sequentially deletes them from its tour, takes the auctioneer role and offers the selected robots to bid on the tasks.(iii) The robots select an insertion method and place bids on subsets of tasks that can be inserted as a continuous segment on its tour.(iv) Each robot sends its bids (each consisting of a subset of tasks and a corresponding bid value) to the auctioneer, who solves the combinatorial auction problem to allocate the tasks.(v) The auctioneer communicates the result of the auction to the winning robots.(vi) Each robot inserts the tasks it has won and locally optimizes its tour.
We now give a more detailed description of the steps.In Step (i), each robot assigns a score to each other robot and increases scores of the winning robots after each auction.The robot selection operation is a roulette wheel selection algorithm.
The bidding starts at Step (ii).Assume the auctioneer is robot r.Its bids are generated by sequentially deleting tasks from its tour T r .Without loss of generality, let V 1 , V 2 . . ., V d be the tasks deleted from the auctioneer's tour and S r i = {V 1 , . . ., V i }, i ∈ {1, 2, . . ., d} be the subset of tasks until the i th step of deletions.
The bidding algorithm generates a bid after each deletion, which is a pair consisting of subset of S r i containing V i and a non-negative bid on the subset: BID r i = (bid-set i , bid-value i ).The set bid-set i is the largest subset of S i containing V i that forms a continuous segment of T r and bid-value i is the insertion cost of the segment of T r corresponding to bid-set i , see Figure 2.
is the difference between the cost of the segment shown in dashed arrows and the cost of the edge from V 6 to V 7 .

At
Step (iii) robots generate subsets to bid on given their current tour and the set of tasks from the auctioneer.Given a set of tasks up for auction {V 1 , V 2 , . . ., V d }, each robot in the auction selects an insertion method and sequentially inserts the tasks in their tour.The set S r i , i ∈ {1, 2, . . ., d} is the set first i tasks inserted in the tour of robot r.Again we assume (without loss of generality) that S r i = {V 1 , . . ., V i }.Let T r i be the tour of robot r at step i of insertions.The bidding mechanism is closely related to the auctioneers bidding process in Step ii with a subtle but important difference.Unlike, the bidding for the auctioneer where the algorithm searches for the largest segment on the original tour, the algorithm for all other robots returns the largest segment in T r i .More precisely, in BID r i , the set bid-set i is the largest subset of S r i containing V i that forms a continuous segment of T r i .The bid value bid-value r i is the insertion cost of the segment in T r i .
The auctioneers goal is to find an allocation that assigns each task to exactly one robot and such that the sum of the winner bids on the subsets is minimum.Determining the winners of the auction at Step (iv) is formulated as a combinatorial auction problem whose integer programming formulation (IP) is as follows: x r i = 1 for all i ∈ {1, . . ., d}, r ∈ I r , x r i ∈ {0, 1} for all i ∈ {1, . . ., d}, r ∈ I r .
where x r i is an integer variable equal to 1 if the bid BID r i is accepted and 0 otherwise, and I r contains the indices of all robots participating in the auction.Note that the IP is feasible since the auctioneer's bids form a feasible solution.Several techniques are proposed to reduce the run-time of solving this IP [46] which enables fast solutions for large sizes.We show in Lemma 6.1 that the number of the variables is linear in the size of the problem, and in Section 7 we experimentally evaluate the fraction of time needed to solve the IP.
Step (v) is a simple process by the auctioneer to broadcast the result of the auction.At Step (vi) each robot inserts its winning bids in the same position on the tour it used to generate the bid.The consistency of the insertion methods in the bidding and insertion steps is required to prove the monotonic decrease in the total tour cost after each auction.Further optimization is done by robots locally.After completing the auction, each robot locally optimizes its tour by deleting tasks from its tour and reinserting then via the GTSP insertion methods of Section 4.
Let D be the maximum number of tasks offered for an auction.Assuming that each edge cost can be encoded with at most k bits, the following lemma summarizes properties of the proposed algorithm.Proof.Proof of (i): At each step of bidding, only a single new bid is added.Therefore, in total D bids are submitted by each robot.Moreover, the cardinality of the bid-sets is at most D. Each bid value is a result of the summation of D − 1 edge costs and each bid value is encoded by log D + k bits.Thus, the number of bits transferred in an auction per robot is at most D(D log D + k).
Proof of (ii): Note that the set of all possible combinations of tasks is the power-set of the tasks.Also, note that without loss of optimality we can replace all the bids submitted on the same bid-set by the bid with minimum bid-value.From i, we know that each robot submits at most D bids, therefore, the total number of bids in the IP ( 7) is equivalent to min{mD, 2 D − 1} Proof of (iii): Let cost(T r ) be the tour cost of robot r prior to the auction.Let operation ⊕ represent inserting a set of tasks to a tour by an insertion method.Define the set win(r) as the set of tasks that robot r has won.The bid-values are the insertion costs of the bid-sets.Therefore, This holds for any robot in an auction.Let z * denote the optimal solution to the integer program (7) and z be the objective value of assigning all tasks to the auctioneer.Thus, the total path tour is Note that assigning all the tasks to the auctioneer is a feasible solution to (7).As a consequence, the right-hand side for (8) is not greater than zero.

Simulation Results
In this section, we compare our decentralized algorithm to several different existing methods.We compare to two different implementations of the Consensus-Based Bundle Algorithm (CBBA) b from [21].The CBBA algorithm plays the benchmarking role in recent studies as the state of the art decentralized task allocation algorithm [47,48].We also compare results to the Multi-Vehicle Algorithm (MVA) [37] and to a centralized algorithm [44].

LNS-Auction Implementation Details
The experiments featuring the LNS-Auction are initiated with a random allocation of the tasks to the robots.The number of auctions in our experiments is limited to N t , where at each round of auctions the auctioneer is selected randomly.The auctioneer communicates with all the neighbor robots in the communication graph, and offers a number of tasks which is selected randomly between two and the number of task in the tour of the auctioneer.
In the LNS-Auction, each robot locally optimizes its tour after each round of the auction, using the method detailed in [1, Section 4].Given a tour, this method fixes the ordering of the vertex sets, and re-optimizes the vertex chosen from each set.With a fixed ordering of the tasks, the graph G is a multi-partite graph.Therefore, in a problem with n vertices for each task, the vertex optimization method performs n breadth-first-searches [1].
Once all auctions are finished, each robot performs one final re-optimization of its tour.This optimization method is a modified implementation of Algorithm 1.The tour acceptance criteria in this optimization method is a simulated-annealing method [33] criterion.The robots randomly select a set of tasks from their tours and reinserts by the GTSP insertion methods to re-optimize the tour.The selection of the insertion method at the final re-optimization step follows the adaptive method detailed in [32].Each insertion method is assigned an initial score.After each iteration and if the cost of the tour has improved, the score of the insertion method is increased by a constant value.The insertion method at each iteration is selected randomly with probability proportional to the scores (i.e., roulette wheel selection).The stopping criteria for the rounds of insertions and deletions is the number of the rounds without improvement in the tour cost.This is set to 1000 in our experiments.

Existing Methods For Comparison
In this section, we provide a brief description of the existing approaches for the task allocation problem.
CBBA-AA: The first implementation of CBBA finds the assignment without considering dynamics for the robots.Each task consists of visiting a location with any heading, and we consider Dubins vehicle dynamics.In this implementation, we linked the CBBA and the Alternating Algorithm (AA) [8] to create feasible solutions to the Dubins vehicle after the assignment.Given an Euclidean TSP solution, the AA assigns a heading to each point based on the position of the point in the tour.Let T ij be the jth task in the tour of robot i.If j is odd then heading with the AA procedure is the orientation of segment from T ij to T i(j+1) , otherwise the heading is equal to the heading assigned to the previous point in the tour.
CBBA-GLKH: In the second implementation of the CBBA, we linked the CBBA and the state of the art GTSP solver, GLKH [12].After assigning the tasks by CBBA, the set of tasks assigned to each robot is transformed to a GTSP instance by discretization of the heading at each task location and solved separately by GLKH.The GTSP instance consists of vertices representing the configuration of the robots and the edges representing the optimal Dubins path length between each pair of configurations.
MVA: The MVA algorithm presented in [37], considers decoupling the dynamic constraints of the robots from the b The CBBA code is available at http://acl.mit.edu/projects/cbba.htmlassignment problem.After task assignment and sequencing by a decentralized variation of the Prim's algorithm, a heuristic method is proposed to construct feasible Dubins tours on the sequenced tasks.Assuming 2R min pair-wise Euclidean distance between the tasks and starting from a configuration at a depot, the algorithm plans the optimal path to the next task in the tour.The MVA algorithm is constrained to the 2R min distance between the points, therefore, this algorithm is augmented by an exhaustive search method for the cases where the pair-wise Euclidean distances between the tasks are smaller than 2R min .The exhaustive search method searches all the candidate optimal Dubins paths to the next point with a fine discretization of the headings (0.1 degree) at the point and returns the Dubins path with minimum cost.
Centralized: Our method is compared to a centralized algorithm [18] in both heterogeneous and homogeneous system of robots.The problem of task allocation and sequencing for multiple robots with dynamic constraints is transformed to a GTSP problem and solved by the state-of-theart GTSP solver [12].The GTSP construction is detailed in Section 5.1.
The experiments are conducted on random communication graphs in which robot i and j can communicate with probability p.In each experiment, robots are initialized by randomly assigning the tasks without any conflicts.Given the initial allocation, each robot constructs a path by an insertion method.

Random Instances
In this section, we compare the quality of the multiple tours constructed by our decentralized implementation of LNS, namely LNS-Auction, to the various centralized and decentralized methods.The experiments are conducted on uniformly randomly generated tasks in X = [0, 10] × [0, 10], and a task is accomplished by visiting the task location with any heading, i.e., Θ = [0, 2π[. Figure 3 compares the total tour cost of the LNS-Auction to CBBA-GLKH and the centralized method for different random instances.Since the published CBBA implementation constructs paths instead of tours, therefore, a postprocessing on the paths by the state of the art GTSP solver, namely GLKH, is performed on the paths in order to improve the quality.The communication graphs are generated for each p ∈ {0.4,1}.Note that the experiments with p = 1 corresponds to task allocation with all-to-all communication.At each run of the algorithm, a new communication graph is generated.The seven robots in the system are assumed to have no motion constraints.The number of auctions for the LNS-Auction algorithm is equal to the number of the tasks.Without considering any dynamics for the robots, Figure 3 shows that the LNS-Auction algorithm for different communication graphs gives considerable improvements in tour quality compared to CBBA-GLKH.In the next experiment, we replace the robots with seven Dubins vehicles with minimum turning radius of 1.To construct the GTSP instance we discretize the heading at each location with 5 equally spaced headings.Figure 4 shows the tour costs in different random instances compared to the CBBA-AA, CBBA-GLKH, MVA and the centralized method on random instances.The maximum deviation of the tour cost of the LNS-Auction from the centralized algorithm is 37% and the average is 16%.However, the maximum deviation of the tour cost of the CBBA-GLKH from the centralized algorithm is 76% and the average deviation is 65%.

TSPLIB Instances
The TSPLIB [49] provides a large library of TSP instances on which we can test the performance of our algorithm.Table 1 shows the total tour cost of the CBBA implementations, centralized and LNS approaches for a system consisting of seven Dubins vehicles with minimum turning radius of 1.To provide a fair comparison of the tour quality of each auction-based method with the centralized method, we use a complete communication graph (p = 1).The experiment includes several medium-size geometric instances from TSPLIB.To be consistent on the ratio of the distances to the minimum turning radius, we scale the task locations in each instance so that they lie in a 10 × 10 square.The initial location of the seven robots are the first seven locations in each instance.The quality of the tours constructed by LNS-Auction algorithm is compared to the two implementations of the CBBA algorithm, namely CBBA-GLKH and CBBA-AA.The published versions of CBBA, GLKH and LNS-Auction are implemented in MATLAB, C and Python, respectively.Although the times are not completely comparable, we provide the time ratio for LNS-Auction to CBBA-GLKH.The total time of the LNS-Auction on ulysses22 and kroA150 instances on a Corei5 @2.5Ghz processor are 10.14 and 62.84 seconds, respectively.

Heterogeneous Robots
In this section, we compare our method to a centralized method for heterogeneous systems.The experiments are conducted on uniformly randomly chosen task locations.
We consider Dubins and DD vehicle dynamics with unit translational velocity.The DD robot accomplishes a task by visiting the location (x i , y i ) with free heading, i.e., task i is defined as follows: t i = {(x, y, θ)|(x, y) = (x i , y i ), θ ∈ [0, 2π)}.
The Dubins vehicle accomplishes a task by visiting any location in a unit circle centered at the task, i.e., task i is defined as follows: The minimum turning radius of the Dubins vehicles, R min , and the distance between wheels of the DD vehicle, L, are assumed to be 1.The circular neighborhoods for the Dubins vehicle are discretized with 5 random locations and 5 equally spaced headings at each location.Similarly, the configuration space at the task location for the DD vehicles are discretized with 5 equally spaced headings.Table 2 shows the total tour cost of the centralized and LNS-Auction approaches for different systems of robots and numbers of tasks.Moreover, the experiment shows the ratio of the total time of the LNS-Auction to that of the centralized approach.Each row of the table is a class of 20 random instances with the same problem parameters: that is, the number of tasks N, the number of DD vehicles, and the number of Dubins vehicles.The averages are on 10 runs of the LNS-Auction on instances of each class.
Finally, Figure 5 shows tours for our implementation of the LNS-Auction for a system of three DD vehicles and one Dubins vehicle on 20 task locations.
Table 2. Total tour cost on TSPLIB instances.The LNS-Auction used the communication graph with p = 1.0.N in the instance class name denotes the number of tasks, DD denotes the number of DD vehicles and Dubins denotes the number of Dubin vehicles in the system.Auction indicates the fraction of the total LNS-Auction time which is spent for solving I.P. (7), and Ratio indicates the average ratio of time for LNS-Auction to the centralized approach.

Conclusion
This paper considered task allocation and sequencing for heterogeneous robots with differential motion constraints.
Our approach was based on transforming the problem to a multi-vehicle GTSP.We leveraged the existing insertion heuristics for the GTSP to construct dynamically feasible tours for robots, and gave bounds on their performance.We proposed a novel decentralized implementation of the LNS method for repeatedly removing and reinserting tasks.Our method leverages combinatorial auctions in order to couple task allocation and sequencing.We also proved that the auctions monotonically decrease the total tour length with limited number of bids -a crucial factor in the runtime.For future work, we are pursuing the idea of inserting tasks without explicitly constructing samples of the allow-able configurations for each task.Instead, we determine the appropriate robot configuration at the time a task is inserted.
He is currently an Associate Professor in electrical and computer engineering at the University of Waterloo, Canada.From 2009 to 2011 he was a Postdoctoral Associate in the Computer Science and Artificial Intelligence Lab at the Massachusetts Institute of Technology.His main research interests lie in the control of autonomous systems, with a particular emphasis on robot motion planning, optimization, and distributed coordination.Dr. Smith is a recipient of the 2016 Ontario Early Researcher Award, the NSERC Discovery Accelerator Supplement Award, and the 2015 Outstanding Performance Award from the University of Waterloo.

Lemma 6 . 1 (
Auction algorithm properties).The decentralized auction algorithm has the following properties: (i) The message size per robot per auction is at most D(D log D + k).(ii) The number of the variables in the IP (7) for a set of m robots is at most min{mD, 2 D − 1}.(iii) The total tour cost monotonically decreases after each auction.

Fig. 3 .
Fig.3.Total tour cost versus the number of tasks for seven robots on uniformly randomly generated instances in a 10 × 10 square environment.The robots do not have any constraint on their motion ρ = 0.For each different number of tasks, 30 random instances are generated.The reported tour cost for each

4 Fig. 4 .
Fig.4.Total tour cost versus the number of tasks for seven Dubins' vehicles with turning radius of 1 on uniformly randomly generated instances in a 10 × 10 square environment.For each different number of tasks, 30 random instances are generated.The reported tour cost for each number of tasks is the average of 30 instances, each solved 10 times.The error bars represent the standard deviation of the results in different runs and instances.

Fig. 5 .
Fig. 5. Tours for a Dubin vehicle with R min = 1 and three DD vehicles with L = 1.The Dubins vehicle, shown with a triangle, completes a task by visiting a location in the neighborhood of the task.The neighborhoods are circles with radius 1.The DD vehicles, shown with squares, complete tasks with visiting the location of the tasks with free heading.The 20 task locations are randomly generated in a 10 × 10 square.

Table 1 .
(7)al tour cost on TSPLIB instances.The LNS-Auction used the communication graph with p = 1.0.Avg.denotes the average total tour length and Min.denotes the minimum total tour length on different runs of the LNS-Auction.Auction indicates the fraction of the total LNS-Auction time which is spent for solving I.P.(7), and Ratio indicates the average ratio of time for LNS-Auction to the CBBA-GLKH approach.The results for LNS-Auction are average of 20 experiments on each instance.