Distributed Approximation Algorithms for the Combinatorial Motion Planning Problem

We present a new 4-approximation algorithm for the Combinatorial Motion Planning problem which runs in O(n^2α(n^2,n)) time, where α is the functional inverse of the Ackermann function, and a fully distributed version for the same in asynchronous message passing systems, which runs in O(n_2n) time with a message complexity of O(n^2). This also includes the first fully distributed algorithm in asynchronous message passing systems to perform "shortcut" operations on paths, a procedure which is important in approximation algorithms for the vehicle routing problem and its variants. We also show that our algorithm gives feasible solutions to the k-TSP problem with an approximation factor of 2 in both centralized and distributed environments. The broad idea of the algorithm is to distribute the set of vertices into two subsets and construct paths for each salesman over each of the two subsets. Finally we combine these pairwise disjoint paths for each salesman to obtain a set of paths that span the entire graph. This is similar to the algorithm by Yadlapalli et. al. 3.66 but differs in respect to the fact that it does not require us to use minimum cost matching as a subroutine, and hence can be easily distributed.

READ FULL TEXT VIEW PDF

Authors

page 1

page 2

page 3

page 4

07/16/2018

An asynchronous message-passing distributed algorithm for the global critical section problem

This paper considers the global (l,k)-CS problem which is the problem of...
03/07/2022

MS2MP: A Min-Sum Message Passing Algorithm for Motion Planning

Gaussian Process (GP) formulation of continuoustime trajectory offers a ...
01/25/2021

Data Flow Analysis of Asynchronous Systems using Infinite Abstract Domains

Asynchronous message-passing systems are employed frequently to implemen...
02/19/2021

Simple Combinatorial Algorithms for the Minimum Dominating Set Problem in Bounded Arboricity Graphs

We revisit the minimum dominating set problem on graphs with arboricity ...
07/30/2021

Beep-And-Sleep: Message and Energy Efficient Set Cover

We observe message-efficient distributed algorithms for the Set Cover pr...
10/23/2017

Near-Optimal Clustering in the k-machine model

The clustering problem, in its many variants, has numerous applications ...
06/04/2014

Augmentative Message Passing for Traveling Salesman Problem and Graph Partitioning

The cutting plane method is an augmentative constrained optimization pro...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

The traveling salesman problem is one of the most famous and one of the most thoroughly studied NP-complete problems in literature. There has been an increasing amount of interest in the various variations of the traveling salesman problem and the vehicle routing problems over the past few decades due to their vast number of practical applications [7] [15].

Routing of unmanned vehicles for scouting and reconnaissance operations usually involves using multiple vehicles of different types, i.e., not all vehicles may be equipped with the same sensors and thus some might be unsuitable to scout certain locations. Typically these unmanned vehicles are assigned targets so as to minimize some cost function like fuel consumed, time taken, etc. Such problems can be modelled as various variants of the vehicle routing problem [13], [14], [11], [12].

Robotic arms in assembly lines are typically assigned tasks as a collection of points in 3 dimensional space that they must visit and then perform some operation at these locations. The order in which these locations are visited affects how much energy is consumed by the robot and how much time is taken to complete the entire operation. Usually, these set of target locations can be visited by multiple robots working simultaneously to speed up the process. This problem can also be modelled as an instance of a variant of the vehicle routing problem. Solving such an instance optimally can imply large amounts of savings in time and money for industries [17].

With the boom in e-commerce, logistics is becoming an increasingly important division in companies and efficient and timely delivery of goods is a critical factor to stay alive in these competitive markets. As the number of warehouses and delivery fleets of these e-commerce giants increases, so does the difficulty of the task to optimally route these vehicles to deliver the goods whether to minimize the total time taken or amount of fuel consumed. This again highlights the importance of efficient algorithms to come up with efficient algorithms for the vehicle routing problem and its variants.

In this paper, we will present the first distributed approximation algorithm for a variant of a multiple depot-terminal Hamiltonian path problem called the Combinatorial Motion Planning problem (CMP). Since CMP is known to be NP-Complete (because it is a generalization of the Traveling Salesman Problem which is NP-Complete [16]), we will focus on approximation algorithms, which are polynomial time algorithms but relax the requirement of optimality, i.e., they are algorithms that produce feasible solutions of a given optimization problem within some known bound of error relative to the optimal solution to the problem. A formal definition of an approximation algorithm can be found in appendix A. In this article, we will concern ourselves with approximation algorithms where the approximation factor is a constant.

Additionally, we would like to point out that there is very little research for distributed approximation algorithms for vehicle routing problems and their variants and it is becoming increasingly important due to the vast number of practical applications, to find efficient techniques in parallelism and approximation algorithms to solve instances of these problems efficiently.

Yadlapalli et. al. [18] present a factor approximation algorithm for the Combinatorial Motion Planning problem (CMP). In this article we will present a factor approximation algorithm for the Combinatorial Motion Planning problem and then subsequently present the first fully distributed algorithm for CMP in asynchronous message passing systems. Though our algorithm gives a worse approximation factor in centralized systems, we show that we would obtain better a approximation factor compared to a distributed version of the algorithm presented by Yadlapalli et al. [18]. Specifically, we show that a distributed version of the algorithm by Yadlapalli et al. [18] would give an approximation factor of due to lack of exact distributed algorithms for minimum cost matching. Moreover, our algorithm has a significantly better running time of compared to a running time of at least by Yadlapalli et al. [18] in centralized systems. Since the inverse of the Ackermann function is an extremely slowly growing function, our algorithm runs in time for all practical network sizes. In a distributed system, our algorithm runs in time and uses at most messages.

We also present the first fully distributed algorithm for performing the shortcutting step in asynchronous message passing systems. The shortcut operation is a very common operation used in literature for approximation algorithms for the traveling salesman problem [3] and a fully distributed routine for the same should aid us in developing fully distributed approximation algorithms for the traveling salesman problem. This should help us in addressing the lack of research in producing fully distributed algorithms for the traveling salesman problem and its variants. We believe that such work is necessary since as the size of problem instances gets larger, it will eventually become infeasible to run centralized algorithms to solve these large instances (since these algorithms usually have quadratic or cubic running times) especially in online variants of these problems. We should try to exploit some form of parallelism in distributed systems and develop algorithms that can be run feasibly even for larger instances of the problem.

In this article we also demonstrate a 2-approximation algorithm for the multiple traveling salesman problem (-TSP) by reducing it to an instance of CMP. Subsequently, we present the first distributed approximation for -TSP in asynchronous message passing systems which runs in time and uses at most messages.

This article is organized as follows: in Section 2 we formally define the Combinatorial Motion Planning problem and define some notation that will be used throughout this paper along with some preliminaries. In Section 3, we highlight the issues faced by the current state of the art algorithms for CMP in distributed environments and subsequently present our 4-approximation algorithm for CMP in centralized systems. In Section 4 we present a fully distributed version of the -approximation algorithm for CMP. In Section 5 we demonstrate how the multiple Traveling Salesman Problem can be modelled as an instance of CMP and how our algorithm provides an approximation factor of 2 in this case.

In the appendix A we provide a formal analysis of the approximation factor and running time of our algorithm for CMP which is presented in section 3.2. In appendix B we provide the pseudocode for the -approximation algorithm presented in section 3.2. In appendix C we present the pseudocode and run-time analysis of our fully distributed algorithm for shortcutting.

2 The Combinatorial Motion Planning Problem

In this section we will formally define our problem. But first let’s define some preliminaries and introduce the notation we will be using throughout this paper. A path is defined as a sequence of edges such that each edge appears exactly once. The weight of a path is defined as the sum of the weights of the edges in the paths, i.e., where denotes the weight of the edge .

Before we define the Combinatorial Motion Planning Problem, we must define the Multiple Depot-Terminal Hamiltonian Path Problem With Motion Constraints -

Definition 2.1.

Multiple Depot-Terminal Hamiltonian Path Problem With Motion Constraints (MDTHPPC) Given a weighted, undirected graph and three subsets of the vertex set - a set of depot nodes , a set of terminal nodes and a set of target vertices and also given traveling salesmen where is initially located at depot . Each salesman is assigned a set of motion constraints which denotes the set of target vertices that the salesman is allowed to visit. Assign paths to each salesmen , starting at and ending at such that the motion constraints are satisfied, each target vertex in is visited by exactly one salesman and the sum of weights of paths of all salesmen is minimum.


We consider a relaxed version of MDTHPPC where the target vertices belong to either of the following two types:

  1. Any of the salesmen can visit the vertex

  2. There exists exactly one salesman who is allowed to visit the vertex

In this variant, we can split the set of motion constraints for each into two disjoint subsets and where is the set of vertices that the -th salesman must necessarily visit, i.e., vertices of the second type as described above (since no other salesman can visit this vertex) and is the common set of vertices that all salesmen are allowed to visit, i.e., vertices of the first type as described above. Thus the vertex set of the graph is given by where . Also observe that . Yadlapalli et al. [18] call this variation the Combinatorial Motion Planning Problem (CMP).

Each edge of the graph is associated with a real number which denotes the weight of the edge. We also define the weight of a set of edges of the graph by

Sahni and Gonzalez [16] have shown that the traveling Salesman Problem is hard to approximate under general weights. Since CMP is a generalization of TSP, it is also hard to approximate under general weights. Thus we consider the case where the weights of the edges satisfy the triangle inequality, i.e., for any pair of vertices ,

3 A Centralized 4-Approximation Algorithm for CMP

Yadlapalli et al. present a 3.66 factor approximation algorithm for the Combinatorial Motion Planning Problem [18]. Henceforth we will refer to it as the YDRP algorithm. Our algorithm has a worse guarantee as compared to the YDRP algorithm for the Combinatorial Motion Planning Problem. In subsection 3.1 we will show that in a fully distributed system, our algorithm will in fact give a better approximation factor than the distributed version of the YDRP algorithm due to lack of exact algorithms for minimum cost perfect matching in distributed environments.

In subsection 3.2 we will present our centralized algorithm for the Combinatorial Motion Planning problem. The complete analysis of the approximation factor and running time can be found in appendix A.

3.1 Analysis of the Distributed YDRP Algorithm for CMP

In this section we will analyse what would happen if we try to make the YDRP algorithm distributed and show that it loses its approximation factor. The YDRP algorithm has an approximation factor of with a running time of

where is the functional inverse of the Ackermann function. In the worst case this algorithm will run in . Hoogeven’s algorithm [8] to compute a Hamiltonian path with two specified end points dominates the running time of the YDRP algorithm and this is due to its subroutine which constructs a minimum cost perfect matching for which the current best running time on a graph with nodes and edges is as given by Gabow et al. [5].

The YDRP algorithm constructs a feasible solution for CMP by constructing a set of disjoint paths for each salesman over the vertex set and a set of disjoint cycles for each salesman which cover the vertex set and then combine and for each salesman to produce a path . They then proceed to show that if the optimal solution is represented by then the following hold true

(1)

Equation 1 is due to Hoogeven’s algorithm. Specifically, Hoogeven shows that for a graph with a minimum spanning tree , a minimum cost perfect matching

over all the vertices with odd degree in the spanning tree, an optimal Hamiltonian path

between two specified end points of and the Hamiltonian path constructed by Hoogeven’s algorithm, we have the following

(2)
(3)
(4)

Our primary objective is to come up with a fully distributed algorithm for CMP. If we make a direct attempt to make the YDRP algorithm distributed by using state of the art distributed algorithms for each of the major routines in the YDRP algorithm, then we need a fully distributed version of Hoogeven’s algorithm and Hoogeven’s algorithm would in turn require a fully distributed algorithm for a minimum cost matching in general graphs. At present the best distributed algorithm for computing a minimum cost matching over a set of vertices is an approximation algorithm with an approximation factor of two [2]. If we assume that we are able to create a fully distributed version of YDRP algorithm using this routine, the bound on the cost of the matching with respect to the optimum path would lose a factor of 2 and expressions 3 and 4 would change as follows

Thus we can see that Hoogeven’s algorithm would give an aproximation factor of in distributed systems. If we used this distributed version of Hoogeven’s algorithm in a distributed version of the YDRP algorithm, since now we are using a -approximation factor algorithm instead of the original -approximation algorithm, inequality 1 would change as follows

(5)

Additionally, at present, we only have distributed algorithms for min cost matching for general graphs in synchronous message passing systems whereas we want to focus in asynchronous message passing systems.

In the following subsections, we present a -approximation algorithm for CMP which runs in time and does not use matching as a subroutine. In section 4, we present a fully distributed version which runs in time and uses at most messages in asynchronous message passing systems. Thus our algorithm performs better in terms of the approximation factor in distributed systems compared to the YDRP algorithm.

3.2 A 4-Approximation Algorithm for CMP

We will solve the problem in three phases, constructing two paths for each salesman, once over the set of vertices (phase I) and once over the set of vertices (phase II) and then combine these paths (phase III) to create a set of paths that covers the entire graph . Henceforth, we will use the shorthand to refer to this algorithm.

Phase I

Consider the set of vertices for each salesman . Since each salesman must necessarily visit all the vertices in , we will construct a Hamiltonian path in the set starting at and ending at for each .

First, assign the weight of the edge connecting nodes and to 0. Now construct the minimum spanning tree over the subgraph of containing . Call this tree . Double the edges of , i.e., create a multiset of edges where each edge of appears twice. Now, delete one of the edges connecting to . This procedure will give us a multigraph with exactly two vertices with odd degree - and .

Now that our graph is Eulerian, we can construct an Euler path from to . Call this path . Each vertex in the set appears at least once in this path .

Now use this path as a guide to obtain a feasible Hamiltonian path over the set of vertices by repeated application of the shortcut operation over all repeated occurrences of vertices in the path

Definition 3.1.

Shortcut A shortcut operation consists of replacing two consecutive edges in a path by a single edge and the vertex is said to have been shortcutted. By the triangle inequality it is guaranteed that this new path will have length no greater than the original path.

If we perform the shortcut operation over all the duplicate occurrences of vertices in the path , eventually we will obtain a path in which each vertex of appears exactly once and thus this shortcutted path will be a valid Hamiltonian path over the vertex set which starts at and ends at . We will denote this path by for each set vertex set and the collection of all such will be our output in phase I. See figure 1.

Figure 1: Output of Phase I - path for salesman

Phase II

Consider the the subgraph of consisting of the set of vertices . First, re-assign the weight of the edges connecting each pair of depots to zero. Since these edges have the least weight among all edges of the original graph, it is guaranteed that exactly of them must belong to the minimum spanning tree of this graph. Construct a minimum spanning tree over

Now, delete the edges which have edge weight zero. Deleting these edges will disconnect all pairs of depots from each other and thus we will obtain a spanning forest consisting of trees where each tree contains exactly one depot, i.e., .

Now construct a Hamiltonian cycle over each tree using the well known 2 approximation algorithm for TSP, i.e., double the edges of as we did in phase I, construct an Euler tour over the obtained multigraph and then perform repeated shortcut operations over the obtained Euler Tour on duplicate occurrences of vertices to obtain a cycle where each vertex in appears exactly once, i.e., a Hamiltonian cycle over the vertex set . Denote this Hamiltonian cycle for by . The collection of for each salesman would be the output of phase II. See figure 2.

Figure 2: Output of Phase II - cycle for salesman

Phase III

In this phase we will combine the paths obtained in the first two phases for each salesman to obtain a feasible solution to CMP

Consider the union of the edges and for each salesman . The degree of each depot will be exactly 3 in this union (or will be exactly one if and this case can be handled trivially). Thus we can perform a shortcut operation over two of the edges incident to - one from and the other from to obtain a path starting at and ending at . Denote this path by . Since each vertex in the graph belongs to exactly one such path , the union of all is a feasible solution to CMP. See figures 3, 4 and 5.

Figure 3: Phase III - cycle and path are combined
Figure 4: Phase III - perform a shortcut over depot
Figure 5: Phase III output - path

The complete pseudocode for algorithm can be found in appendix B.

4 A Distributed Approximation Algorithm for CMP

In this section we present the fully distributed version of the 4-approximation algorithm for CMP which was presented in section 3. Our model of computation is the asynchronous message passing system. We assume that the time taken to pass a message between any two nodes takes at most one unit of time.

Our distributed algorithm is composed of the following three major subroutines -

  • Minimum Spanning Tree - Gallager et al. [6] present a fully distributed algorithm to construct the minimum spanning tree of a network with nodes and edges in asynchronous message passing systems in time and using at most messages. Henceforth, we will refer to this algorithm as the GHS algorithm.

  • Euler Paths and Euler Tours - S. A. M. Makki et al. [10] present a fully distributed algorithm to construct the Euler Tour of a network with nodes and edges in time and using at most messages in asynchronous message passing systems.

  • Shortcutting - We present the first fully distributed algorithm in asynchronous message passing systems to perform the shortcutting operation on a path with repeated vertices which works in time for a path of length and uses at most messages.

4.1 Distributed Shortcutting

The complete pseudocode for this algorithm and its run-time analysis can be found in appendix C.

In this section we present our fully distributed algorithm for shortcutting. The input given to our algorithm is a graph and a path in this graph . Each processor in the distributed system corresponds to a vertex . Note that if such that then deleting from the vertex set will have no effect on the output of the algorithm. Thus we will assume that the path is a Hamiltonian path over the graph.

Each vertex maintains two adjacency lists -

  • - the adjacency list of this vertex as it is defined by the set of edges

  • - the adjacency list of this vertex as is defined by the path , i.e., a list of edges that are incident to in . Each edge in this list is also assigned an integer label according to the order in which these edges appear in . The edge that appears before any other edge in this list is given the label , the edge that appears next is given the label and so on. This is similar to how a path is represented in the distributed Euler Tour algorithm [10]

The algorithm modifies the list for each vertex to produce another path such that .

Using this representation, one can easily traverse the path as follows - each node in the network maintains a variable which denotes the number of edges from the start of the list that have already been traversed by us. Initially . Each time we visit a node in our traversal via some edge that belongs to the path (or if is the starting vertex of the path), we increment the counter variable by 1 for . If is not the last node in the path then there must exist an edge in the adjacency list for whose label is and this is the next edge to use in the traversal of path . Thus we increment by 1 and visit the neighbour of node across the edge with label . If there is no edge with label then is an endpoint of the path and we have complete our traversal. This procedure can trivially be modified in asynchronous message passing systems where the “traversal” across an edge is simply simulated by node sending a message across the edge to

We can modify this basic traversal algorithm to perform shortcuts over vertices that appear more than once by simply introducing a single boolean variable for each vertex . Initially is set to for all nodes except the terminal node of the path for which we set to (this is done to allow us to shortcut intermediate occurrences of the terminal node. This can be easily modified if the path is actually a cycle to avoid performing shortcut on the first vertex of the path).

Each time an unvisited node is visited for the first time during the traversal, it sets its variable to and continues the traversal algorithm as before. If on the other hand we visit a vertex which has already been visited before, we must perform a shortcut operation over this vertex. Let be the vertex over which we must perform the shortcut operation. Let be the vertex from which we arrived at in the path and let be the vertex that we would have visited from if we did not perform the shortcut operation. Now, we must replace the sequence of edges with a single edge .

To facilitate the shortcut, node sends a message to node instructing it to replace the edge with and similarly sends a message to instructing it to replace the edge with . After this, deletes the edges and form and increments by 1 as it would have in case it traversed along the edge . Eventually, we will reach the final node in the path and at this point our algorithm will terminate and the collection of for each vertex will define the new shortcutted path .

Henceforth, we will refer to this algorithm with the shorthand .

Lemma 4.1.

The fully distributed algorithm for repeated shortcutting eventually terminates.

Proof.

Since the algorithm traverses across each edge exactly once due to variable in each vertex , eventually the algorithm will traverse across the final edge of the path and thus will terminate. ∎

Lemma 4.2.

The fully distributed algorithm for repeated shortcutting computes the shorcutted path correctly.

Proof.
  • If a vertex is not the terminal vertex of the path then it is easy to see that all its occurrences after its first occurrence will be shortcutted. This is because one the variable is toggled to be it remains .

  • If a vertex is the terminal vertex of the path then the repeated occurrences of in that require shortcutting are all occurrences except its final occurrence. To allow us to detect start shortcutting of the repeated occurrences immediately, we set for the terminal vertex.

Theorem 4.3.

The fully distributed algorithm for repeated shortcutting is correct.

This follows from lemmas 4.1 and 4.2

4.2 Distributed CMP

We are now ready to create a fully distributed algorithm for CMP. The input to the algorithm is an undirected weighted graph where the weight function over the edges satisfies the triangle inequality. Additionally, we are also given the set of depots , the set of terminal nodes , the set of vertices for each salesman and the set of common vertices . Each node has information about which category it belongs to, i.e., if it is a depot or a terminal node or a target vertex and in case it is a target vertex, which set of vertices - or it belongs to. Each node maintains an adjacency list of its edges.

Initially, when a node wakes up, it sends a message across each of its edges, requesting them to report which category they belong to. Once this step is completed, each pair of and set the weight of the edge connecting to to zero in their respective adjacency lists. Following this, all nodes initiate the GHS algorithm to construct a minimum spanning tree over . Once the minimum spanning tree is constructed, the “core” edge of the final fragment of the GHS algorithm sends a message to all other nodes in the tree to double their edges except for the edge connecting to . To avoid confusion between the duplicate edges we assume that the edges are assigned distinct ids which can be done in a trivial fashion by adding a large enough number to the ids of the original edges. After this, the core edge also sends a message to the unique depot to initiate the distributed Euler Path algorithm of S. A. M. Makki et al. [10] ( already knows the unique terminal node of this set). Once the Euler Path algorithm is completed, the unique labellings given to the edges of the Euler Path by each vertex will form a path which subsequently acts as an input for our distributed shortcutting algorithm as described earlier. Application of the distributed shortcutting algorithm on will produce the Hamiltonian Path for the vertex set . This ends phase I for the distributed algorithm.

Upon completion of phase I, each depot sends a message to all other depots to indicate that it is ready to start phase II of the algorithm. Once all the depots have completed phase I, they re-assign the weights of the edges connecting them to other depots to 0 and then the set of vertices initiates the GHS algorithm to construct a minimum spanning tree over . Once the MST is constructed the “core” edge of the MST passes a message to each depot instructing them to delete the edges of the MST that connect them to other depots. This results in the -spanning forest . Each depot then broadcasts a message over its own tree of the spanning forest, instructing all nodes to double their edges and then initiates the Euler Tour algorithm followed by shortcutting, similar to what was done in phase I for each . This will result in a Hamiltonian cycle for each tree . After this, each depot will have two adjacency lists which are the outputs of the shortcutting algorithm in phases I and II respectively - for and for . These depots increase the label of all edges in by and then shortcut the last edge in and first edge of to produce a path for the salesman . This would result in the end of phase III and completes the distributed algorithm.

4.2.1 Complexity Analysis

Initially time is spend by the nodes to identify which sets their neighbours belong to and this uses messages. The running time and message complexity in phase I is dominated by the GHS algorithm which takes time and messages for each set . The depots then use messages to indicate to each other that they have finished phase I. Following this, phase II begins and its runtime and message complexity is also dominated by the GHS algorithm taking time and messages. Phase III takes constant time and constant number of messages for each depot .

Thus the final run time of the algorithm is given by

and uses at most

messages. Both of these quantities are upper-bounded by and respectively where .

5 2-Approximation Algorithm for the Multiple Traveling Salesman Problem

In this section we demonstrate how the 4-approximation algorithm for CMP can be used to solve the Multiple Traveling Salesman Problem and then demonstrate that we obtain an approximation factor of 2 in this special case.

Definition 5.1.

-Traveling Salesman Problem Given a weighted undirected graph and traveling salesmen located at their depots given by = , find a cycle for each salesman such that each city is visited by exactly one salesman and the sum of weights of all paths is minimized. It is also known as the -TSP problem.


It is easy to observe from the definition that CMP is just a generalized version of -TSP. If and then CMP reduces to an instance of -TSP and thus we can use our algorithm from Section 3.2 to solve -TSP also.

We can show that gives an approximation factor of in -TSP. Since , we can simply skip Phase I of . This would shave off a cost of from our approximation factor. Giving an approximation factor of . Since there is no other modification to , our runtime analysis, message complexity and proof of correctness for both the centralized and distributed algorithms remain the same for -TSP also.

6 Conclusion

We presented the first fully distributed approximation algorithm for the Combinatorial Motion Planning problem in asynchronous message-passing systems, which runs in time and uses at most messages; and the first fully distributed approximation algorithm for the multiple Traveling Salesman problem (-TSP) which runs in time and uses at most messages, which are tight bounds for MSTs [1].

The fully distributed algorithm for shortcutting should encourage more research for fully distributed approximations for other variants of the vehicle routing problem, which as we mentioned earlier has a vast number of practical applications.

Further work is needed in fully distributed exact algorithms for minimum-cost matching in general graphs. An exact algorithm would allow us to directly create a distributed version of the YDRP algorithm, thus giving us a -approximation algorithm in distributed systems as well.

Our -approximation algorithm for -TSP is a result of a direct reduction of -TSP to an instance of CMP, does not necessarily exploit well any of the underlying structure of -TSP itself. This leaves open the possibility that if we take advantage of some property of -TSP itself, it might be possible to create a distributed approximation algorithm for -TSP with a better approximation factor.

References

  • [1] Awerbuch, B. Optimal distributed algorithms for minimum weight spanning tree, counting, leader election and related problems. In

    STOC ’87, Proceedings of the 19th Annual ACM Symposium on Theory of Computing

    (1987), pp. 230–240.
  • [2] Chazelle, B. A minimum spanning tree algorithm with inverse-ackermann type complexity. Journal of the Association for Computing Machinery 47, 6 (2000), 1028–1047.
  • [3] Christofides, N.

    Worst-case analysis of a new heuristic for the travelling salesman problem.

    Tech. Rep. 388, Graduate School of Industrial Administration, Carnegie Mellon University, 1976.
  • [4] Evans, J., and Minieka, E. Optimization Algorithms for Networks and Graphs, 2 ed. Marcel Dekker, 1992.
  • [5] Gabow, H. Implementation of Algorithms for Maximum Matching on Nonbipartite Graphs. PhD thesis, Stanford University, 1973.
  • [6] Gallager, R. G., Humblet, P. A., and Spira, P. M. A distributed algorithm for minimum-weight spanning trees. ACM Transactions on Programming Languages and Systems 5, 1 (Jan. 1983), 66–77.
  • [7] Gutin, G., and Punnen, A., Eds. The Travelling Salesman Problem and its variations. Kluwer, 2002.
  • [8] Hoogeveen, J. Analysis of christofides’ heuristic: Some paths are more difficult than cycles. Operations Research Letters 10 (1991), 291–295.
  • [9] Lotker, Z., Patt-Shamir, B., and Pettie, S. Improved distributed approximate matching. Journal of the ACM 62, 5 (Oct. 2015).
  • [10] Makki, S. A. M. A distributed algorithm for constructing an eulerian tour. In Performance, Computing, and Communications Conference, 1997. IPCCC 1997, IEEE International (Feb. 1997).
  • [11] Malik, W., Rathinam, S., and Darbha, S. An approximation algorithm for a symmetric generalized multiple depot, multiple travelling salesman problem. Operations Research Letters 35 (2007), 747–753.
  • [12] Rathinam, S., and Sengupta, R. Lower and upper bounds for a multiple depot uav routing problem. In Proceedings of the 45th IEEE Conference on Decision & Control (Dec. 2006), pp. 5287–5292.
  • [13] Rathinam, S., and Sengupta, R. 3/2 -approximation algorithm for a generalized, multiple depot, Hamiltonian path problem. Tech. Rep. UCB-ITS-RR-2007-21, University of California at Berkeley, 2007.
  • [14] Rathinam, S., and Sengupta, R. 5/3 -approximation algorithm for a multiple depot, terminal Hamiltonian path problem. Tech. Rep. UCB-ITS-RR-2007-1, University of California at Berkeley, 2007.
  • [15] Rathinam, S., Sengupta, R., and Darbha, S. A resource allocation algorithm for multi-vehicle systems with non-holonomic constraints. IEEE Transactions on Automation Science and Engineering 4, 1 (2007), 98–104.
  • [16] Sahni, S., and Gonzalez, T. P-Complete Approximation Problem. Journal of the ACM 23, 3 (July 1976), 555–565.
  • [17] Tang, Z., and Ozguner, U. Motion planning for multi-target surveillance with mobile sensor agents. IEEE Transactions of Robotics 21, 5 (Oct. 2005), 898–908.
  • [18] Yadlapalli, S., Bae, J., Rathinam, S., and Darbha, S. Approximation algorithms for a heterogeneous multiple depot hamiltonian path problem. In 2011 American Control Conference (July 2011), pp. 2789–2794.

Appendix A Analysis of Approximation Factor of the 4-Approximation Algorithm

Definition A.1.

Approximation Algorithm An approximation algorithm is an algorithm that finds approximate answers to optimization problems. For minimization problems, given an instance for some problem such that the optimum value for this instance with respect to the problem is , the algorithm produces a feasible solution with cost such that where is called the approximation factor.

Theorem A.1.

Algorithm from section 3.2 is a -approximation algorithm for CMP

Proof.

Denote the optimum solution for CMP by . This consists of edge disjoint paths , one path for each salesman .

First, bound the weight of the path for each salesman . Let the optimum Hamiltonian path over the vertex set starting at and ending at be . consists of a path starting at and ending at and consists of all vertices in and possibly some vertices from the set . If we perform repeated shortcut operations over the vertices from the set from each path , then we would obtain a valid Hamiltonian path starting at and ending at over the vertex set . Since the optimal path of this kind is , we trivially have that

.

Since the path was obtained by doubling the edges of the minimum spanning tree followed by shortcutting, and because the weight of an minimum spanning tree - is a known lower bound for , we have that

(6)
(7)

Now we will bound the quantity in terms of . If we shortcut the vertices belonging to the set from we obtain a spanning forest over the set of vertices which consists of exactly trees and each tree consists of exactly one depot. Since we constructed the spanning forest via a minimum spanning tree, we have that

But we know that due to our 2-approx algorithm for construction of a least weight Hamiltonian cycle over the set of vertices defined by each tree , we have . This implies the following

(8)

Each path is obtained by combining and via one shortcut operation over the depot . By the triangle inequality and equations 7 and 8, we get

(9)

Thus our algorithm gives us an approximation factor of 4.

a.1 Running Time Analysis

Our algorithm employs three main routines - computation of minimum spanning trees, computation of Euler tours and the shortcut operations.

  • Construction of a minimum spanning tree on a graph with nodes and edges can be done in time where is the functional inverse of the rapidly growing Ackermann function [9]

  • Construction of an Euler Tour on a graph with nodes and edges can be done in time [4]

  • Shortcutting the repeated vertices of a path of length can be done trivially in time with the aid of doubly linked lists and keeping track of visited vertices in the path.


Using this we can analyze the run time of as follows

  1. Running Time in Phase I: For each subgraph of defined by the vertex set , the construction of a minimum spanning tree takes time. Doubling the edges and computing an Euler path over this multigraph will take time. Since the Euler path will also be of length , the shortcutting step will also take time. Thus phase I is dominated by the computation of a minimum spanning tree. Summing up over all sets , phase I takes time.

  2. Running Time in Phase II: Re-assigning weights to edges connecting the depots will take time. We construct the MST just once over the set of vertices . This will take time and this will dominate the running time in phase II similar to how it did in phase I since all other steps are done in linear time in the number of nodes.

  3. Running Time in Phase III: Since phase III involves performing a simple shortcut operation for each salesman which takes time per salesman, summing over all salesman , we get a running time of

  4. Total Running Time: Adding up the running times for each phase, we get a total running time of

  5. Worst Case Running Time: In the worst case, the running time will be dominated by the running time for the cost of construction of minimum spanning tree. If our running time can also be neatly written as

Appendix B Pseudocode for Centralized 4-Approximation Algorithm for CMP

Given below is the pseudocode for the centralized 4-approximation algorithm of CMP. It makes use of four other routines - MinSpanningTree(), EulerPath(), EulerTour() and Shortcut(), which return the minimum spanning tree of a given graph [9], the Euler Tour of a given graph [4], the Euler path in a given graph between two specified endpoints [4] and the repeated shortcut operation as explained in the algorithm above respectively.

1:procedure CMP(, , , , , )
2:     for i = to  do
3:         
4:         
5:          MinSpanningTree
6:          Double the edges
7:          Delete one of the edges connecting to
8:          EulerPath
9:          ShortCut
10:     end for
11:     for i = to  do
12:         for j = i+1 to  do
13:               Re-assign weights of edges connecting depots
14:         end for
15:     end for
16:      = MinSpanningTree
17:      Delete the 0 weight edges
18:     for i = 1 to  do Construct a Hamiltonian cycle over each tree of
19:          ShortcutEulerTour
20:     end for
21:     for i = 1 to  do Combine and for each salesman
22:          Shortcut
23:     end for
24:     return
25:end procedure
Algorithm 1 Pseudocode for

Lines 2 to 9 correspond to phase I of the algorithm where in we construct a minimum spanning tree over each set of vertices , double its edges, delete one copy of the edge connecting to and then construct a Euler Tour followed by a shortcutting step to give us a Hamiltonian Path starting at and ending at for each vertex set .

Lines 11 to 20 correspond to phase II of the algorithm where we first re-assign the weights of the edges connecting all depots to 0, construct a minimum spanning tree and subsequently a spanning forest by deleting all 0 weight edges from this forest such that each tree of the forest contains exactly one depot. Then we proceed to construct a Hamiltonian cycle over the graph for each vertex set defined by a tree of the spanning forest.

Lines 21 to 23 correspond to phase III of the algorithm. Each path is obtained by combining the corresponding path and cycle via a single shortcut operation over the depot . Since the depot is the only vertex that is repeated in the path , we can simply write this single shortcut operation as Shortcut

In Line 24, we collect all the paths for each salesman and this collection of routes is the output of our algorithm.

Appendix C Pseudocode for Distributed Shortcutting and Complexity Analysis

Algorithm 2 gives the fully distributed pseudocode for shortcutting for a path . This code is executed for each process in the network. There also exist two distinguished processes (one in case we have a cycle instead of the path), the end points of the path.

In line 1, variables , , and correspond to the variables as described in section 4.1. An additional boolean variable is used to indicate whether a node has woken up or not.

In lines 3-9, when a processor wakes up spontaneously, it checks if it is the terminal node of the path and if yes, sets its variable to . If the processor corresponds to node then it makes a call to the moveForward() sub-routine.

Lines 30 to 34 correspond to the moveForward() sub-routine which corresponds to identifying the next node that must be visited in the traversal of the path and passing a message to it to indicate that the node adjacent along this edge must continue the algorithm.

In Lines 10 to 18, when a processor receives a node, if it is the last node in the path, it terminates. Else it identifies if it has been visited before in the traversal of the path or not as per value of the variable . If this is the first time a message has arrived at said processor, then it sets variable to true and calls the moveForward() sub-routine else it performs a shortcut along itself.

The shortcut operation is performed with the aid of the shortcut sub-routine in lines 35 to 40 which identifies which two edges adjacent node must be shortcutted. The message instructs the node receiving this message to replace the edge going towards (or incoming from ) with a an edge going towards .

It is not hard to see that the algorithm sends at most two messages over each edge of the path (at most once per moveForward() and at most once for a shortcut() operation()) and hence it runs in time. This also gives a bound of on the message complexity of the algorithm.

1:
2:upon receiving no message:
3:     if  then
4:         
5:         if  then
6:         end if
7:         if  then moveForward()
8:         end if
9:     end if
10:upon receiving from :
11:     
12:     if   then terminate
13:     end if
14:     if  then
15:         moveForward()
16:     else
17:         shortcut()
18:     end if
19:upon receiving from
20:      = label of in
21:     
22:     if  then
23:         
24:         if  then
25:              moveForward()
26:         else
27:              shortcut()
28:         end if
29:     end if
30:procedure moveForward()
31:     
32:     
33:     send across
34:end procedure
35:procedure shortcut()
36:     
37:     send to
38:     send to
39:     
40:end procedure
Algorithm 2 Distributed Shortcutting, code for processor