{'fraction_non_alphanumeric': 0.04943427204911304, 'fraction_numerical': 0.013420423314416247, 'mean_word_length': 3.9423178691127183, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 2, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 6, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Optimal and Bounded-Suboptimal Multi-Goal Task Assignment and Path Finding

We formalize and study the multi-goal task assignment and path finding (MG-TAPF) problem from theoretical and algorithmic perspectives. The MG-TAPF problem is to compute an assignment of tasks to agents, where each task consists of a sequence of goal locations, and collision-free paths for the agents that visit all goal locations of their assigned tasks in sequence. Theoretically, we prove that the MG-TAPF problem is NP-hard to solve optimally. We present algorithms that build upon algorithmic techniques for the multi-agent path finding problem and solve the MG-TAPF problem optimally and bounded-suboptimally. We experimentally compare these algorithms on a variety of different benchmark domains.


I. INTRODUCTION
In recent years, the multi-agent path finding (MAPF) problem [1] has been well-studied in artificial intelligence and robotics due to its many applications, such as warehouse automation [2], autonomous traffic management [3], autonomous aircraft towing [4], and video games [5]. In the MAPF problem, each agent must move from its current location to its pre-assigned goal location while avoiding collisions with other agents in a known environment.
The MAPF problem has recently been extended to many real-world settings [6], [7] where goal locations are not preassigned to agents. For example, in a modern automated warehouse, each warehouse robot needs to pick up an inventory pod from its storage location, deliver it to the inventory stations that request one or more products stored in it, and take it back to its storage location. Such automated warehouse systems often employ a task planner to determine a set of tasks consisting of a sequence of goal locations. The problem is then to assign these tasks to the warehouse robots and plan paths for them.
We thus formalize and study the multi-goal task assignment and path finding (MG-TAPF) problem, where as many tasks as agents are given and each task consists of a sequence of goal locations. The MG-TAPF problem is to compute a one-to-one assignment of tasks to agents and plan collisionfree paths for the agents from their current locations to the goal locations of their assigned tasks such that each agent visits the goal locations in the order specified by its assigned task and the flowtime (the sum of the finish times of all agents in the last goal locations of their assigned tasks) is minimized.

A. Background and Related Work
Many problems that are related to our problem have been proposed and studied in recent years. MAPF: The MAPF problem is NP-hard to solve optimally for flowtime (the sum of the finish times of all agents in the last goal locations of their assigned tasks) minimization [8] and even NP-hard to approximate within any constant factor less than 4/3 for makespan (the maximum of the finish times of all agents in their pre-assigned goal locations) minimization [9], [10]. MAPF algorithms include reductions to other well-studied optimization problems [11]- [13] and specialized rule-based, search-based and hybrid algorithms [14]- [20]. In particular, Conflict-Based Search (CBS) [19] is a popular two-level optimal MAPF algorithm that computes time-optimal paths for individual agents on the low level and performs a best-first tree search to resolve collisions among the paths on the high level. Recent research has developed several improved versions of CBS [21]- [24]. An extended version of CBS has been developed for the case where each agent has multiple pre-assigned goal locations [25]. However, the MAPF problem is insufficient for modelling real-world settings where goal locations are not pre-assigned to agents. TAPF: In the TAPF problem [26], agents are partitioned into teams and each team is given the same number of single-goal tasks as the number of agents. The objective is to assign each agent of a team exactly one task of the team and plan collision-free paths for the agents. A special case of the TAPF problem occurs when only one team exists, known as the anonymous MAPF problem. We use TAPF to denote this special case. TAPF can be solved optimally in polynomial time for makespan minimization [27]. For flowtime minimization, its complexity remains unclear, but it can be solved with an extension of CBS, called CBS with Task Assignment (CBS-TA) [28]. CBS-TA searches in the space of all possible assignments of tasks to agents using a best-first search in a forest that consists of regular CBS search trees where each tree corresponds to a different assignment. A similar version of CBS has been developed for the case where each agent can execute more than one task, but it scales to only four agents and four tasks [29]. Lifelong TAPF: Recent research has considered the online multi-agent pickup and delivery (MAPD) problem, where tasks appear at unknown times and each task consists of a sequence of two goal locations [30]. The offline MAPD problem has also been studied for the case where all tasks are known in advance [7]. The multi-goal TAPF (MG-TAPF) problem is at the crux of two lifelong problems since state-of-the-art MAPD algorithms [7], [31] essentially decompose a lifelong instance into a sequence of MG-TAPF instances. However, the MG-TAPF instances are not solved optimally in either case. Grenouilleau et al. [31] have proposed the Multi-Label Space-Time A* algorithm (MLA*), that computes a time-optimal path for an agent that visits two goal locations and solves task assignment and path finding independently. A similar lifelong problem has also been considered where each task has a temporal constraint [6]. PC-TAPF: The precedence-constraint TAPF (PC-TAPF) problem generalizes the anonymous MAPF problem [32]. It involves sequential task assignment and incorporates temporal precedence constraints between tasks, where for example, tasks A and B must be completed before task C begins. The PC-TAPF problem is NP-hard to solve for makespan minimization. A four-level hierarchical algorithm is proposed to solve it optimally. However, the lower level path planner (third and fourth level) is incomplete. So, there is no completeness guarantee for the whole algorithm.

B. Contributions
In this paper, we study the general version of the TAPF problem, where each task consists of a sequence of multiple ordered goal locations, called MG-TAPF problem.
We formalize the MG-TAPF problem as an extension of the TAPF problem that aims to minimize the flowtime. We prove that it is NP-hard to solve optimally. The proof is based on a reduction [10] from a specialized version of the Boolean satisfiability problem [33] to the MG-TAPF problem.
We present an Conflict-Based Search with Task Assignment with Multi-Label A* algorithm (CBS-TA-MLA) that solves the MG-TAPF problem optimally for flowtime minimization. CBS-TA-MLA is a hierarchical algorithm. It uses a best-first search algorithm CBS-TA [28] on the high level to search over all possible assignments of tasks to agents and resolve collisions among paths and MLA* [31] on the low level to compute a time-optimal path for each agent that visits the goal locations of its assigned task in sequence. We prove that CBS-TA-MLA is correct, complete and optimal.
We develop three admissible heuristics for the high-level search of CBS-TA-MLA based on the existing admissible heuristics [22] for CBS for the MAPF problem and generalize Multi-Valued Decision Diagrams (MDDs) from the case of one goal location to the case of multiple goal locations. We also extend CBS-TA-MLA to a bounded-suboptimal version, called ECBS-TA-MLA, using ideas from the boundedsuboptimal version of CBS [34]. We experimentally compare the proposed algorithms for a variety of benchmark domains.

II. PROBLEM DEFINITION
The MG-TAPF problem instance consists of (1) an undirected graph G = (V, E), where V is the set of locations and E is the set of unit-weight edges connecting locations, (2) m agents {a 1 , a 2 , . . . , a m }, and for each agent a i , there is a start location s i ∈ V , and (3) m tasks {g 1 , g 2 , . . . , g m }, where each task g j is characterized by a sequence of K j goal locations g j = g j [1], . . . , g j [K j ] . Each agent a i can be assigned any task g j .
Let π i (t) denote the location of agent a i at time t. A path π i = π i (0), . . . , π i (T i ), π i (T i + 1), . . . for agent a i is a sequence of locations that satisfies the following conditions: (1) The agent starts at its start location, that is π i (0) = s i ; (2) At each timestep t, the agent either moves to a neighboring location π i (t + 1) ∈ V where (π i (t), π i (t + 1)) ∈ E, or stays in its current locations, that is π i (t) = π i (t + 1); and (3) The agent visits all goal locations of its assigned task g j in sequence and remains in the final goal location at the finish time T i , which is the minimum time T i such that π i (t) = g j [K j ] for all times t = T i , . . . , ∞.
Agents need to avoid collisions while moving to their goal locations. A collision between agents a i and a j is either: (1) a vertex collision a i , a j , u, t , where two agents a i and a j are in the same location u = π i (t) = π j (t) at time t; or (2) an edge collision a i , a j , u, v, t where two agents a i and a j traverse the same edge (u, v) in opposite directions u = π i (t) = π j (t + 1) and v = π i (t + 1) = π j (t + 1) at timestep t. A plan consists of an assignment of tasks to agents and a path for each agent. A solution is a plan whose paths are collision-free. The flowtime m i=1 T i of a plan is the sum of the finish times of all agents. The problem of MG-TAPF is to find a solution that minimizes the flowtime. In this paper, we only consider the flowtime objective even though many of our results could be easily generalized to other objectives, such as makespan (the maximum of the finish times max 1≤i≤m T i of all agents) minimization.

III. COMPLEXITY
We show that the MG-TAPF problem is NP-hard to solve optimally for flowtime minimization, even when each task has only two goal locations. Similar to [10] and [35], we use a reduction from ≤3,=3-SAT [33], an NP-complete version of the Boolean satisfiability problem. A ≤3,=3-SAT instance consists of N Boolean variables {X 1 , . . . , X N } and M disjunctive clauses {C 1 , . . . , C M }, where each variable appears in exactly three clauses, uncomplemented at least once, and complemented at least once, and each clause contains at most three literals. Its decision question asks whether there exists a satisfying assignment. We first show a constant-factor inapproximability result for makespan minimization.
Theorem 1: For any > 0, it is NP-hard to find a (4/3 − )-approximate solution to the MG-TAPF problem for makespan minimization, even if each task has exactly two goal locations.
Proof: We use a reduction similar to that used in the proof of Theorem 3 in [10] to construct an MG-TAPF instance with m = M + 2N agents and the same number of tasks that has a solution with makespan three if and only if a given ≤3,=3-SAT instance with N variables and M clauses is satisfiable.
We follow the notations used in the proof of Theorem 3 in [10] and point out the differences here: For each variable X i in the ≤3,=3-SAT instance, we construct two "literal" agents a iT and a iF with start locations s iT and s iF , and two tasks g iT and g iF , each with two goal locations. We set For each clause C j in the ≤3,=3-SAT instance, we construct a "clause" agent a j with start location c j and a task g j with two goal locations g j [1] = c j and g j [2] = d j . Therefore, any optimal solution must assign every task to the agent whose start location is the first goal location of the task and let the agent execute the task.
Using the same arguments as in the proof of Theorem 3 in [10], we can show that the constructed MG-TAPF instance has a solution with makespan three if and only if the ≤3,=3-SAT instance is satisfiable, and always has a solution with makespan four, even if the ≤3,=3-SAT instance is unsatisfiable. For any > 0, any MG-TAPF algorithm with approximation ratio 4/3 − thus computes a solution with makespan three the ≤3,=3-SAT instance is satisfiable and thus solves ≤3,=3-SAT problem.
In the proof of Theorem 1, the MG-TAPF instance reduced from the given ≤3,=3-SAT instance has the property that the length of every path from the start location of every agent to the final goal location of the task assigned to the agent is at least three. Therefore, if the makespan is three, every agent arrives at the final goal location of its assigned task in exactly three timesteps, and the flowtime is 3m. Moreover, if the makespan exceeds three, the flowtime exceeds 3m, yielding the following theorem.
Theorem 2: It is NP-hard to find the optimal solution to the MG-TAPF problem for flowtime minimization, even if each task has exactly two goal locations.

IV. CBS-TA-MLA
The CBS-TA-MLA algorithm is a two-level search algorithm, where the low-level MLA* algorithm plans an optimal path for each agent based on the task assignment and the constraints provided by the high-level CBS-TA algorithm.

A. High Level: CBS-TA
Conflict-Based Search with Task Assignment (CBS-TA) is a best-first search algorithm, which was initially designed to solve the TAPF problems [28]. We extend it to solving MG-TAPF problem by replacing the low-level search algorithm with MLA*. Algorithm 1 shows the pseudo-code. CBS searches a binary tree, called constraint tree (CT), while CBS-TA searches a forest that contains multiple CTs. Each tree corresponds to a different task assignment. Each node, called CT node, in the CT contains (1) a Boolean value root, indicating whether the node is a root node of a CT; (2) an assignment, which is the task assignment of the node; (3) a set of constraints, where a vertex constraint a i , u, t prohibits agent a i from being at location u at time t and an edge constraint a i , u, v, t prohibits agent a i from moving along from u to v at timestep t; (4) a set of paths with respect to the task assignment and the constraints; and (5)   are visited in sequence while ignoring collisions with the other agents. CBS-TA starts with a single root node with the best task assignment (the task assignment with the lowest flowtime which ignoring collisions among agents). The best task assignment is calculated by applying the Hungarian method [36] to the cost matrix C. Once the task assignment is calculated, the corresponding paths of the agents are planned by the low-level MLA* search algorithm . CBS-TA then finds collisions among the planned paths, stores the number of collisions in the node and adds the node to the OPEN list [Lines [8][9]. A new root node with the next-best task assignment is created if the currently expanded node is a root node [Lines [15][16][17][18][19][20][21][22][23]. We use the next-best task assignment algorithm in [28]. See [28] for details.
CBS-TA removes a node N with the lowest cost N.cost from the OPEN list to expand (breaking ties in favor of the paths in node with the smallest number of collisions) [Lines [11][12]. First, it checks whether the number of collisions is 0. If so, N is declared a goal node, and N.assignment and N.paths are returned [Lines [13][14]. Otherwise, CBS-TA resolves an earliest vertex collision a i , a j , u, t (or edge collision a i , a j , u, v, t ) [Line 24] by generating two child nodes. Child nodes inherit the constraint set and paths from N [Lines [25][26][27][28][29]. CBS-TA adds constraint a i , u, t (or a i , u, v, t ) to the constraint set of one child node, and adds constraint a j , u, t (or a j , v, u, t ) to that of the other child node. It then calls the low-level MLA* search algorithm to replan the path of a i (or a j ) to satisfy the new constraint set.
If such a path does not exist, CBS-TA prunes the child node [Lines 30 -31]. Otherwise, CBS-TA updates the cost and the number of collisions between the newly planned path and the existing paths of the other agents and adds the child node to the OPEN list [Lines 32 -34]. Once the OPEN list is empty, CBS-TA terminates the search unsuccessfully [Line 35].

B. Low Level: MLA*
Multi-Label Space-Time A* (MLA*) finds a time-optimal path for an agent a i (a path with the smallest finish time T i ) that visits all goal locations of its assigned task g j in sequence and obeys a set of constraints. MLA* was first introduced for two goal locations [31] and then extended to more than two goal locations [37]. MLA* extends Space-Time A* [38] by adding a label indicating the different segments between the goal locations, where label k indicates that the next goal location to visit is g j [k].
We now formally describe MLA*. MLA* is an A* search whose states are tuples of a location, a time and a label. It starts with state s i , 0, 1 , indicating agent a i being at location s i at time 0 with label 1. A directed edge exists from state u, t, k to state v, t + 1, k if and only if (1) and k = k otherwise. To obey the constraints, the set of states { v, t, k | k = 1, . . . , K j + 1} is removed from the state space of agent a i if and only if there is a vertex constraint a i , v, t , and the set of edges {( u, t, k , v, t + 1, k ) | k = 1, . . . , K j } is removed if and only if there is an edge constraint a i , u, v, t . If MLA* expands a goal state g j [K j ], t, K j + 1 and the agent can stay at the goal location forever (without violating any vertex constraints), it terminates and returns the path from the start state to the goal state.
During the search, the h-value of each state v, t, k is set to dist(v, g j [k]) + Kj −1 k =k dist(g j [k ], g j [k + 1]), that is, the shortest distance from location v to visit all unvisited goal locations in task g j in sequence. The distances dist(v, g j [k]) from each location v ∈ V to all goal locations g j [k] with j = 1, . . . , m and k = 1, . . . , K j are pre-computed by searching backward once from each goal location g j [k] on graph G.

C. Properties of CBS-TA-MLA
We now show that CBS-TA-MLA is complete and optimal. Theorem 3: CBS-TA-MLA is guaranteed to find an optimal solution if the given MG-TAPF instance is solvable and correctly identifies an unsolvable MG-TAPF instance with an upper bound of O(|V | 3 · m j=1 K j ) on the finish time T i of any agent at the final goal location of its assigned task.
Proof: The proof of the optimality of CBS-TA-MLA is trivial as CBS-TA and MLA* have been proved to be optimal in [28] and [31], respectively. As for the completeness, consider an arbitrary optimal solution to the given MG-TAPF instance with paths π i . The solution can be divided chronologically into at most K = m j=1 K j segments at breakpoints t (0) = 0, t (1) , . . . , t K = max i T i where the label of at least one agent changes (because it reaches a new goal location of its assigned task) at each agent t (κ) . Since there exists a solution with at most U = O(|V | 3 ) (U is S2 ga [1] ga [2] gb [1] gb [2]   a constant depending on V only) agent movements (edge traversals) to any solvable MAPF instance [39], there exist collision-free paths for all agents with makespan at most U that move each agent a i from π(t (κ−1) ) to π(t (κ) ) and thus t (κ) − t (κ−1) ≤ U, ∀κ ≥ 1. Therefore, t (K) ≤ U · m j=1 K j . CBS-TA-MLA can thus safely prune any state whose time is larger than U · m j=1 K j on the low level and terminate on Line 35 for any given unsolvable MG-TAPF instance when OPEN eventually becomes empty in finite time.

D. Example
Consider the example in Figure 1 with two agents a 1 and a 2 located at s 1 = B1 and s 2 = A2 respectively. Two tasks g a and g b will be assigned to two agents, where g a [1] = C2, g a [2] = A2, g b [1] = B3 and g b [2] = B1. The corresponding high-level forest of CBS-TA-MLA is shown in Figure 2. The first root CT node N 1 assigns g b to a 1 and g a to a 2 . CBS-TA-MLA chooses to expand the node with the minimum cost, which is N 1 . It detects two collisions a 1 , a 2 , B2, 1 and a 1 , a 2 , B2, 3 . Since N 1 is a root CT node, the second root node N 2 with next-best task assignment g a to a 1 and g b to a 2 is created and added to the OPEN list. CBS-TA-MLA resolves the earliest collision a 1 , a 2 , B2, 1 by creating two child nodes N 3 and N 4 , where a 1 is prohibited from being in location B2 at time 1 in N 3 by adding a 1 , B2, 1 to N 3 .constraint and a 2 is prohibited from being in location B2 at time 1 in N 4 . As the low-level search can find paths for the replanned agents, both child nodes are added to the OPEN list. In the next iteration, CBS-TA-MLA picks N 2 for expansion, but does not create a root node since there are only two possible task assignments. The paths in N 2 have collisions, and thus CBS-TA-MLA generates two child nodes and adds them to the OPEN list. Then, it selects N 3 which has no collisions. So, it declares N 3 the goal node and returns the task assignment and paths.

V. EXTENSIONS OF CBS-TA-MLA
This section introduces three extensions of CBS-TA-MLA, namely an improved optimal version (with heuristics), a bounded-suboptimal version and a greedy version. CBS with heuristics [22] introduces three admissible heuristics (namely CG, DG and WDG) for the high-level search of CBS, which reduce the number of expanded CT nodes. The collisions among paths of a CT node are classified in three types [21]: cardinal collisions if both of the resulting child nodes have a larger cost than the node itself, semicardinal collisions if only one of its child nodes has a larger cost than the node itself, and non-cardinal collisions if both of the child nodes have the same cost as the node itself.
The technique to classify collisions is a Multi-Valued Decision Diagrams (MDDs) [21]. An MDD for agent a i at CT node N is a directed acyclic graph consisting of all possible cost-optimal paths of a i with respect to the task assignment and constraints of N . Each MDD node consists of a location v and a level/time t. A collision between agents a i and a j at time t is cardinal iff the contested vertex/edge is the only vertex/edge at level t of the MDDs of both agents (t = 1 in Figure 3). To make the MDDs applicable in our case in which the cost-minimal paths contain all goal locations of the assigned task in the correct sequence, we add a label to each MDD node (see Figure 3).
CG heuristic only considers the cardinal collisions among paths. DG heuristic considers the dependency among agents and WDG heuristic considers the extra cost that each pair of dependent agents contributes to the total cost. WDG dominates DG, which dominates CG. See [22] for details.
We are at most ω · f best . The FOCAL list is sorted according to some other heuristic. The FOCAL search guarantees to find solutions that are a factor of at most ω worse than optimal by always expanding the best node in the FOCAL list.
Low-level focal search: The low-level focal search prioritizes nodes in the OPEN list with f -values and nodes in the FOCAL list with the number of collisions in paths between the current agent a i and the other agents in the CT node. When it finds a solution, it returns the path and the f -value of the best node n in the OPEN list, which is the lower bound on the cost of the time-optimal path, denoted by f best (a i ).
High-level focal search: The high-level focal search sorts CT nodes in the OPEN list in increasing order of the sum of the lower bounds of all agents LB(N ) = m i=1 f best (a i ). Let N best denote the node N in the OPEN list with the minimum LB(N ). The FOCAL list contains that subset of CT nodes N with N.cost ≤ ω · LB(N best ). The nodes in the FOCAL list are sorted in increasing order of the number of collisions among N.paths. Since LB(N best ) is provably a lower bound on the optimal flowtime C * , the cost of any CT node in the FOCAL list is at most ω · C * . As a result, once a solution is found, its flowtime is at most ω · C * , so it is bounded-suboptimal with suboptimality factor ω.

C. Greedy CBS-TA-MLA (TA+CBS-MLA)
The TA+CBS-MLA performs best task assignment (TA) followed by the CBS-MLA algorithm. It starts with the root node with the best task assignment and does not generate any other root nodes. TA+CBS-MLA provides no optimality or completeness guarantee.

VI. EXPERIMENTS
This section describes our experimental results on a 2.3GHz Intel Core i5 laptop with 16GB RAM. The algorithms are implemented in Python and tested on three maps, namely (1) a dense map, which is a 20 × 20 warehouse map with 30% obstacles (Figure 4a), (2) a sparse map, which is a 32×32 random map with 10% obstacles (Figure 4b), and (3) a 32 × 32 empty map, all with a time limit of 120 seconds unless otherwise specified.

A. CBSH-TA-MLA
We evaluate CBSH-TA-MLA using two test sets. In the first set, we use the dense map with 10 agents/tasks with randomly generated locations and report the success rate, the average number of expanded CT nodes and the average runtime over 100 instances. In the second test set, we use the sparse map and the empty map and report the above three values over 50 instances with a time limit of 300 seconds. The last two values are averaged over instances    Table I shows that WDG always results in the smallest number of expanded nodes, while DG always results in the smallest average runtime on all instances. This is so because WDG needs to compute the weights of the edges of the pairwise dependency graph, which requires executing the CBS-TA-MLA algorithm for two agents repeatedly.

B. ECBS-TA-MLA
We evaluate ECBS-TA-MLA with different suboptimality factors ω on the dense and the sparse maps with different numbers of agents/tasks (for both maps) and different numbers of goal locations in each task (for the sparse map). We report the success rate, the average number of expanded CT nodes, the average runtime and the average cost over 100 instances in Table II. The last three values are averaged over instances that are successfully solved by ECBS-TA-MLA with all four ω. As expected, ECBS-TA-MLA achieves high success rates on the instances with small numbers of agents/tasks. The success rates only drop a bit with ω = 1.3 when the number of agents increases up to 30. In addition, when we increase ω, the average number of expanded CT nodes and the average runtime decrease, while the average cost increases. We test ECBS-TA-MLA when tasks have different number of goal locations with 10 agents/tasks and report the same values as in Table I in Table III. The experiment shows that, with an appropriate ω, the success rate is still over 70% within two minutes, even with a maximum of 20 goal locations per task.

C. TA+CBS-MLA
We compare TA+CBS-MLA against CBS-TA-MLA on the dense map and report the success rate, the average cost, and the average runtime with 10 agents/tasks, where each task consists of two goal locations, over 100 instances in Table IV. CBS-TA-MLA outperforms TA+CBS-MLA in the average cost, but TA+CBS-MLA outperforms CBS-TA-MLA in both the success rate and the average runtime. The reason for this is that the number of possible task assignments is large, namely 10! ≈ 3 millions, so CBS-TA-MLA spends a significant amount of time computing task assignments.

VII. CONCLUSION AND FUTURE WORK
In this paper, we presented the CBS-TA-MLA algorithm to solve the MG-TAPF problem optimally. We presented three enhanced variants of CBS-TA-MLA, namely (1) optimal variant CBSH-TA-MLA, which speeds up CBS-TA-MLA by adding a heuristic, (2) bounded-suboptimal variant ECBS-TA-MLA, which speeds up CBS-TA-MLA by using focal search and (3) greedy variant TA+CBS-MLA, which commits to the most promising task assignment without exploring other assignments. We conducted experiments to evaluate these algorithms in different settings. It is future research to incorporate additional enhancements (such as disjoint splitting for the high-level search and incremental A* for the low-level search) into CBS-TA-MLA to improve its efficiency.