Very Large-scale Multi-Robot Task Allocation in Challenging Environments via Robot Redistribution

Changjoo Nam; Joonyeol Sim; Seabin Lee

REVIEW 3 major objections 4 minor 19 references

Very Large-scale Multi-Robot Task Allocation in Challenging Environments via Robot Redistribution

T0 review · 3 major / 4 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A roadmap-based redistribution scheme allocates hundreds of robots in dense environments with fewer deadlocks and shorter makespans than conflict-based planners, in seconds.

desk verdict New scalable MRTA heuristic with real empirical promise; the formal guarantees don't hold as stated, but the method deserves peer review. read the letter →

arxiv 2506.07293 v1 pith:YO7B4ABL submitted 2025-06-08 cs.RO cs.MA

Seabin Lee , Joonyeol Sim , Changjoo Nam This is my paper

classification cs.ROcs.MA

keywords multi-robottaskallocationmakespanminimizationgeneralizedVoronoidiagramrobotredistributiondemand-supplyanalysisdeadlockavoidanceconflict-freenavigationlarge-scalefleets

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper claims that the bottleneck in large-scale multi-robot task allocation is not the assignment itself but the conflicts robots create while moving, and that those conflicts can be designed out rather than resolved. The proposed method, MRTA-RM, builds a Generalized Voronoi Diagram roadmap of the environment, splits it into components, measures how many robots each component holds relative to its tasks, and redistributes surplus robots between neighboring components along one-way flows. This makes robots traverse every passage in a single direction and keeps early arrivals from blocking later ones, so hundreds of robots can execute all tasks with rare deadlocks and a shorter makespan than conflict-based planners such as CBS-TA, which time out once instances grow to hundreds of robots or robots and tasks are separated. The allocation runs in seconds even for 500 robots; the paper's theorems state that if robots follow the planned waypoints in the planned order, the execution is conflict-free.

What carries the argument

The load-bearing objects are the roadmap and the component-flow plan built on top of it. The roadmap is a topological graph generated from the environment's Generalized Voronoi Diagram and postprocessed to remove nodes unreachable by a robot of radius $r$; its junction (JC) nodes, nodes with degree other than two plus terminals, and the sections between them define the components $Z = J \cup S$. Each component carries a demand-supply value $D_s = |R_s| - |T_s|$, and the redistribution plan is a collection of flows stating how many robots move from each oversupplied component to each undersupplied one, revised by Algorithm 2 so that every flow runs only between adjacent components. Components are typed C1 through C4 by whether they receive or send robots, and flows execute in a fixed order, C2 to C4 first, then C2 to C3, then C4 to C4, then C4 to C3, which is the push-pop mechanism announced in the abstract: a transit component sends robots onward only after it has received them, first-in first-out. Task assignment inside each component follows the arrival order with tasks grouped by entry direction (front, back, and optionally middle groups), which is what prevents early arrivals from blocking later ones. Theorems 4.1-4.3 convert cost-minimality of the Hungarian allocation plus these grouping rules into the one-way-traffic and non-blocking guarantees that make explicit conflict resolution unnecessary.

What would settle it

Run the dynamic-simulator experiment in the separated shopping-mall scenario with the simulator logging each robot's position against its planned roadmap waypoints and recording every deadlock and head-on encounter. If any deadlock or opposite-direction meeting occurs while both involved robots are still on their planned waypoints and in the planned arrival order, Properties 1 and 2 are violated and the theorems' conditional guarantee fails. If every such event follows a visible deviation from the waypoints, the theorems stand and the gap is entirely in the tracking controller.

Watch

Extended reading notes

Core claim

The central claim is that allocating robots at the component level, rather than robot-by-robot, keeps multi-robot task allocation tractable at fleet scale without sacrificing conflict avoidance. MRTA-RM first generates a roadmap from the environment's Generalized Voronoi Diagram and partitions it into components, the junction (JC) nodes where corridors meet and the linear sections between them. For each component it computes a demand-supply value $D_s$, the number of robots associated with the component minus the number of tasks; surplus robots in oversupplied components are matched to tasks in undersupplied components using the Hungarian method on component-pair shortest-path costs, and the resulting flows are decomposed into transfers between adjacent components. The flows are then executed in a fixed priority order and tasks are assigned within each component by arrival order, so that the first robot to arrive takes the farthest task. Theorems 4.1-4.4 prove that this redistribution enforces unidirectional edge traversal and non-blocking arrivals, hence conflict-free execution whenever robots follow the computed waypoints in the planned order, and Theorem 4.5 bounds the running time by $O(N|V| + \max(N^3, |Z|^3))$. In dynamic simulation the method allocates 100-500 robots in a few seconds, reaches 58-100% execution success in the hardest separated scenarios and 65-100% in random ones, and achieves lower makespan than the CBS-based and conventional baselines in nearly all tested instances; the paper notes a single five-robot warehouse case where CBS-TA is one percent faster.

Load-bearing premise

The conflict-free guarantees hold only if robots follow the planned roadmap waypoints and arrive in the planned order; the paper's own experiments use a local controller that lets robots deviate, which is why execution success rates stay below 100 percent.

Editorial extensions

If this is right

The allocation and its reference waypoints are produced in polynomial time $O(N|V| + \max(N^3, |Z|^3))$, so a fleet of hundreds of robots can be re-allocated quickly when tasks change; the paper notes that time-extended assignments follow by repeatedly running the method until all tasks are done.
Because head-on encounters are removed at planning time, no explicit collision-free path computation is needed: in the paper's dynamic simulations MRTA-RM reaches 100% computation success in every tested instance, with execution success rates of 58-100% in the separated scenarios and 65-100% in the random ones.
Feeding MRTA-RM's allocation to a space-time planner (ST-RRT*) reduces that planner's computation time by at least 7.8% and raises its success rate relative to the same planner fed by Hungarian or greedy allocations.
The method operates in continuous space on a roadmap rather than on a grid, which removes the discretization overhead of CBS-based methods and keeps runtime under a second for tens of robots and under about nine seconds for 500.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

Beyond the paper: the component-flow view suggests a natural online extension, when new tasks appear mid-execution only the demand-supply counts and category order change, so re-running the redistribution step should suffice; the paper only mentions repeated runs for time-extended assignments.
Beyond the paper: the speedup rests on the approximation that every robot in a component shares one component-pair travel cost; a sensitivity study varying section length and JC-node density would reveal where allocation quality is traded for computation time, which the paper does not report.
Beyond the paper: the gap between the 100% conflict-free theorems and the 58-100% simulator success rates is, by the paper's own analysis, a tracking gap; a controller or planner that preserves waypoint order should close it, and the ST-RRT* integration experiment is a partial test of that idea.
Beyond the paper: treating each robot type as a separate commodity with its own roadmap would extend the demand-supply balancing to heterogeneous fleets, the direction the paper reserves for future work.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

MRTA-RM is a genuinely new algorithmic idea and its simulations are strong enough to take seriously. The redistribution over GVD components, the C1-C4 categorization, and the arrival-order task grouping are not in the CBS-TA or Hungarian baseline literature; they produce a fast front-end that scales to hundreds of robots in dense maps. The empirical work is decent: three environments, two distributions, six baselines, and an integration test with ST-RRT*. I believe the core claim that this allocation is useful as a scalable heuristic is probably true.

The weak spot is the theory section, and it is load-bearing. Theorem 4.1 tries to rule out opposite-direction flows through a JC node with an exchange argument, but the allocation A minimizes a sum of component-wise path costs, not the makespan, and the cost matrix uses one shortest path per component pair. No Monge or non-crossing property is established; a crossed flow can be sum-of-cost optimal. So the theorem does not establish unidirectional edge traversal. Theorem 4.4's completeness proof is essentially circular: it assumes that if a C4 component is waiting, there is an already-executed flow inbound from outside the waiting set, which is exactly the dependency-cycle case it needs to rule out. The properties also require exact waypoint following, and the Unity NavMesh/RVO controller explicitly deviates, so the below-100% success rates are consistent with the guarantee not being tested, not with a proven bound. No code, maps, or error bars are provided, which makes independent checks hard.

That said, this is not a fatal problem for the paper as a heuristic contribution. The empirical evidence is plausible and the method is new. The authors should either tighten the proofs or explicitly reframe the claims as heuristic deadlock reduction rather than guaranteed properties. A referee can ask for that.

I'd send this to peer review. The contribution is real, the experiments are broad, and the flaws are correctable. It deserves a serious referee, not a desk reject. I'd bring it to reading group if the discussion is about where scalability and formal guarantees diverge in MRTA.

Referee Report

3 major / 4 minor

Summary. The paper proposes MRTA-RM, a scalable multi-robot task allocation method for dense, cluttered environments. The method builds a GVD-based roadmap, partitions it into junction nodes and sections, performs a demand-supply analysis, computes a surplus-robot redistribution plan via the Hungarian method on component-wise shortest-path costs, revises the plan into adjacent component flows, prioritizes those flows, and finally assigns tasks within components using arrival-order and task-grouping rules. The authors claim that Theorems 4.1-4.3 guarantee unidirectional edge traversal and no blocking if robots exactly follow roadmap paths, that Theorem 4.4 guarantees completeness of flow execution, and that the method runs in polynomial time. Experiments in a Unity/NavMesh simulator with RVO collision avoidance compare MRTA-RM against CBS-TA, ECBS-TA, continuous CBS variants, Hungarian-TA, Greedy-TA, and a ST-RRT* integration, reporting favorable makespan, success rate, and scalability for instances with up to 500 robots.

Significance. If the formal guarantees were sound, the paper would make a substantial contribution to large-scale MRTA in continuous environments, and the empirical study is generally well designed: it spans three environment types, two distribution scenarios, several baseline families, and a MAPF-integration test. The algorithmic pipeline is clearly described and the computational scaling claims are credible from the experiments. However, the central theoretical bridge connecting the redistribution mechanism to deadlock-free execution is not proven: the proofs of Theorems 4.1 and 4.4 contain load-bearing gaps, and the experiments explicitly relax the exact-waypoint-following assumption under which the properties are stated. The empirical results are valuable as evidence for a well-engineered heuristic, but the paper's stated formal claims currently overreach.

major comments (3)

[Sec. 4.3 and Theorem 4.1 (Sec. 4.6)] The proof of Theorem 4.1 argues that any opposite-direction crossing of a JC node produces a higher-cost allocation, so a cost-minimizing assignment A cannot contain it. However, A is computed by the Hungarian method (Algorithm 1, line 12) minimizing the sum of component-wise path lengths c_ij = |P_ij|, whereas the problem objective is minimax makespan (Eq. 1). Moreover, c_ij is a component-center approximation computed once per component pair, not a per-robot cost, and the proof establishes no Monge or non-crossing property for shortest paths on GVD roadmaps, which can contain cycles. Without such a property, crossed flows can be cost-optimal, so Property 1 (unidirectional edge traversal) is not guaranteed. The subsequent bridging statement, 'By Theorems 4.1-3, Properties 1 and 2 ... are satisfied if the robots can exactly follow the paths along the roadmap,' therefore does not follow.
[Theorem 4.4 (Sec. 4.6)] The completeness proof is circular. It assumes that if a C4 component has not fully received robots, there must be at least one already-executed flow heading to it, and then asserts that some other C4 component is not in Z_l and has not met its execution condition, contradicting the assumption. This merely restates the existence of an incoming flow; it does not rule out a dependency cycle in which every waiting C4 component waits for robots from another waiting C4 component. The priority ordering in Sec. 4.4 (C2-to-C4 before C4-to-C4, etc.) is not shown to imply acyclicity of the flow graph, so the proof does not establish that all flows will execute. The claimed planning-level deadlock-freedom therefore rests on an unproven assertion.
[Sec. 4.6 (final paragraph) and Sec. 5.1/5.2] The formal guarantees are conditional on robots exactly following the planned roadmap waypoints, yet the experiments use Unity NavMesh with an RVO local controller that permits deviations from planned paths, and the measured success rates are below 100% in many conditions (for example, 58-96% in several separated-scenario cells of Table 2 and 60-100% in Table 3). The paper explicitly acknowledges that conflict-free paths cannot be guaranteed under such deviations. Consequently, the empirical success rates do not directly validate Theorems 4.1-4.3; they demonstrate the heuristic value of the redistribution pipeline, but the central claim of conflict-free or deadlock-free execution remains formally unverified. I recommend either repairing the proofs or clearly reframing the contribution as an empirically validated heuristic with the formal section labeled as an ideal-case analysis under perfect path tracking.

minor comments (4)

[Sec. 4.5 and Sec. 4.6] The method provides JC-node-based reference waypoints, but the formal analysis refers to robots following 'paths along the roadmap' without specifying whether robots are assumed to traverse the full node sequence or only the JC waypoints; this ambiguity affects the interpretation of Properties 1 and 2.
[Sec. 5.2] The statement that Hungarian-TA 'satisfies Property 1 in Sec. 3' is unsupported: a generic Hungarian assignment over arbitrary roadmap costs does not enforce unidirectional edge traversal, and the paper's own proof of Property 1 relies on the redistribution and task-grouping mechanism specific to MRTA-RM. This claim should be removed or justified.
[Tables 2 and 3] When a baseline fails to compute a solution within the time limit, the corresponding makespan and SoC cells are omitted, making direct comparisons in the separated scenarios difficult; reporting the number of successful instances and, where possible, median or time-limited performance would improve readability.
[Sec. 5.1] The roadmap construction time is excluded from the reported computation times; while the paper notes that including it would not change the conclusions for the large-scale experiments, a more thorough reporting of this one-time cost in the small-scale CBS comparisons would improve reproducibility.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central derivation is self-contained and does not reduce its predictions to fitted inputs or self-citations.

full rationale

MRTA-RM's derivation chain is not circular. The allocation cost matrix (Alg. 1, lines 5-11) is built from shortest-path lengths on an externally constructed GVD roadmap and solved by the standard Hungarian method; no parameter is fitted to the reported makespan or success-rate values, and the reported makespan is measured in simulation rather than read off from the planning costs. The deadlock-avoidance properties are enforced algorithmically through directed flow priorities, component categorization (C1-C4), and front/back task grouping, so Properties 1-2 are design aims verified by construction rather than renormalizations of the target metric. There are no load-bearing self-citations: the GVD construction [14], CBS [3], RVO [15], and ST-RRT* [17] are all external references. The paper does contain an acknowledged gap in Sec. 4.6: 'conflict-free paths could not be guaranteed if the robots deviate from the paths from the roadmap,' and the experimental controller (Unity NavMesh with RVO) allows such deviations, which is why success rates are below 100%. The completeness proof of Theorem 4.4 is also not rigorous as written; however, that is a correctness and rigor concern, not a circular reduction of a prediction to its inputs. Accordingly, the circularity burden is low.

Assumptions & free parameters 2 free parameters · 6 assumptions · 0 invented entities

No constants were fitted to the reported makespan or success-rate targets. The listed free parameters are environment and protocol inputs that materially affect results. JC nodes, sections, components, and C1-C4 categories are algorithmic abstractions inside the roadmap representation, not independently testable physical entities, so no invented entities are recorded.

free parameters (2)

robot radius r = 6 units
Input to roadmap pruning in Sec. 4.1. Not fitted to target metrics, but it directly shapes the roadmap topology and therefore all allocations and success rates.
planning time limit and deadlock threshold = 5-minute computation limit, 5-second deadlock threshold
Chosen in Sec. 5. These definitions determine computation success rates and deadlock success rates, so they materially affect all reported percentages.

assumptions (6)

domain assumption The GVD-based roadmap preserves the essential connectivity of the free space and yields valid routes for disk robots of radius r.
Invoked in Sec. 4.1. If the roadmap is disconnected or too coarse, the component demands and paths used by the method are wrong.
domain assumption Associating each robot and task to the closest visible roadmap node yields traversable and meaningful component memberships.
Invoked in Sec. 4.2. The line-of-sight check prevents walls, but closest-node association can still misroute robots in dense layouts.
domain assumption Component-center shortest path length is a sufficient approximation of true robot travel cost for the Hungarian assignment.
Invoked in Sec. 4.3, lines 5-11. All robots in a component share one cost to another component, ignoring individual positions and congestion.
domain assumption Robots follow the planned reference waypoints and preserve the planned arrival order.
Invoked in Sec. 4.6. Properties 1 and 2 depend on exact path following; the paper says deviations invalidate the conflict-free guarantee.
domain assumption Unity NavMesh with local RVO collision avoidance realistically models execution and deadlocks for homogeneous disk robots.
Invoked in Sec. 5. No physical robot experiments are reported, so the simulation is the only evidence for runtime behavior.
standard math Hungarian algorithm and Dijkstra shortest paths are correct and available as standard tools.
Used in Sec. 4.3 and Sec. 4.6 as standard subroutines with known correctness and complexity.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Very Large-scale Multi-Robot Task Allocation in Challenging Environments via Robot Redistribution." pith.science (2026). https://pith.science/paper/YO7B4ABL

@misc{pith2026250607293,
  author       = {Pith},
  title        = {Pith review of: Very Large-scale Multi-Robot Task Allocation in Challenging Environments via Robot Redistribution},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YO7B4ABL}},
  note         = {Machine review of arXiv:2506.07293}
}

read the original abstract

We consider the Multi-Robot Task Allocation (MRTA) problem that aims to optimize an assignment of multiple robots to multiple tasks in challenging environments which are with densely populated obstacles and narrow passages. In such environments, conventional methods optimizing the sum-of-cost are often ineffective because the conflicts between robots incur additional costs (e.g., collision avoidance, waiting). Also, an allocation that does not incorporate the actual robot paths could cause deadlocks, which significantly degrade the collective performance of the robots. We propose a scalable MRTA method that considers the paths of the robots to avoid collisions and deadlocks which result in a fast completion of all tasks (i.e., minimizing the \textit{makespan}). To incorporate robot paths into task allocation, the proposed method constructs a roadmap using a Generalized Voronoi Diagram. The method partitions the roadmap into several components to know how to redistribute robots to achieve all tasks with less conflicts between the robots. In the redistribution process, robots are transferred to their final destinations according to a push-pop mechanism with the first-in first-out principle. From the extensive experiments, we show that our method can handle instances with hundreds of robots in dense clutter while competitors are unable to compute a solution within a time limit.

Figures

Figures reproduced from arXiv: 2506.07293 by the authors.

**Figure 2.** An example roadmap. Red larger nodes represent junction [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗

**Figure 3.** Example of revising initial redistribution plan to the final [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗

Figures from the paper (6 more)

**Figure 4.** Figure 4: Example of task grouping in a section. The yellow trian [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]

**Figure 5.** Figure 5: Example environment for Theorem 4.1 shorter. Specifically, when Nz→z ′ = Nz ′→z ′′ , directly transferring N robots from z to z ′′ can reduce the cost. For Nz→z ′ > Nz ′→z ′′ , the cost can be cheaper when transferring Nz→z ′ − Nz ′→z ′′ robots from z to z ′ and Nz ′→…

**Figure 6.** Figure 6: Environments used for evaluation: (a) Shopping mall [PITH_FULL_IMAGE:figures/full_fig_p009_6.png]

**Figure 7.** Figure 7: Part of the environments for small-scale experiments com [PITH_FULL_IMAGE:figures/full_fig_p009_7.png]

**Figure 8.** Figure 8: The comparison result with the methods that explicitly resolve conflicts. Success rate here refers to the percentage of instances in [PITH_FULL_IMAGE:figures/full_fig_p011_8.png]

**Figure 9.** Figure 9: The comparison result with the methods that do not explicitly resolve conflicts. Our proposed method is slightly slower than others [PITH_FULL_IMAGE:figures/full_fig_p013_9.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

19 extracted references · 18 canonical work pages

[1]

B. P. Gerkey, M. J. Matari´ c, A formal analysis and taxonomy of task allocation in multi-robot systems, The International Jour- nal of Robotics Research 23 (9) (2004) 939–954

work page 2004
[2]

J. K. Lenstra, D. B. Shmoys, ´E. Tardos, Approximation algo- rithms for scheduling unrelated parallel machines, Mathemati- cal Programming 46 (1990) 259–271

work page 1990
[3]

Sharon, R

G. Sharon, R. Stern, A. Felner, N. R. Sturtevant, Conflict- based search for optimal multi-agent pathfinding, Artificial In- telligence 219 (2015) 40–66

work page 2015
[4]

H¨ onig, S

W. H¨ onig, S. Kiesel, A. Tinka, J. W. Durham, N. Ayanian, Conflict-based search with optimal task assignment, in: Pro- ceedings of the International Conference on Autonomous Agents and Multiagent Systems (AAMAS), IF AAMAS, 2018, pp. 757– 765

work page 2018
[5]

Z. Chen, J. Alonso-Mora, X. Bai, D. D. Harabor, P. J. Stuckey, Integrated task assignment and path planning for capacitated multi-agent pickup and delivery, IEEE Robotics and Automa- tion Letters 6 (3) (2021) 5816–5823

work page 2021
[6]

Z. Liu, H. Wei, H. Wang, H. Li, H. Wang, Integrated task al- location and path coordination for large-scale robot networks with uncertainties, IEEE Transactions on Automation Science and Engineering 19 (4) (2021) 2750–2761

work page 2021
[7]

H. W. Kuhn, The hungarian method for the assignment prob- lem, Naval Research Logistics Quarterly 2 (1-2) (1955) 83–97

work page 1955
[8]

Henkel, J

C. Henkel, J. Abbenseth, M. Toussaint, An optimal algorithm to solve the combined task allocation and path finding prob- lem, in: Proceedings of IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), IEEE, 2019, pp. 4140– 4146

work page 2019

Show all 19 references

[9]

Zhang, H

H. Zhang, H. Luo, Z. Wang, Y. Liu, Y. Liu, Multi-robot coop- erative task allocation with definite path-conflict-free handling, IEEE Access 7 (2019) 138495–138511

2019
[10]

Turpin, K

M. Turpin, K. Mohta, N. Michael, V. Kumar, Goal assign- ment and trajectory planning for large teams of interchangeable robots, Autonomous Robots 37 (4) (2014) 401–415

2014
[11]

R. E. Burkard, F. Rendl, Lexicographic bottleneck problems, Operations Research Letters 10 (5) (1991) 303–308

1991
[12]

Chakrabarty, S

D. Chakrabarty, S. Khanna, S. Li, On (1, ϵ)-restricted as- signment makespan minimization, in: Proceedings of the An- nual ACM-SIAM Symposium on Discrete Algorithms (SODA), SIAM, 2014, pp. 1087–1101

2014
[13]

S. M. LaValle, Planning Algorithms, Cambridge University Press, 2006

2006
[14]

H. Choset, Incremental construction of the generalized voronoi diagram, the generalized voronoi graph, and the hierarchical generalized voronoi graph, in: Proceedings of the CGC Work- shop on Computational Geometry, 1997

1997
[15]

Van den Berg, M

J. Van den Berg, M. Lin, D. Manocha, Reciprocal velocity ob- stacles for real-time multi-agent navigation, in: Proceedings of IEEE International Conference on Robotics and Automation (ICRA), IEEE, 2008, pp. 1928–1935

2008
[16]

C. Yu, Q. Li, S. Gao, A. Prorok, Accelerating multi-agent plan- ning using graph transformers with bounded suboptimality, in: Proceedings of IEEE International Conference on Robotics and Automation (ICRA), IEEE, 2023, pp. 3432–3439

2023
[17]

Grothe, V

F. Grothe, V. N. Hartmann, A. Orthey, M. Toussaint, St-rrt*: Asymptotically-optimal bidirectional motion planning through space-time, in: Proceedings of IEEE International Conference on Robotics and Automation (ICRA), IEEE, 2022, pp. 3314– 3320

2022
[18]

I. A. Sucan, M. Moll, L. E. Kavraki, The open motion planning library, IEEE Robotics & Automation Magazine 19 (4) (2012) 72–82

2012
[19]

Orthey, C

A. Orthey, C. Chamzas, L. E. Kavraki, Sampling-based motion planning: A comparative review, Annual Review of Control, Robotics, and Autonomous Systems 7 (2023). 15

2023

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.

[1] [1]

B. P. Gerkey, M. J. Matari´ c, A formal analysis and taxonomy of task allocation in multi-robot systems, The International Jour- nal of Robotics Research 23 (9) (2004) 939–954

work page 2004

[2] [2]

J. K. Lenstra, D. B. Shmoys, ´E. Tardos, Approximation algo- rithms for scheduling unrelated parallel machines, Mathemati- cal Programming 46 (1990) 259–271

work page 1990

[3] [3]

Sharon, R

G. Sharon, R. Stern, A. Felner, N. R. Sturtevant, Conflict- based search for optimal multi-agent pathfinding, Artificial In- telligence 219 (2015) 40–66

work page 2015

[4] [4]

H¨ onig, S

W. H¨ onig, S. Kiesel, A. Tinka, J. W. Durham, N. Ayanian, Conflict-based search with optimal task assignment, in: Pro- ceedings of the International Conference on Autonomous Agents and Multiagent Systems (AAMAS), IF AAMAS, 2018, pp. 757– 765

work page 2018

[5] [5]

Z. Chen, J. Alonso-Mora, X. Bai, D. D. Harabor, P. J. Stuckey, Integrated task assignment and path planning for capacitated multi-agent pickup and delivery, IEEE Robotics and Automa- tion Letters 6 (3) (2021) 5816–5823

work page 2021

[6] [6]

Z. Liu, H. Wei, H. Wang, H. Li, H. Wang, Integrated task al- location and path coordination for large-scale robot networks with uncertainties, IEEE Transactions on Automation Science and Engineering 19 (4) (2021) 2750–2761

work page 2021

[7] [7]

H. W. Kuhn, The hungarian method for the assignment prob- lem, Naval Research Logistics Quarterly 2 (1-2) (1955) 83–97

work page 1955

[8] [8]

Henkel, J

C. Henkel, J. Abbenseth, M. Toussaint, An optimal algorithm to solve the combined task allocation and path finding prob- lem, in: Proceedings of IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), IEEE, 2019, pp. 4140– 4146

work page 2019