# An Effective Algorithmic Framework for Near Optimal Multi-Robot Path Planning

## Abstract

We present a centralized algorithmic framework for solving multi-robot path planning problems in general, two-dimensional, continuous environments while minimizing globally the task completion time. The framework obtains high levels of effectiveness through the composition of an optimal discretization of the continuous environment and the subsequent fast, near-optimal resolution of the resulting discrete planning problem. This principled approach achieves orders of magnitudes better performance with respect to both speed and the supported robot density. For a wide variety of environments, our method is shown to compute globally near-optimal solutions for robots in seconds with robots packed close to each other. In the extreme, the method can consistently solve problems with hundreds of robots that occupy over of the free space.

## 1Introduction

We study the problem of planning collision-free paths for multiple labeled disc robots operating in two-dimensional, multiply-connected, continuous environments (*i.e.*, environments with holes). The *primary goal* of this work is to develop a practical, extensible framework toward the efficient resolution of multi-robot path planning (Mpp) problems, in which the robots are densely packed, while simultaneously seeking to minimize *globally the task completion time*. The framework is composed of two key algorithmic components, executed in an sequential order. Using the example illustrated in Fig. ?(a), first, we compute the configuration space for a single robot, over which an optimal lattice structure is overlaid (Fig. ?(b)). Using the lattice structure as a roadmap, each start (resp., goal) location is assigned to a nearby node of the roadmap as its unique discrete start (resp., goal) node, which translates the continuous problem into a discrete one (Fig. ?(c)). Then, a state-of-the-art discrete planning algorithm is applied to solve the roadmap-based problem near-optimally (Fig. ?(d)). Through the tight composition of these two algorithmic components, our framework proves to be highly effective in a variety of settings, pushing the boundaries on optimal multi-robot path planning to new grounds in terms of the number of robots supported and the allowed robot density.

(a) | (b) | |

(c) | (d) | |

**Related work**. Mpp finds applications in a wide spectrum of domains such as navigation [1], manufacturing and assembly [3], warehouse automation [4], computer video games [5], and microfluidics [6]. Given the important role it holds in robotics-related applications, Mpp problems has received considerable attention in robotics research with dedicated study on the subject dating back at least three decades [7], in which a centralized approach is taken that considers all robots as a single entity in a high dimensional configuration space. Because the search space in such problems grows exponentially as the number of robots increases linearly, a centralized approach [7], although complete, would be extremely inefficient in practice. As such, most ensuing research take the approach of decomposing the problem. One way to do this is by assigning priorities to the robots so that robots with higher priority take precedence over robots with lower priority [8]. Another often adopted partitioning method is to plan a path for each robot separately without considering robot-robot interaction. The paths are then *coordinated* to yield collision free paths [10]. Following these initial efforts, the decomposition scheme is further exploited and improved [12]. Many of the mentioned works also consider optimality in some form. We emphasize that, since finding feasible solution for Mpp is already PSPACE-hard [18], *i.e.*, no polynomial-time complete algorithm may even exist for such problems unless P = PSPACE, computing globally near-optimal solution for a large number of robots is extremely challenging.

Recent years have witnessed a great many new approaches being proposed for solving Mpp. One such method, reciprocal velocity obstacles [19], which can be traced back to [21], explicitly looks at velocity-time space for coordinating robot motions. In [6], mixed integer programming (MIP) models are employed to encode the interactions between the robots. A method based on network-flow is explored in [22]. In [23], similar to our framework upon a first look, an -based search is performed over a discrete roadmap abstracted from the continuous environment. However, the authors addressed a much narrower class of problems for which they can bound the computation cost but cannot guarantee the solution optimality. It is also unclear how the complex geometric problem of efficiently computing a discrete roadmap from the continuous environment is resolved in the paper. In [24], discrete-RRT (d-RRT) is proposed for the efficient search of multi-robot roadmaps. Lastly, as a special case of Mpp in continuous domains, efficient algorithms are proposed [25] for interchangeable robots (*i.e.*, in the end, the only requirement is that each goal location is occupied by an arbitrary robot). At the same time, discrete (*e.g.*, graph-based) Mpp has also been a subject of active investigation. This line of research originates from the mathematical study of the 15-puzzle and related *pebble motion* problems [27]. Since then, many heuristics augmenting the algorithm have been proposed for finding optimal solution, *e.g.*, [29], to name a few. These heuristics essentially explore the same decoupling idea used in the continuous case to trim down the search space. A method based on network-flow also exists here [32]. Some of these discrete solutions, such as [27], have helped solving continuous problems [33].

**Contribution.** Our work brings two contributions toward solving Mpp effectively and optimally. First, we introduce a two-phase framework that allows any roadmap building (*i.e.*, discretization) method to be combined with any suitable discrete Mpp algorithm for solving continuous Mpp problems. The framework achieves this by imposing a partial collision avoidance constraint during the roadmap building phase while preserving path near-optimality. Second, we deliver a practical integrated algorithmic implementation of the two-phase framework for computing near optimal paths for a large number of robots. We accomplish this by combining *(i)* a fast algorithm for superimposing dense regular lattice structures over a bounded two-dimensional environment with holes and *(ii)* an integer linear programming (ILP) based algorithm for computing near-time-optimal solutions to discrete Mpp [35]. To the best of our knowledge, we present the first such algorithm that can quickly plan near optimal, continuous paths for hundreds of robots densely populated in multiply-connected environments^{1}

**Paper organization.** The rest of the paper is organized as follows. We formulate the Mpp problem in Section 2. In Section 3, we describe the overall algorithmic framework architecture and the first component of the framework on roadmap-based problem construction. In Section 4, we describe how the second component of the framework may be realized. In Section 5, we demonstrate the effectiveness of our framework over a variety of environments. We hold an extensive discussion and conclude in Section 6.^{2}

## 2Problem Statement

Let denote a bounded, open, multiply-connected (*i.e.*, with holes), two-dimensional region. We assume that the boundary and obstacles of can be approximated using polygons with an overall complexity of (*i.e*, there are a total of edges). There are unit disc robots residing in . These robots are assumed be omnidirectional with a velocity satisfying . Let denote the free configuration space for a single robot (the shaded area in Fig. ?(b)). The centers of the robots are initially located at , with goals . For all , a robot initially located at must be moved to .

In addition to planning collision-free paths, we are interested in optimizing path quality. Our particular focus in this paper is minimizing the *global task completion time*, also commonly known as *makespan*^{3}

The *makespan* objective seeks solutions that minimize . In other words, let denote the set of all solution path sets, the task is to find a path set with close to

We emphasize that the aim of this work is a method for quickly solving “typical” problem instances with many robots and high robot density (*i.e.*, the ratio between robot footprint and the free space is high) with optimality assurance. By *typical*, we mean that: *(i)* the start location and goal locations are reasonably separated, *(ii)* a start or goal location is not too close to static obstacles in the environment, and *(iii)* there are no narrow passages in the environment that cause the discretized roadmap structure to have poor connectivity. More formally, we assume that assumptions *(i)* and *(ii)*, respectively, take the forms ^{4}

and

For *(iii)*, the discretized roadmap should capture the topology of the continuous environment well. To be more concrete, see Figure ?(a). In this environment, there are two holes. The lattice graph, after contraction of faces that do not contain any obstacles, does not have any holes. We expect the discrete roadmap to be connected and have number of holes (after face contraction) equal to the number of holes of the continuous environment (*e.g.*, Fig. ?(d)).

(a) | (b) | |

**Remark.** We provide these assumptions only to suggest situations in which our framework is expected to perform well. In our evaluation, these assumptions are not enforced. We in fact greatly relax (from to ) and do not enforce at all. We also give an efficient subroutine for restoring connectivity when assumption *(iii)* is not satisfied. For example, the routine, when applied to the example in Fig. ?(a), yields the result in Fig. ?(b), which is a screen capture from our program. We also emphasize that, given that optimal Mpp is an extremely challenging task computationally [18] and our focus on method effectiveness, we do not consider the problem from the angle of solution completeness.

## 3Algorithmic Framework Architecture and Roadmap-Based Discrete Problem Construction

We solve the proposed problem using an algorithmic framework with two algorithmic components–discretization of the continuous problem followed by resolution of the roadmap-based problem. The overall framework contains four sequential procedures:

select and overlay a regular lattice structure over the configuration space,

restore environment connectivity lost in the discretization process,

snap start and goal locations to roadmap nodes to create a discrete problem on the roadmap, and

solve the discrete Mpp problem optimally or near-optimally.

We note that, when compared with motion planning methods such as PRM [36] and RRT [37], our framework, looking somewhat similar on the surface, is in fact rather different. In methods like PRM and RRT, the discretization deals with the configuration space encompassing all degrees of freedom of the target system. Our approach, on the other hand, performs a careful, mostly uniform discretization of the configuration space for a single robot with two degrees of freedom. In doing so, we trade probabilistic completeness for the faster computation of near-optimal solutions. In the rest of this section, we describe the first key component of our algorithmic framework–the construction of the roadmap-based discrete problem, which subsumes the first three algorithmic procedures of the overall framework.

### 3.1Lattice Selection and Imposition

**Appropriate lattice structure selection** In selecting the appropriate lattice structure, we aim to allow the packing of more robots simultaneously on the resulting roadmap and obtain the structure fast. Clearly, if an insufficient number of nodes exists in the roadmap, the resulting discrete problem can be crowded with robots, which is difficult to solve and may not even have a solution. On the other hand, to allow a clean separation between the roadmap building phase and the discrete planning phase of the framework, the nodes cannot be too close to each other, *e.g.*, two robots occupying two different nodes should not be in collision. Moreover, it is desirable that two robots moving on different edges in parallel will not collide with each other.

Considering all these factors together, we resort to adopting uniform tilings of the plane [38]. A uniform tiling of the plane is a regular network structure that can be repeated infinitely to cover the entire two-dimensional plane. Due to the regularity of uniform tilings, it is computationally easy to overlay a tiling pattern over . Choosing such a tiling then relieves us from selecting each node for the roadmap individually. Over the uniform tilings^{5}*e.g.*, Fig. ?(a)). Indeed, it is straightforward to show that the closest inter-robot distance is reached when two robots are in the middle of two edges connecting to the same node. For hexagonal tilings, this results in a minimum side length of (Fig. ?(b)).

(a) | (b) |

After obtaining the required side length parameters for all tilings, the maximum robot density allowed by these tilings can then be computed. We compute the density by assuming that all nodes of the regular tiling patterns are occupied by robots and compute the ratio between the area occupied by robots and the free space when it is unoccupied. For an infinite lattice with no obstacles, the hexagonal tiling is the best with about density, followed by the square tiling with roughly density. Triangular tilings have a density of only . This leads us to choose hexagonal lattices as the base structure of the discrete roadmap.

**Imposing the lattice structure** After deciding on the lattice structure, we need a procedure for imposing the structure on . Essentially, every edge must be checked to determine whether it is entirely contained in the free configuration space . Note that if this is performed naively, *i.e.*, performing collision checking of each edge with all obstacles, the overall complexity is on the order of , in which is the complexity of the workspace and is the area contained in the outer boundary. The naive approach quickly becomes time-consuming as either or grows.

To complete this step efficiently, we start by making an arbitrary alignment between a sufficiently large piece of the infinite hexagonal lattice and the continuous environment (Fig. Figure 1). Then, we look at one C-space obstacle (including the outer boundary) at a time. For each obstacle, we pick an arbitrary vertex on the boundary (red dot in Figure 1) and locate the hexagon from the lattice it belongs to (in case of the example in Figure 1, the shaded hexagonal with the label “1” ). We then follow the obstacle boundary and find all (green) edges of the lattice that intersect the boundary. The edges found this way do not belong to and the final discrete graph structure; moreover, they partition the lattice into pieces that are either completely inside or completely outside . This allows us to efficiently check whether the rest of the lattice edges belong to . To do so, we start with a vertex that is within that also belongs to one of these green edges and perform a breath first search over the lattice structure, now with all the green edges deleted. All edges found this way must be long to . We repeat this until all vertices of the lattice that fall inside are exhausted. Note that this BFS is a discrete search without performing geometric computation over real numbers, which can be done much faster than edge intersection checks. In the end, we obtain an output sensitive algorithm that typically takes time between and , depending the total length of obstacle boundaries. In practice, using the said method, the computation time used by this step is trivial in comparison to the time it takes to do the discrete planning.

**Restore Configuration Space Connectivity** We now address how we may ensure that the topology of is preserved in the discrete roadmap. Essentially, we must locate places where connectivity in the continuous environment is lost. We illustrate our algorithmic solution for doing so using an example. For the problem given in Fig. ?(a), for each C-space obstacle, it is straightforward to obtain the smallest cycle on the lattice enclosing the obstacle (*e.g.*, the green and red cycles in Figure 2). Then, for each pair of obstacles, we check whether the corresponding enclosing cycles share non-trivial interior and if so, locate a minimum segment on the overlapping section (em e.g., the red segments between the two orange nodes in Figure 2). Using *visibility graph* [39], we may then restore the lost connectivity and obtain the roadmap shown in Fig. ?(b). Most of the computation time in this step is spent on computing the visibility graph itself, which takes time [40], with being the complexity of the environment and being the number of edges in the resulting visibility graph.

**Remark.** In the process of restoring connectivity, it is possible that the resulting roadmap cannot guarantee that simultaneous movements of disc robots are collision-free. Without getting into details, we mention that this issue can be fully addressed by sacrificing some time optimality.

We also note that the preservation of the connectivity or topology of the continuous environment can be crucially important. A better connected environment has a more diverse set of candidate paths, making the resulting problem easier to solve. Perhaps more importantly, the preservation of the connectivity of is essential to preserving path optimality. For a roadmap built from an overlaid square lattice, given a shortest path between two points, due to the *strong equivalence* between the Euclidean metric and the Manhattan metric, the shortest path and the corresponding shortest path on the square lattice-based roadmap are within a constant factor multiple of each other for any reasonably long path (that is, does not hold). The same argument applies to the roadmap-based hexagonal lattices. Without obstacles, the ratio over a long path is bounded by for square lattices and roughly the same for hexagonal lattices. The ratio is largely the same when obstacles are present. On the other hand, if the connectivity of is not preserved, then it becomes possible that is arbitrarily large. An example is given in Figure 3.

Once we establish that the roadmap preserves the near-optimality on path length, the same applies to time optimality. Given the preservation of near-optimality of individual paths, it does not directly imply that an optimal solution to the abstracted discrete problem also preserves optimality with respect to the original continuous problem, in terms of time or distance. However, our computational experiments show that this is generally the case when has good connectivity.

### 3.2Snapping Start and Goal Locations to Roadmap Nodes

After the full roadmap is built, each start or goal location in must be associated with a nearby roadmap node. We call this process *snapping*. For the snapping step, for each , we simply associate with the closest roadmap node that can reach without colliding with another . The same process is performed for all With the separation assumptions and , this is almost always possible. In particular, implies that each hexagon from the lattice contains (roughly) at most one start and one goal location. Therefore, the number of nodes on the roadmap is at least twice the number of robots. In rare cases when conflicts do happen, we may apply the rearrangement algorithms (*e.g.*, [25]) to perform the snapping step without incurring much penalty on time optimality. The completeness of this step is guaranteed by and .

With the snapping process complete, a discrete abstraction of the original continuous problem is obtained. For our example, this leads to the scenario captured in Fig. ?(c). If we are not interested in optimality, the discrete problem may be attempted using a non-optimal but polynomial time algorithm [27]. As stated in the individual subsections, the computation required in this section can be carried out using low-degree polynomial time algorithms. The relative time used for this portion is trivial as compared to the time required for solving the roadmap-based discrete problem.

## 4Fast, Near-Optimal Discrete Path Planning

After a high quality roadmap is obtained with near-optimality guarantees on time and distance (*e.g.*, an optimality-preserving reduction from continuous space to discrete space), one may then freely choose an algorithm for finding solutions to the discrete abstraction (Fig. ?(c) in our example). Whereas an arbitrary number of globally optimal objectives can be conjured, four objectives are perhaps most natural. These four objectives minimize the maximum or the total *arrival time* or *travel distance*. Viewing from the angle of service provider (*e.g.*, delivery drones) and end user (*e.g.*, customers), minimizing the total distance or time allows the service provider to minimize energy cost or overall vehicle fleet usage. On the other hand, minimizing the maximum time or distance promises a more uniform service quality among customers. If minimizing the total arrival time or the total distance is the goal, then discrete search methods such as ID [30] can be applied. Here, we focus on the minimum *makespan* (*i.e.*, maximum arrival time or task completion time). We describe an effective method for minimizing the makespan [32], which is also a good proxy to minimizing the maximum travel distance. The method is an ILP-based one with an optimal baseline algorithm, augmented with near-optimal heuristics to improve the computational performance.

### 4.1The Baseline, ILP Model-Based Algorithm

We describe here an integer linear programming (ILP) model based algorithm from [32]. The algorithm delivers an exact method for computing a minimum makespan solution to a discrete Mpp instance. The key idea is to perform *time expansion* over the discrete roadmap and then build the ILP model over the resulting forward only *space-time* graph. This allows the consideration of robot-robot time interaction to go from being implicit over the (spatial) roadmap to being explicit on the space-time graph. For a hexagonal (spatial) roadmap, between subsequent time steps, the time expansion has the intuitive local structure illustrated in Fig. ?, which basically says that a robot at a node and its neighbors can reach in the next time step. Then, in the ILP constraint setup phase, two additional constraints are enforced:

At most a single edge leading to from time step can be used (

*i.e.*, all but one such edge binary variable can be set to ), this enforces that only a single robot may reach node at time step . This prevents collision on a node.At most one edge from and can be used. This prevents collision on an edge.

The above constraints can be encoded easily using linear inequalities. To optimize for minimum time, an underestimate of the minimum required time is used as the number of time steps in the time expansion. This underestimate can be easily obtained by computing the minimum path length for each robot ignoring the rest of the robots and then taking the maximum of the path lengths. To complete the model setup, for a robot starting at node that has node as its goal, an edge is added to the model and is forced to be used. This forces a solution to find a path through the space-time graph connecting and . If the model is infeasible, is then increased and the model is rerun until a solution is found. The number of time steps required for finding the first feasible solution is then the optimal time (for the discrete problem). When the initial roadmap has good connectivity, which is the case targeted by our work, this method appears to work reasonably well for instances with robots, taking only minutes to solve such problems (see [32] for details).

### 4.2Heuristic: Divide-and-Conquer Over Time Domain

In exploring the ILP model-based algorithm, we observe the general trend that the model solution time grows exponentially with respect to the size of the model. This prevents the baseline algorithm from being very useful as it does not work very well beyond 10-20 robots when the robot density is also high, even without the presence of static obstacles.

The same observation, though limiting the performance of the (exact) baseline algorithm, turns out to offer an useful insight toward a highly efficient divide-and-conquer heuristic. We notice that by limiting the size of the ILP model, we generally get fairly good performance from an ILP solver (we used Gurobi [42] in this paper). To apply the method to more challenging problems (*e.g.*, solving problems with hundreds of robots quickly), we simply limit the individual ILP model that is fed to the solver. One way to achieve this is through divide-and-conquer over the time domain. We use a simple example (see Fig. ?) to illustrate this idea.

(a) | (b) | |

In Fig. ?(a), we have a simple planning problem for two robots on a grid. To carry out the heuristic, we first compute a shortest path for every pair of start and goal locations. In this case, we get the orange and green paths for robots and , respectively. Then, if we decide to split the problem into two smaller problems, for each of the paths, it is split into two (generally) equal length pieces and the middle node is set as the intermediate goal. In our example, we may do this for robot easily and set the intermediate goal location at from the top-left corner (the brown disc labeled in Fig. ?(b)). For robot , because the middle location coincides with that of robot , we pick an alternative location that is not already occupied as the intermediate goal for robot , in this case from the top-left corner. The intermediate goals for the first instance will also serve as the start locations of the second instance. This yields two child instances with both requiring a time expansion with steps each, whereas the original problem also requires a time expansion with steps. In general, we may divide a problem into arbitrarily many smaller instances in the time domain.

If a problem is divided in this manner to sub problems, we call the resulting heuristic a *-way split*. Because the division is over time, there is in fact no interaction between the individual, smaller instances. Once we obtain the solution for each child instance, the solutions can be glued together by simple concatenation. In practice, it turns out that this simple heuristic dramatically improves the performance without heavy negative impact on path optimality. In computational experiments, we observe a consistent speedup.

### 4.3Heuristic: Reachability Analysis

Another method to effectively reduce ILP model size (without losing any guarantee) is through *reachability analysis*. Again using the example from Fig. ?(a) and focusing on robot , if the time expansion uses time steps, then the reachable nodes (from both the start and the goal) of the graph at is illustrated in Fig. ?. Constructing the time-expanded graph from these then greatly reduces the resulting ILP model size.

(a) | (b) | (c) | ||

**Remark.** Because the problem we are to solve in this section is NP-complete

[43] and we are aiming to solve it exactly, no meaningful analysis on computational complexity can be provided; we only note that the computational time required by this part of the framework dominates all other parts.

## 5Computational Evaluation

We implemented the roadmap building phase in C++ using CGAL [44]. The discrete path planning module, written in Java, uses Gurobi [42] as the ILP solver. The experiments were carried out on an Intel i7-4850HQ laptop PC. For evaluation, we tested of our algorithmic framework over five distinct environments. The first one is a simple square with a side length of 35 (recall that the robots are unit discs), with no internal obstacles. The rest of the environments have the same bounding square but contain different obstacle setups. We randomly select start and goal locations for all our tests. These environments, along with a typical -robot problem instance, are illustrated in Fig. ?.

(a) | (b) |

(c) | (d) |

### 5.1Performance in Bounded, Obstacle-Free Environment

We first characterize how our framework performs in terms computation speed and solution optimality, as -way split heuristic is used with different values of . For this task, we carry out two sets of computations. The first set, covered in this subsection, focuses on bounded, obstacle-free environment. For this environment, we let the number of robots vary between to and evaluate the performance of the framework with the baseline algorithm (*i.e.*, a single sub-problem), 2-way split (*i.e.*, two sub-problems), 4-way split, and 8-way split. For each choice of the number of robots and the heuristic, test cases are randomly generated sequentially and solved. The average running time and optimality ratio is plotted in Fig. ?. Note that our computation of the optimality ratio is conservative. To compute this ratio, we find the shortest distance between each pair of start and goal locations and use the maximum of these distances as the estimate of optimal time (since the robot has maximum speed of ). We then obtain the optimality ratio by dividing the actual task completion time by the estimated value.

From the experiments, we observe that the baseline algorithm actually performs quite well for up to robots in the absence of obstacles. With that said, both 2-way and 4-way splits do much better without losing much optimality–all three achieves optimality ratio between 1.2 to 1.6 in our experiments. With the 8-way split, sacrificing some optimality, we were able to consistently solve problems with robots in seconds on average. Such settings correspond to robots occupying over of the free space, a setting that has never been attempted before in optimal multi-robot path planning. With 8-way split, problems with robots in the same environment, which corresponds to a robot density over , can be comfortably solved in about minutes. We note that, if robot density is around , our method can readily solve problems with over robots (in a larger environment).

### 5.2Performance in Bounded Environment with Obstacles

The second set of experiments shifts the focus to an environment with obstacles. For this we use the “Jack” environment. We choose this environment because it is in fact a relatively difficult setting as many shortest paths have to pass through the middle, causing conflicts. The experimental result, for to robots, is plotted in Fig. ?, which is consistent with our first set of experiments. We note that obstacles, while affecting the computation time, do not heavily impact the optimality of the result.

### 5.3Evaluation of Overall Framework Performance

Our last set of experiments is aimed at showing the overall effectiveness of our framework. For this purpose we select the splitting heuristic automatically. Roughly, we do this by increasing (in a -way split) to keep each time expansion with time steps, which we have found to strike a good balance between speed and optimality. For the set of environments illustrated in Fig. ?, the experimental result is plotted in Fig. ?. Our method is able to consistently solve all instances with an average solution time from to seconds while providing good optimality assurance on minimum makespan. The two spikes in Fig. ?(a) at robots are due to the switching to 8-way split at robot for these two environments.

## 6Conclusion

In this paper, we present an algorithmic framework for tackling the multi-robot path planning problem in continuous, multiply-connected environments. Our framework partitions the planning task into two phases. In the first phase, the configuration space is tiled with a carefully selected regular lattice pattern, taking into account robot-robot collision avoidance. The imposed lattice is then processed to yield a roadmap that preserves the connectivity of the continuous configuration space, which is essential for achieving near optimality in the final solution. Snapping the robots and their goal locations to the roadmap then transforms the initial continuous planning problem to a discrete planning problem. In the second phase, the discrete planning problem can be solved using any graph-based multi-robot path planning algorithms, after which the solution can be readily used in continuous domains. With a good optimal planner for discrete Mpp, our overall algorithm can consistently solve large problem instances with tens to hundreds of robots in seconds to minutes.

As we make an important first step here toward a generic framework for near-optimal multi-robot path planning in continuous domains with obstacles, we also bring about many natural next steps. We discuss a few of these here, which we plan to fully explore in our future research.

*Nonholonomic constraints.* An important issue not addressed in this paper is path planning for nonholonomic robots. We briefly touch upon this issue here. Our algorithmic framework supports quite naturally nonholonomic robots that are small-time locally controllable (STLC) with reasonable minimum turning radius. Essentially, to apply our method to a nonholonomic robot, the robot only need the capability to: *(i)* move from its start location to a nearby roadmap node with a given orientation, *(ii)* trace any path on the roadmap without incurring collision, and *(iii)* move from a roadmap node to a nearby goal location (with an arbitrary orientation). A car-like robot, or any robot that is STLC, possesses the first and the third capabilities. Then, as long as the robot has a minimum turning radius of , it can follow any path on a hexgonal lattice without violating its nonholonomic constraints (see Figure 4). More importantly, multiple robots may move concurrently in such a manner without causing collisions. The introduction of nonholonomic constraints does not significantly affect optimality.

*Decentralized planner.* The current implementation of our framework yields a centralized algorithm. It is possible, however, to make the algorithm decentralized at the global scale. For example, we may simply let each robot perform planning individually using a method such as reciprocal velocity obstacle (RVO) based algorithm and engage locally our centralized method as the density of robots surpass some critical threshold. Note that, as the density of robots increases, RVO-based or repulsion-force-based methods generally do not have optimality guarantees and may also create deadlocks.

*Optimality of hexagonal lattice in general environments.* While we have shown that a hexagonal lattice structure yields the optimal tiling in the absence of obstacles, it is unclear whether this holds well when there are obstacles in the bounded environment. In future work, we plan to study this through simulation under various obstacle settings. We will also characterize the performance using lattice structures other than hexagonal ones. The reason behind this is that, although hexagonal lattice allows the highest density, each node is only 3-connected. Square lattices, for example, has a 4-connected structure, which facilitates the discrete planning phase. Generally, discrete Mpp problems with higher connectivity are easier to optimally solve.

### Footnotes

- Warehousing systems from Kiva Systems [4] can work effectively with hundreds of robots. However, these robots essentially live on a grid within a structured environment.
- An accompanying video demonstrating our algorithm and software developed in this paper are available from the corresponding author’s website.
- Note that our algorithmic framework also applies to other time- and distance-based optimality objectives through the use of an appropriate discrete planning algorithm.
- and are unit-less given the unit disc robot assumption. If the robots have radius , the right side of the inequalities from and should be scaled by a multiplicative factor of .
- These tilings are: triangular, trihexagonal, square, elongated triangular, hexagonal, truncated square, truncated trihexagonal, truncated hexagonal, snub square, rhombitrihexagonal, snub hexagonal.

### References

- J. Alonso-Mora, “Collaborative Motion Planning for Multi-Agent Systems,” Ph.D. dissertation, ETH Zurich, Mar. 2014.
- J. Snape, S. J. Guy, J. van den Berg, and D. Manocha, “Smooth coordination and navigation for multiple differential-drive robots,” in
*Exp. Robot.*1em plus 0.5em minus 0.4emSpringer, 2014. - R. A. Knepper and D. Rus, “Pedestrian-inspired sampling-based multi-robot collision avoidance,” in
*RO-MAN*, 2012. - P. R. Wurman, R. D’Andrea, and M. Mountz, “Coordinating hundreds of cooperative, autonomous vehicles in warehouses,”
*AI Mag.*, vol. 29, no. 1, pp. 9–19, 2008. - J. R. Snape, “Smooth and collision-free navigation for multiple mobile robots and video game characters,” Ph.D. dissertation, University of North Carolina at Chapel Hill, 2012.
- E. J. Griffith and S. Akella, “Coordinating multiple droplets in planar array digital microfluidic systems,”
*IJRR*, vol. 24, no. 11, pp. 933–949, 2005. - J. Schwartz and M. Sharir, “On the piano movers’ problem: III. coordinating the motion of several independent bodies: the special case of circular bodies moving amidst polygonal barriers,”
*IJRR*, vol. 2, no. 3, pp. 46–75, 1983. - S. J. Buckley, “Fast motion planning for multiple moving robots,” in
*ICRA*, 1989. - M. A. Erdmann and T. Lozano-Pérez, “On multiple moving objects,” in
*ICRA*, 1986. - Z. Bien and J. Lee, “A minimum-time trajectory planning method for two robots,”
*IEEE T. Robot. Autom.*, vol. 8, no. 3, pp. 414–418, 1992. - P. A. O’Donnell and T. Lozano-Pérez, “Deadlock-free and collision-free coordination of two robot manipulators,” in
*ICRA*, 1989. - R. Ghrist, J. M. O’Kane, and S. M. LaValle, “Computing Pareto Optimal Coordinations on Roadmaps,”
*IJRR*, vol. 24, no. 11, pp. 997–1010, 2005. - S. M. LaValle and S. A. Hutchinson, “Optimal motion planning for multiple robots having independent goals,”
*IEEE T. Robot. Autom.*, vol. 14, no. 6, pp. 912–925, Dec. 1998. - J. Peng and S. Akella, “Coordinating multiple robots with kinodynamic constraints along specified paths,” in
*Algo. Found. Robot. V*, J.-D. Boissonat, J. Burdick, K. Goldberg, and S. Hutchinson, Eds.1em plus 0.5em minus 0.4emBerlin: Springer-Verlag, 2002, pp. 221–237. - J. van den Berg and M. Overmars, “Prioritized motion planning for multiple robots,” in
*IROS*, 2005. - J. van den Berg, J. Snoeyink, M. Lin, and D. Manocha, “Centralized path planning for multiple robots: Optimal decoupling into sequential plans,” in
*RSS*, 2009. - P. Švestka and M. H. Overmars, “Coordinated path planning for multiple robots,”
*Robotics and Autonomous Systems*, vol. 23, no. 3, pp. 125–152, 1998. - J. E. Hopcroft, J. T. Schwartz, and M. Sharir, “On the complexity of motion planning for multiple independent objects; PSPACE-Hardness of the “Warehouseman’s Problem”,”
*IJRR*, vol. 3, no. 4, pp. 76–88, 1984. - J. van den Berg, M. C. Lin, and D. Manocha, “Reciprocal velocity obstacles for real-time multi-agent navigation,” in
*ICRA*, 2008. - J. van den Berg, J. Snape, S. J. Guy, and D. Manocha, “Reciprocal collision avoidance with acceleration-velocity obstacles,” in
*ICRA*, 2011. - K. Kant and S. Zucker, “Towards efficient trajectory planning: The path velocity decomposition,”
*IJRR*, vol. 5, no. 3, pp. 72–89, 1986. - A. F. v. d. S. I. Karamouzas, R. Geraerts, “Space-time group motion planning,” in
*WAFR*, 2012. - M. Peasgood, C. Clark, and J. McPhee, “A complete and scalable strategy for coordinating multiple robots within roadmaps,”
*IEEE T. Robot.*, vol. 24, no. 2, pp. 283–292, 2008. - K. Solovey, O. Salzman, and D. Halperin, “Finding a needle in an exponential haystack: Discrete RRT for exploration of implicit roadmaps in multi-robot motion planning,” in
*WAFR*, 2014. - K. Solovey, J. Yu, O. Zamir, and D. Halperin, “Motion planning for unlabeled discs with optimality guarantees,” in
*RSS*, 2015. - M. Turpin, N. Michael, and V. Kumar, “Concurrent assignment and planning of trajectories for large teams of interchangeable robots,” in
*ICRA*, 2013. - D. Kornhauser, G. Miller, and P. Spirakis, “Coordinating pebble motion on graphs, the diameter of permutation groups, and applications,” in
*FOCS*, 1984. - R. M. Wilson, “Graph puzzles, homotopy, and the alternating group,”
*J. Combinat. Theo. (B)*, vol. 16, pp. 86–96, 1974. - M. R. K. Ryan, “Exploiting subgraph structure in multi-robot path planning,”
*J. Arti. Intel. Res.*, vol. 31, pp. 497–542, 2008. - T. Standley and R. Korf, “Complete algorithms for cooperative pathfinding problems,” in
*IJCAI*, 2011. - G. Wagner and H. Choset, “M*: A complete multirobot path planning algorithm with performance bounds,” in
*IROS*, 2011. - J. Yu and S. M. LaValle, “Planning optimal paths for multiple robots on graphs,” in
*ICRA*, 2013. - A. Krontiris, Q. Sajid, and K. Bekris, “Towards using discrete multiagent pathfinding to address continuous problems,”
*AAAI-WoMP*, 2012. - K. Solovey and D. Halperin, “-color multi-robot motion planning,” in
*WAFR*, 2012. - J. Yu and S. M. LaValle, “Fast, near-optimal computation for multi-robot path planning on graphs,” in
*AAAI*, 2013, late breaking papers. - L. E. Kavraki, P. Svestka, J.-C. Latombe, and M. H. Overmars, “Probabilistic roadmaps for path planning in high-dimensional configuration spaces,”
*IEEE T. Robot. Autom.*, vol. 12, no. 4, pp. 566–580, 1996. - S. M. LaValle, “Rapidly-exploring random trees: A new tool for path planning,” Iowa State University, Tech. Rep., Oct 1998, computer Science Department TR 98-11.
- W. Robert,
*The Geometrical Foundation of Natural Structure. A Source Book of Design*.1em plus 0.5em minus 0.4emDover, 1978. - T. Lozano-Pérez and M. A. Wesley, “An algorithm for planning collision-free paths among polyhedral obstacles,”
*Comm. ACM*, vol. 22, no. 10, pp. 560–570, 1979. - S. K. Ghosh, A. Maheshwari, S. P. Pal, S. Saluja, and C. V. Madhavan, “Characterizing and recognizing weak visibility polygons,”
*Comput. Geom.*, vol. 3, no. 4, pp. 213–233, 1993. - J. Yu and D. Rus, “Pebble motion on graphs with rotations: Efficient feasibility tests and planning,” in
*WAFR*, 2014. - =2plus 43minus 4 G. O. Inc., “Gurobi optimizer reference manual,” 2015. [Online]. Available: http://www.gurobi.com =0pt
- J. Yu and S. M. LaValle, “Structure and intractability of optimal multi-robot path planning on graphs,” in
*AAAI*, 2013. - “Cgal, Computational Geometry Algorithms Library,” http://www.cgal.org.