 Research
 Open Access
 Published:
Performance impact of mutation operators of a subpopulationbased genetic algorithm for multirobot task allocation problems
SpringerPlus volume 5, Article number: 1361 (2016)
Abstract
Multirobot task allocation determines the task sequence and distribution for a group of robots in multirobot systems, which is one of constrained combinatorial optimization problems and more complex in case of cooperative tasks because they introduce additional spatial and temporal constraints. To solve multirobot task allocation problems with cooperative tasks efficiently, a subpopulationbased genetic algorithm, a crossoverfree genetic algorithm employing mutation operators and elitism selection in each subpopulation, is developed in this paper. Moreover, the impact of mutation operators (swap, insertion, inversion, displacement, and their various combinations) is analyzed when solving several industrial plant inspection problems. The experimental results show that: (1) the proposed genetic algorithm can obtain better solutions than the tested binary tournament genetic algorithm with partially mapped crossover; (2) inversion mutation performs better than other tested mutation operators when solving problems without cooperative tasks, and the swapinversion combination performs better than other tested mutation operators/combinations when solving problems with cooperative tasks. As it is difficult to produce all desired effects with a single mutation operator, using multiple mutation operators (including both inversion and swap) is suggested when solving similar combinatorial optimization problems.
Introduction
Multirobot task allocation (MRTA) determines the task distribution and schedule for a group of robots in multirobot systems (Gerkey and Matarić 2004). It is a constrained combinatorial optimization problem, which usually provides solutions to minimize the cost or maximize the profit while satisfying some operational constraints. MRTA problems without cooperative tasks are similar to multiple traveling salesman problems, both of them are NP (nondeterministic polynomialtime) hard optimization problems. MRTA problems with cooperative tasks are more complex and strongly NPhard (Gerkey and Matarić 2004), because each cooperative task requires at least two robots to carry it out simultaneously, which introduces both spatial and temporal constraints.
For solving an MRTA problem, the first important thing is to understand what the tasks are. In general, tasks in an MRTA problem can be classified into singlerobot tasks and multirobot tasks (Gerkey and Matarić 2004). A singlerobot task is carried out by a single robot. A multirobot task requires multiple robots to perform, which is also referred to as cooperative task. Tasks vary in different practical applications. Moreover, the problem complexity increases with the number of robots required for each cooperative task.
In the industrial plant inspection, two types of the inspection tasks exist according to the measurement method and detection sensors (Bonow and Kroll 2013; Ordoñez Müller and Kroll 2013): singlerobot tasks and tworobot tasks (cooperative tasks, each of which requires two robots to carry out simultaneously). This paper aims at developing an efficient algorithm to solve the multirobot tasks allocation problems for the industrial plant inspection.
The contributions of this paper include: (1) the development of the subpopulationbased genetic algorithm, this algorithm employs mutation operators and elitism selection in each subpopulation, and can solve the multirobot tasks allocation problems for industrial plant inspection efficiently; and (2) the recommendation of mutation operators for solving multirobot task allocation problems and similar optimization problems, i.e., using multiple mutation operators (including both inversion and swap) is suggested.
Background
Related works on multirobot task allocation problems
To find good solutions efficiently for multirobot task allocation problems, many approaches have been developed, such as genetic algorithms (Jones et al. 2011; Liu and Kroll 2012a), hybrid genetic algorithms (Liu and Kroll 2015; Ni and Yang 2012), auctionbased algorithms (Das et al. 2015), behaviorbased algorithms (Butler and Hays 2015), negotiationsbased approaches (Rossi et al. 2015). Some of them can solve MRTA problems both without and with cooperative tasks, but some only can solve problems without cooperative tasks.
Goldberg et al. (2003) proposed a distributed layered architecture for multirobot systems. This architecture includes three layers: planning layer, executive layer, and behavior layer. In the planning layer, a marketbased approach was developed to allocate tasks. Based on the market economy, Dias (2004), Zhang and Parker (2013) developed TraderBots and IQASyMTRe. Cicirello and Smith (2001, 2002) presented a decentralized mechanism for coordinating factory operations in behavioral models. Similar behaviorbased algorithms include ALLIANCE (Parker 1998) and BLE (Werger and Matarić 2000). These methods can quickly deal with new tasks and dynamic environmental information during execution. Different from distributed/decentralized methods mentioned above, this paper focuses on centralized approaches and aims at providing the optimal solution for multirobot task allocations with cooperative tasks.
Related works on genetic algorithms
A genetic algorithm (GA) (Mitchell 1998) is a centralized heuristic method inspired by biological evolution. It is widely used for optimization and search problems because of its simplicity, high flexibility in problem modeling, and good global search capability. Many genetic algorithms have been developed to solve optimization problems in computational science, engineering, economics, and other fields. For example, in engineering applications, genetic algorithms have been used to solve the design of roof structures (Kociecki and Adeli 2014), assembly problems (Akpınar and Bayhan 2011), and industrial plant inspection planning problems (Liu and Kroll 2012a).
Selection, crossover, and mutation operators maintain the population diversity (Mc Ginley et al. 2011), and also influence the performance of genetic algorithms. Therefore, many efforts have been devoted to the design of these operators; for example, a new selection strategy based on population recombination and elitist refinement (Kwak and Lee 2011), a twopart chromosome crossover operator (Yuan et al. 2013), and a greedy sub tour mutation operator (Albayrak and Allahverdi 2011) have been developed to improve the efficiency of genetic algorithms. Crossover and mutation are the main search operators of genetic algorithms. They play different roles in genetic algorithms: crossover tends to preserve the features of the parents, while mutation tends to make some small local perturbation of individuals. Compared to crossover, mutation is usually considered as a secondary operator with a low probability in standard genetic algorithms (Holland 1992). This could be due to the fact that a large mutation rate would make genetic algorithms to search randomly. However, many studies have shown that genetic algorithms without crossover can perform better than standard genetic algorithms, if mutation is combined with an effective selection operator (Fogel and Atmar 1990; Liu and Kroll 2012b; Osaba et al. 2014; Walkenhorst and Bertram 2011).
Mutation is carried out with a single parent and plays an important role in increasing the population diversity. Various mutation operators have been developed for different solution representations: bit inversion mutation for binary coding (Holland 1992); swap, insertion, inversion and displacement for permutation coding (Larrañaga et al. 1999); Gaussian mutation (Sarangi et al. 2015), polynomial and power mutation for real coding (Deb and Deb 2012; Deep and Thakur 2007). Some mutation operators are problemdependent, such as greedy sub tour mutation for traveling salesman problems (Albayrak and Allahverdi 2011) and energy mutation for multicast routing problems (Karthikeyan et al. 2013). Some studies suggest a mutationcombination (Deep and Mebrahtu 2011) or selfadaptive mutation operators (Hong et al. 2000; Mc Ginley et al. 2011; Serpell and Smith 2010). The performance of different mutation operators highly depends on the parameter choice of genetic algorithms (Brizuela and Aceves 2003; Osaba et al. 2014; Wang and Zhang 2006) and the type of problems (Hasan and Saleh 2011; Karthikeyan et al. 2013). Most of related work studied problems without cooperative tasks, such as traveling salesman problems (Albayrak and Allahverdi 2011; Deep and Mebrahtu 2011) and flow shop scheduling (Nearchou 2004; Wang and Zhang 2006). In this paper, the performance of mutation operators will be analyzed when solving multirobot task allocation problems without or with cooperative tasks.
Permutation coding is used to represent solutions in this paper, which will be illustrated in section “Methods”. As a natural coding, permutation representation is widely used for many search and optimization problems, such as traveling salesman problems, vehicle routing problems, job scheduling problems, task assignment problems. Permutation problems can be classified into three types according to what influences solution fitness (Cicirello 2015, 2016; Cicirello and Cernera 2013; Hernando et al. 2016; Schiavinotto and Stützle 2007; Sörensen 2007; TayaraniN. and PrügelBennett 2014): Apermutation (absolute element positions most impact fitness), Rpermutation (relative ordering most impacts fitness), and Ppermutation (elements’ precedence impacts fitness). Cicirello (2016) theoretically analyzed the performance of several common mutation operators on different permutation problems. Multirobot task allocation problems studied in this paper are blendedpermutation problems as both task assignments among robots and task scheduling for each robot impact the fitness. The performance of different mutation operators on solving these problems will also be analyzed in this paper.
Multirobot task allocation problems for industrial plant inspection
Characteristics of tasks
This paper studies the problem of multirobot task allocation for industrial plant inspection, and the target scenarios are derived from a tank farm of a petroleum refinery (Fig. 1). To detect gas and fluid leakages in this refinery, remote sensing is usually used (Bonow and Kroll 2013; Ordoñez Müller and Kroll 2013). This applied sensing technology requires an active sensor and a diffuse reflecting background, and they are located in different positions within their measurement range. If the surface of a target object can be used as a reflecting background, only one robot with an active sensor is required to detect the leakage of this target object; otherwise, two robots (one robot with an active sensor and the other assistant robot with a special retroreflector (Ordoñez Müller and Kroll 2014) are required. This results in two types of tasks: single and tworobot tasks. Each singlerobot task is performed by one robot with an active sensor at an inspection position. Each tworobot task is carried out by two distinct robots at two inspection positions simultaneously. Multirobot task allocation for inspection problems with cooperative tasks (tworobot tasks) introduces spatial and temporal constraints: spatial constraints, tasks must be executed by robots each from specific inspection position; temporal constraints, each cooperative task requires two robots to carry out at the very same time.
Figures 2 and 3 display the simulation environments of two inspection problems with cooperative tasks, which are derived from “Area 1” and “Area 2” of Fig. 1, respectively. Both inspection problems are accomplished by 3 mobile robots. The inspection time of the robots at inspection positions (marked with diamonds) is determined by the diameters of target objects. All robots can move freely outside the inadmissible zones and obstacles (marked with rectangles). Each pair of diamonds linked by a bold dashed line defines the two inspection positions of a tworobot task (cooperative task). The other diamonds represent inspection positions of singlerobot tasks.
Assumptions of the problem
This paper focuses on strategic planning that makes decisions on allocating tasks to robots, and does not respond to unplanned events such as robot collisions or road blocks that can be handled during tactical planning. The multirobot task allocation problems studied in this paper are performed based on the following assumptions. (1) All robots are identical and start at the same time. (2) All robots start from their home bases that are predefined, and end at their home bases after finishing their assigned tasks. Between performing any two tasks, robots do not move back to their home bases. (3) Each singlerobot task is assigned to one robot, while each cooperative task is assigned to two robots. Based on the described characteristics and assumptions of the multirobot task allocation for inspection problems, the time of each robot finishing its assigned tasks includes three parts: the traveling time, the inspection time of each task, and the waiting time occurring when performing cooperative tasks. In this work, the traveling time is calculated using a modified A* algorithm (Liu 2014) that corrects infeasible paths caused by the standard A* algorithm (Hart et al. 1968). The inspection time is predefined according to the inspection method and measurement system properties. The waiting time depends on the solution itself and is calculated for each solution candidate during the execution of the genetic algorithm.
Objective and constraints
The objective of multirobot task allocation problems is usually to minimize the total mission cost due to energy consumption, completion time, and/or traveled distance. Shorter duration of inspecting a plant permits a higher frequency of repetition of the inspections, and also may reduce costs of the inspection. Therefore, the objective of multirobot task allocation problems in this paper is to find the optimal solution \(\mathbf A _{opt}\) that requires the minimal completion time (the time span between the first robot starting its work and the last robot finishing its tasks). \(\mathbf A _{opt} \in \mathbb {A}\), \(\mathbb {A}\) is the set of all admissible solutions of the task allocation problem.
Formally, given a set of \(N^R\) identical robots \(R=\{R_k \vert k\in \{1,2,\ldots ,N^R\}\}\) and a set of \(N^T\) tasks \(T=\{T_l \vert l\in \{1,2,\ldots ,N^T\}\}\), the completion time (fitness value) J of each admissible solution \(\mathbf A \in \mathbb {A}\) can be represented as
where \(\mathbf A =\{A_k \vert k\in \{1,2,\ldots ,N^R\}\}\) denoted as a set of \(N^R\) vectors, \(A_k\) is the task sequence of robot \(R_k\) and denoted as a vector, and \(C_k (A_k )\) is the time of robot \(R_k\) required to finish all assigned tasks according to the sequence \(A_k\). As we assume that all robots start at the same time, the completion time is the maximal/longest value of operation times of all robots in the system.
For task allocation problems with only singlerobot tasks, instead of \(\mathbf A\) in Eq. (1), each admissible solution is denoted as \(\mathbf A ^S = \{A_k^S \vert k\in \{1,2,\ldots ,N^R\}\}\) that has to satisfy the following constraint:
The task sequence of the kth robot assigned d tasks is denoted as \(A_k^S=\{a_1^k,a_2^k,\ldots ,a_d^k\}\); each element in \(A_k^S\) represents a task \(T_l\). Equation (2) ensures that every task is executed only once. In case of problems without cooperative tasks, the time \(C_k (A_k ^S)\) of robot \(R_k\) finishing all assigned tasks includes the traveling time from the home base of \(R_k\) to the first task \(a_1^k\), the sum of the traveling time of all pair of assigned tasks \(\left( a_i^k \hbox { and } a_{i+1}^k, k\in \{1,2,\ldots ,d1\}\right)\), the traveling time for returning from the last task \(a_d^k\) to the home base of \(R_k\), and the sum of the inspection time of all tasks assigned to \(R_k\).
For task allocation problems with cooperative tasks, each singlerobot task is denoted as a subtask \(T_l=t_l\) and each cooperative task (tworobot task) is denoted as two subtasks \(T_l=(t_{l1},t_{l2})\), all subtasks would form a set \(P=\{P_i \vert i\in \{1,2,\ldots ,N^P\}\}\), i.e.,
\(N^P=N^T+N^{co}\), \(N^{co}\) is the number of cooperative tasks. Instead of \(\mathbf A\) in Eq. (1), each admissible solution is denoted as \(\mathbf A ^C=\{A_k^C \vert k\in \{1,2,\ldots ,N^R\}\}\) that has to satisfy the following constraint:
with \(i,k\in \{1,2,\ldots ,N^R\}\). Where each element in \(A_k^C\) represents a subtask \(P_i\). Subtasks assigned to the same robot are performed sequentially, while subtasks assigned to different robots are performed in parallel. The constraint (4) ensures that each subtask is executed only once. In case of problems with cooperative tasks, the time \(C_k \left( A_k ^C\right)\) of robot \(R_k\) finishing all assigned tasks includes the traveling time from the home base of \(R_k\) to its first task, the sum of the traveling time between two assigned tasks, the traveling time for returning from the last task to the home base of \(R_k\), the sum of the inspection time of all tasks assigned to \(R_k\), and the waiting time for carrying out cooperative tasks.
In addition, the following three executability constraints (EC) must also be satisfied to ensure that the task allocation \(\mathbf A ^C\) of problems with cooperative tasks is feasible for execution:

(EC1)
Each cooperative task is carried out by two different robots.

(EC2)
Two subtasks of each cooperative task are started at the same time.

(EC3)
When two robots are scheduled to carry out a cooperative task, all tasks that are assigned to both robots before this cooperative task have to be executable and finished.
Methods
A subpopulationbased genetic algorithm is developed to solve the multirobot task allocation problems with cooperative tasks in this section. At the beginning of this section, the solution representation is introduced. After that, the implementation of the proposed genetic algorithm is illustrated. At the end, the subpopulationbased and standard genetic algorithms (Beyki and Yaghoobi 2015; Larrañaga et al. 1999; Pandey et al. 2016) are compared.
Solution representation
Many coding strategies have been proposed to represent solutions, e.g., permutation, adjacency, ordinal coding (Larrañaga et al. 1999). Permutation coding is used to represent a solution in this paper because: (1) it is the most natural and readable way to represent a task sequence; (2) it can be easily implemented in the most commonly used programming languages such as MATLAB or C/C++. Based on the permutation coding, the taskbased coding is designed to solve multirobot task allocation with cooperative tasks. This coding strategy will not create infeasible solutions and a genotype corresponds to just one phenotype. In the following part, the encoding and the decoding of this coding strategy are illustrated, respectively.
Encoding (Genotype) The genotype of a solution represents the task sequence of each robot and consists of two parts:

A chromosome is a string of genes and represents the sequence of all \(N^T\) tasks. Each gene represents a task and is denoted as an integer in the range of \([1,N_T]\). Each chromosome consists of \(N^T\) distinct integers in the range of \([1,N_T]\).

A geneapportion is a set of \(N^R1\) distinct integers in the range of \([1,N_T1]\), which splits a chromosome into \(N^R\) parts for \(N^R\) robots.
The genotypes represent the initial allocation that each task is assigned to one robot and robot coalitions of cooperative tasks have not yet built. Genetic operators are applied to the genotypes of solutions not phenotypes of them. Both the chromosome and geneapportion of each genotype in the initial population is generated at random. For example, Fig. 4a shows an example problem where six singlerobot tasks (\(T_1T_5,T_8\)) and two cooperative tasks (\(T_6,T_7\)) will be carried out by three robots. In this example, \(T_6=(P_6,P_9)\) and \(T_7=(P_7,P_8)\), that is, the set of 10 subtasks \(P=\{P_1,P_2,P_3,P_4,P_5,P_6,P_7,P_8,P_9,P_{10}\}\). The subtasks and costs are listed in Tables 1, 2, 3, and 4. As each task is encoded as one gene, the genotype of a solution candidate can be represented as shown in Fig. 4c: the chromosome consists of 8 distinct integers in the range of [1, 8], e.g., \(\{1,2,3,4,5,6,7,8\}\); this chromosome is split into three segments by a geneapportion \(\{3,6\}\) that is represented as two vertical lines. The phenotype and schedule corresponding to this genotype is shown in Fig. 4d, the strategy of decoding genotypes is detailed in the following parts.
Decoding (Phenotype) The phenotypes represent complete feasible task allocations including the distribution and the sequence of all subtasks. The completion time of each solution candidate is calculated according to its phenotype not genotype. In a genotype, each cooperative task is only assigned to one robot, thus the other robot is required to carry out this task simultaneously. A genotype is decoded as a phenotype via two steps:

(1)
For singlerobot tasks, each gene is directly decoded as its corresponding task; see Fig. 5a.

(2)
For cooperative tasks, two subtasks of each cooperative task should be decoded. The main idea of the following decoding is to minimize the waiting time. According to the genotype, it is obvious that each cooperative task is already assigned to a robot \(R_k\), e.g. \(T_6\) is assigned to \(R_k =R_2\). Hence, the next step is to find the second robot \(R_s\) so that two robots can carry it out cooperatively (satisfying the constraint EC1). For each cooperative task \(T_l=(P_\alpha ',P_\beta ')\) that is carried out by robot \(R_k\) after finishing \(P_\gamma\) according to the genotype of an individual, the decoding process is:

(S1)
One subtask of \(T_l =(P_\alpha ',P_\beta ')\), which is closest to robot \(R_k\) when it finishing \(P_\gamma\), is denoted as \(P_\alpha\); the other subtask of \(T_l\) is denoted as \(P_\beta\). That is, \(P_\alpha\) must satisfies \(c_{\alpha \gamma k}^t \le c_{\beta \gamma k}^t\), where \(c_{ijk}^t\) is the traveling time of robot \(R_k\) from one subtask \(P_i\) to another subtask \(P_j\). Subtask \(P_\alpha\) is assigned to robot \(R_k\) after finishing \(P_\gamma\).

(S2)
Subtask \(P_\beta\) is inserted at the “best” position of the task sequences of robots \(R_s\in (R \backslash R_k)\) to satisfy the constraint EC1. Denoting \(\tau _i ^a\) as the arriving time of a robot at \(P_i\), the waiting time must be \(c^w=\left \tau _\alpha ^a  \tau _\beta ^a \right\) to satisfy the constraint EC2. If \(\tau _\alpha ^a < \tau _\beta ^a\), robot \(R_k\) waits for \(c^w\) at the inspection position of \(P_\alpha\) until robot \(R_s\) arrives at the inspection position of \(P_\beta\); otherwise robot \(R_s\) waits for \(c^w\) at the inspection position of \(P_\beta\) until robot \(R_k\) arrives at the inspection position of \(P_\alpha\). The “best” position is the position that provides the least waiting time for performing this cooperative task, which is calculated by enumerating all possible positions of the task sequences of robots \(R_s\). To satisfy the constraint EC3, this decoding is carried out starting from the cooperative task that a robot meets first, so that all decoded phenotypes are feasible for execution. The steps of this decoding are:
(S2.1) Calculate the arriving time \(\tau _\alpha ^a\) for all cooperative tasks denoted as a set \(T^T\);
(S2.2) Sort \(T^T\) in ascending order by \(\tau _\alpha ^a\);
(S2.3) For the first cooperative task of \(T^T\), insert its \(P_\beta\) to all possible positions and calculate \(c^w\); find the best position that provides the minimal \(c^w\); insert \(P_\beta\) to the best position, delete this cooperative task from \(T^T\), recalculate \(\tau _\alpha ^a\).
(S2.4) Repeat (S2.2)–(S2.3) until all cooperative tasks are decoded.
For instance, the decoding outcome of the step “S1” is shown in Fig. 5b: \(P_6\) is assigned to \(R_2\) because \(c_{562}^t<c_{592}^t\); \(P_7\) is assigned to \(R_3\) after leaving its home base (denoted as “0”) because \(c_{073}^t<c_{083}^t\). The decoding outcome of the step “S2” is shown in Fig. 5c, d. Possible positions are marked as “active” (denoted as “1”), whereas impossible positions are marked as “inactive” (denoted as “0”). The decoding algorithm first finds the “best” position for \(P_9\) because robot \(R_2\) meets task \(T_6\) earlier than robot \(R_3\) meets task \(T_7\), i.e., \(\tau _6 ^a < \tau _7 ^a\) (\(\tau _i^a\) means the arrival time of a robot at the inspection position of \(P_i\)). There are seven possible positions for decoding \(P_9\) except positions of robot \(R_2\), but only five positions will be tested: for \(R_1\), all four positions are tested; for \(R_3\), only the position before \(P_7\) is tested because \(P_7\) belongs to another cooperative task, which is performed in order to satisfy the constraint EC3. As \(P_9\) being inserted before \(P_7\) provides the minimum waiting time, \(R_2\) is waiting for \(c_{62}^w = \tau _9^a  \tau _6^a = 0.6\) at \(P_6\) until \(R_3\) arrives at \(P_9\) such that robots \(R_2\) and \(R_3\) can cooperatively perform \(T_6\) (satisfying the constraints EC1 and EC2). In order to satisfy the constraint EC3, positions of chromosomes before either \(P_6\) or before \(P_9\) are marked as “inactive”; see Fig. 5c. Therefore, only five active positions can be tested when decoding the next cooperative task \(P_8\) (see Fig. 5d). Before assigning \(P_8\), the arriving time of \(R_3\) at \(P_7\) is recalculated, \(\tau _7^a = 25.4\). The minimum waiting time \(c^w=0\) can be obtained when \(P_8\) is inserted after \(P_6\). That is, \(R_2\) arrives at \(P_8\) and \(R_3\) arrives at \(P_7\) at the same time. The complete task allocation obtained using this decoding requires robots \(R_2\) and \(R_3\) as a coalition to execute \(T_6\) and \(T_7\) as shown in Fig. 5d. Based on the solution expression in section “Related works on multirobot task allocation problems”, the solution in Fig. 5 is denoted as \(\mathbf A ^C=\left\{ A_1^C,A_2^C,A_3^C\right\} = \{\{P_1,P_2,P_3\}, \{P_4,P_5,P_6,P_8\},\{P_9,P_7,P_{10}\}\}\).

(S1)
As illustrated above, this decoding can satisfy all executability constraints, i.e., all decoded phenotypes are feasible for execution.
Using this representation, each individual (solution candidate) includes a genotype and a phenotype. In the proposed genetic algorithm, the chromosomes of the genotypes are mutated for generating offspring; phenotypes are used to calculate the completion time.
Process of the developed genetic algorithm
The developed genetic algorithm in this paper is based on subpopulations. The main idea of this algorithm is that selection and genetic operators are applied separately in each subpopulation. Elites selection is based on the fitness of individuals in a subpopulation not in the whole population, thus more elites including both global elites and local elites will be kept in the new generation. These elites avoid losing the best found solution and local optimal solutions. The pseudo code of our proposed subpopulationbased genetic algorithm is presented in Algorithm 1.
Parameters Parameters of the genetic algorithm are set at the beginning, such as population size (\(pop\_siz\)), subpopulation size (\(pop\_sub\)), elite count (\(eli\_cnt\)), mutation probability (\(p_m\)), and termination criterion (\(gen\_num\)).
Initial population The initial population is randomly produced based on the permutation coding, that is, both the chromosome and geneapportion of each genotype in the initial population are generated at random based on encoding strategy.
Fitness calculation All genotypes should be decoded as phenotypes according to the decoding procedure before fitness calculation. The fitness of each individual means the completion time that is calculated according to the fitness function (1).
New population As can be seen from Algorithm 1, a new population is generated based on subpopulations. First, the whole population is randomly divided into nonoverlapping subpopulations, and each subpopulation involves \(pop\_sub\) individuals. After that, the elitism selection and mutation operators are applied to each subpopulation. The \(eli\_cnt\) superior individuals are transferred to the new population, and the \(best\_num\) superior individuals are selected as parents. The \(pop\_subeli\_cnt\) offspring are produced by mutating parents and generating new geneapportions:

The chromosome of a new offspring is produced by swap, insertion, inversion, or displacement mutation. Swap mutation exchanges two randomly selected genes. Insertion mutation moves a randomly chosen gene to another randomly chosen place. Inversion mutation reverses a randomly selected gene string. Displacement mutation inserts a random string of genes in another random place. Insertion can be considered as a special displacement.

The geneapportion of a new offspring is generated with a probability \(p_a\); otherwise, the geneapportion of the parent is kept for the offspring. A geneapportion is defined by \(N^R1\) integers. Each element in a new geneapportion is generated by rounding a number that is randomly selected within the range of \([1,N^T]\) according to a standard normal distribution (\(\mu , \sigma ^2\)). \(\mu\) is the cumulative average of the geneapportion of the best individual obtained in each previous generation; \(\sigma =0.03 \times N^T\) is used in this paper. This geneapportion procedure will choose numbers that are near to the cumulative average, with a higher probability.
Termination criterion The genetic algorithm is terminated when the number of generations reaches a predefined number of generations (\(gen\_num\)) in this paper. Both the population size and the number of generations are fixed in the simulation studies, i.e., the number of all produced individuals is constant. There are many alternative choices of the termination criterion, e.g. a maximal number of generations, CPU time limit, and fitness limit/stall. In this paper, a fixed number of generations is used because (1) CPU time highly depends on the computer hardware, (2) what is a good fitness value is unpredictable, and (3) the convergence properties highly depend on the initial population and the individual run of the genetic algorithm.
Comparison of the subpopulationbased genetic algorithm and standard genetic algorithms
The main difference between the subpopulationbased genetic algorithm and standard genetic algorithms (Beyki and Yaghoobi 2015; Larrañaga et al. 1999; Pandey et al. 2016) is the way of producing offspring. We compare the subpopulationbased genetic algorithm with standard genetic algorithms with tournament selection (see Algorithm 2) (Beyki and Yaghoobi 2015; Pandey et al. 2016), as the selection strategy of the subpopulationbased genetic algorithm is similar to tournament selection.
Selection First, elites keeping in the new generation are different: a number of superior individuals in the whole population are selected in standard genetic algorithms, while elites in each subpopulation are chosen in the subpopulationbased genetic algorithm. The subpopulationbased genetic algorithm can keep both the current best solution and the local optima that may avoid the population being dominated by a fewer “super” individuals. Second, tournament selection is performed in the whole population randomly, while parents are selected from each nonoverlapping subpopulation in the subpopulationbased genetic algorithm. Parents from nonoverlapping subpopulations are distributed evenly in the solution space of the current population, which may avoid keeping too many better/worse individuals or missing some local optima.
Crossover and mutation Both crossover and mutation are used to produce offspring in standard genetic algorithms, while only mutation operator is used in the proposed genetic algorithm. The \(best\_num\) superior individuals in each subpopulation are mutated, while the rest is not used to produce offspring. \(pop\_subeli\_cnt\) offspring in each subpopulation are generated by mutation with a probability of \(p_m=1\). Note that, \(p_m=1\) does not mean a random search because: the mutation operator is performed in each subpopulation, and \(eli\_cnt\) superior individuals in each subpopulation are kept in the new generation without mutation.
Time complexity The procedure of generating a new population in standard genetic algorithms is more complex than that in the proposed subpopulationbased genetic algorithm. The time complexity of the selection in standard genetic algorithms is \(O(pop\_sizeli\_cnt)\), because \(pop\_sizeli\_cnt\) parents are selected. As illustrated above, the time complexity of the selection in the subpopulationbased genetic algorithm is \(O(best\_num \cdot pop\_siz/pop\_sub)\). The time complexity of swap is O(1) as it is independent of the chromosome length. The time complexity of insertion, inversion, and displacement is \(O(N^T)\) as in the worst case all genes have to be changed. Many crossover alternatives such as partially mapped crossover (PMX) (Goldberg and Lingle 1985), position based crossover, order crossover, and cycle crossover have been proposed for permutation representation. The work of Larrañaga et al. (1999) shows that order crossover is the best crossover and PMX is the fastest crossover when solving smallscale traveling salesman problems. The work of Mudaliar and Modi (2013) shows that PMX is the best crossover when solving traveling salesman problems. The performance of different crossover highly depends on problems. Taking PMX as an example, the mapping relationship between selected numg genes from each pair of parents should be built to legalize the offspring. The time complexity of PMX is \(O(numg+N^T)\) in the worst case: all numg genes should be mapped from one parent to the other and all genes have to be changed.
Results
In this section, the performance of the proposed genetic algorithm is analyzed when solving multirobot task allocation problems without/with cooperative tasks. Four problems are tested in the simulation studies:

Prob.A involves 90 singlerobot tasks that are distributed in rows; its inspection area is similar to that shown in Fig. 2 but all tasks are singlerobot tasks.

Prob.B involves 100 singlerobot tasks that are distributed in islands; its inspection area is similar to that shown in Fig. 3 but all tasks are singlerobot tasks.

Prob.C involves 80 singlerobot tasks and 5 cooperative tasks, and all tasks are distributed in rows; see Fig. 2.

Prob.D involves 90 singlerobot tasks and 5 cooperative tasks, and all tasks are distributed in islands; see Fig. 3.
Prob.A and Prob.B are multirobot task allocation problems without cooperative tasks. Prob.C and Prob.D are multirobot task allocation problems with cooperative tasks. These scenarios have been used as test cases already in Liu (2014), Liu and Kroll (2015) to compare the performance of different encoding and decoding strategies.
In the experiments, each tested genetic algorithm is performed with a population size of \(pop\_siz=200\) and the number of generations chosen as \(gen\_num=10^4\). To statistically evaluate the performance of the proposed genetic algorithm, 20 independent runs of each algorithm are implemented on an Intel Core i3 PC with 3.2 GHz, 8 GB (RAM), Windows 7 Professional, MATLAB R2011b. More runs could provide more accurate results but require more CPU time. Hence, 20 independent runs are carried out to restrict the computational effort, and analysis of variance (ANOVA) is used to check whether the performance differences (solution quality) between the different genetic algorithms are statistically significant. If the value of the significance level is smaller than 0.05, the effects of genetic algorithms are assessed to be statistically significant at a level of confidence of 95 %.
Experiment 1: Subpopulationbased versus binary tournament GA
The first experiment compares the performance of the subpopulationbased genetic algorithm with a standard genetic algorithm with binary tournament selection. The frameworks of both genetic algorithms are displayed in Algorithm 1 and Algorithm 2 in section “Methods”, and the parameters of two genetic algorithms are listed in Table 5. Inversion mutation is used in both genetic algorithms because it performs better than other mutation operators when solving Rpermutation problems (Cicirello 2016), such as TSP (Albayrak and Allahverdi 2011; Deep and Mebrahtu 2011; Liu and Kroll 2012b) and flow shop scheduling (Wang and Zhang 2006). As discussed in section “Comparison of the subpopulationbased genetic algorithm and standard genetic algorithms”, a standard genetic algorithm with tournament selection and partially mapped crossover (PMX) is compared with the proposed genetic algorithm because (1) tournament selection is similar to our proposed selection and (2) tournament selection and PMX performs well when solving similar problems (Beyki and Yaghoobi 2015; Mudaliar and Modi 2013; Pandey et al. 2016; Taplin et al. 2005).
The experimental results are recorded in Table 6, which indicate that the proposed subpopulationbased genetic algorithm provides better solutions and requires less CPU time than the tested binary tournament genetic algorithm. An ANOVA test shows that the differences in the solution quality between these two genetic algorithms are statistically significant. Randomly choosing 5 from the 20 runs of each genetic algorithm, the solution quality (completion time) of the best solution candidate in each generation is shown in Fig. 6. It is obvious that the subpopulationbased genetic algorithm converges significantly faster than the tested binary tournament genetic algorithm within the first 1000 generations.
This experiment indicates that the proposed genetic algorithm based on subpopulations performs better than the tested binary tournament genetic algorithm with PMX crossover when solving multirobot task allocation problems, especially when requiring less CPU time and a fewer generations.
Experiment 2: Subpopulationbased GA with single mutation operator
The second and the third experiments analyze the effects of the subpopulationbased genetic algorithm with different mutation operators and their combinations. Swap, insertion, inversion, and displacement mutation operators are investigated in this paper. The tested subpopulationbased genetic algorithms are listed in Table 7.
The second experiment tests the performance of the subpopulationbased genetic algorithms with a single mutation operator (GA1–GA4 in Table 7); each mutation operator produces \(pop\_subeli\_cnt=8\) offspring in each subpopulation. The results are shown in Fig. 7. An ANOVA test shows that: (1) inversion (GA3) performs significantly better than the other three mutation operators when solving Prob.A and Prob.B; (2) the differences in the solution quality are not statistically significant when using swap, inversion, and displacement to solve Prob.C and Prob.D.
Experiment 3: Subpopulationbased GA with multiple mutation operators
The third experiment analyzes the performance of the subpopulationbased genetic algorithms with multiple mutation operators (GA5–GA8 in Table 7). Each mutation operator in GA5–GA7 produces 4 offspring in each subpopulation by repeated application; each mutation operator in GA8 produces 2 offspring in each subpopulation; all mutation operators are applied in parallel. Inversion is combined with the other mutation operators in this experiment, because it performed well in the second experiment. The experimental results are displayed in Fig. 8. An ANOVA test shows that: (1) the differences in the solution quality between GA5–GA8 are not statistically significant when solving Prob.A and Prob.B; (2) GA5 and GA8 can provide significantly better solutions than GA6 and GA7 when solving Prob.C and Prob.D.
The results of all tested subpopulationbased genetic algorithms listed in Table 7 are shown in Fig. 9 and Table 8. GA3, GA5, and GA8 can provide better solutions than the other genetic algorithms. An ANOVA test shows that: (1) the differences in the solution quality using GA3, GA5, GA6, GA7, and GA8 are not statistically significant when solving Prob.A and Prob.B; (2) GA5 and GA8 perform significantly better than the other tested genetic algorithms when solving Prob.C and Prob.D.
The implementation of the subpopulationbased genetic algorithm and test results for solving Prob.C is available as Additional file 1.
Discussion
Experimental results show that inversion performs well when solving multirobot task allocation problems without cooperative tasks, which is similar to the study of solving traveling salesman problems (Albayrak and Allahverdi 2011; Deep and Mebrahtu 2011; Liu and Kroll 2012b). The swap and inversion combination performs well when solving multirobot task allocation problems with cooperative tasks, which could be due to the fact that they can improve solution candidates with crossed paths effectively.
In general, it is difficult to find the best mutation operator that could produce all desired effects. The influences of mutation operators vary in different genetic algorithms and in solving different problems. According to what most influences solution fitness, permutation problems were be classified into three major types (Cicirello 2015, 2016; Cicirello and Cernera 2013; Sörensen 2007). Cicirello (2016) theoretically analyzed the performance of several common mutation operators on different permutation problems, and suggested swap for most Apermutation problems and inversion for Rpermutation problems with undirected edges.
Multirobot task allocation problems studied in this paper are blendedpermutation problems, as both task assignments among robots and task scheduling for each robot impact the fitness. Therefore, the performance of mutation operators should be analyzed based on specific permutation problems.
In industrial plant inspection problems, good task allocations usually do not include crossed paths or only include a few crossed paths. Figure 10a shows an example where one cross may occur. Transforming permutation \(\{1,5,4,3,2,6\}\) (Fig. 10a) into \(\{1,2,3,4,5,6\}\) (Fig. 10b) needs at least: one inversion, that is, inverting \(\{5,4,3,2\}\); or two swaps, that is, swaping \(\{5\}\) and \(\{2\}\), then swaping \(\{4\}\) and \(\{3\}\); or three insertions/displacements, that is, inserting \(\{2\}\), \(\{3\}\), \(\{4\}\) before \(\{5\}\) sequentially. Figure 11a shows another example where two crosses may occur. Transforming permutation (a) to (b) in Fig. 11 needs at least: one swap, that is, swapping \(\{1\}\) and \(\{6\}\), see Fig. 11b; two inversions/insertions/displacements, see Fig. 11c, d. These two examples imply that proper swap is more efficient than inversion in case of many crossed paths. On the contrary, inappropriate swap produces worse solutions than inversion, e.g. swap produces two crosses, while inversion produces one cross in Fig. 12. Therefore, inversion can obtain better results than swap if given a large number of generations.
For mutation combinations, it is difficult to analyze which is the only operator that guides the evolutionary search, because: (1) an operator cannot guarantee to produce better offspring than parents; and (2) the best individual in \(n+1\) generation may not be generated by mating the best individual in n generation. Although there are no significant differences between results of GA5 and GA8, it cannot indicate that insertion and displacement mutation operators have no effect on the evolutionary search. Therefore, it cannot be said that one specific mutation operator is the best. Based on the experimental results, multiple mutation operators (including both inversion and swap) is suggested when solving similar combinatorial optimization problems.
Conclusion
The problem complexity significantly increases if cooperative tasks are involved because they introduce additional spatial and temporal constraints. To solve the multirobot task allocation problems without/with cooperative tasks for industrial plant inspection, a subpopulationbased genetic algorithm is developed. The proposed subpopulationbased genetic algorithm using just inversion mutation and selection obtains better solutions than the tested binary tournament genetic algorithm with partially mapped crossover (PMX) and inversion mutation. This provides the possibility of crossoverfree genetic algorithms. Succeeding, the impact of four mutation operators and four mutation operator combinations in the subpopulationbased genetic algorithm is analyzed to find suitable mutation operators for multirobot task allocation problems. The results indicate that inversion mutation performs well when solving problems without cooperative tasks, and the swapinversion combination performs well when solving problems with cooperative tasks. As it is difficult to produce all desired effects with a single mutation operator, using multiple mutation operators (including both inversion and swap) is suggested when solving similar combinatorial optimization problems.
References
Akpınar S, Bayhan GM (2011) A hybrid genetic algorithm for mixed model assembly line balancing problem with parallel workstations and zoning constraints. Eng Appl Artif Intell 24(3):449–457. doi:10.1016/j.engappai.2010.08.006
Albayrak M, Allahverdi N (2011) Development a new mutation operator to solve the traveling salesman problem by aid of genetic algorithms. Exp Syst Appl 38(3):1313–1320. doi:10.1016/j.eswa.2010.07.006
Beyki M, Yaghoobi M (2015) Chaotic logic gate: a new approach in set and design by genetic algorithm. Chaos Solitons Fractals 77:247–252. doi:10.1016/j.chaos.2015.05.032
Bonow G, Kroll A (2013) Gas leak localization in industrialenvironments using a TDLASbased remote gas sensor and autonomousmobile robot with the TriMax method. In: IEEE international conference on robotics and automation (ICRA 2013), Piscataway, NJ:IEEE Press, Karlsruhe, Germany, pp 987–992
Brizuela CA, Aceves R (2003) Experimental genetic operators analysis for the multiobjective permutation flowshop. In: Fonseca C, Fleming P, Zitzler E, Thiele L, Deb K (eds) Evolutionary multicriterion optimization, lecture notes in computer science, vol 2632. Springer, Berlin, pp 578–592. doi:10.1007/3540369708_41
Butler Z, Hays J (2015) Task allocation for reconfigurable teams. Robot Auton Syst 68:59–71. doi:10.1016/j.robot.2015.02.001
Cicirello VA (2015) On the effects of windowlimits on the distance profiles of permutation neighborhood operators. In: 8th International conference on bioinspired information and communications technologies (formerly BIONETICS), ICST. doi:10.4108/icst.bict.2014.257872
Cicirello VA (2016) The permutation in a haystack problem and the calculus of search landscapes. IEEE Trans Evol Comput 20(3):434–446. doi:10.1109/TEVC.2015.2477284
Cicirello VA, Cernera R (2013) Profiling the distance characteristics of mutation operators for permutationbased genetic algorithms. In: The 26th Florida Aatificial intelligence research society conference, St. Pete Beach, USA, pp 46–51. http://www.aaai.org/ocs/index.php/FLAIRS/FLAIRS13/paper/view/5841/6040
Cicirello VA, Smith S (2001) Randomizing dispatch scheduling policies. In: The 2001 AAAI fall symposium: using uncertainty within computation
Cicirello VA, Smith S (2002) Distributed coordination of resources via wasplike agents. In: The first NASA goddard/JPL workshop on radical agent concepts (WRAC)
Das GP, McGinnity TM, Coleman SA, Behera L (2015) A distributed task allocation algorithm for a multirobot system in healthcare facilities. J Intell Robot Syst 80(1):33–58. doi:10.1007/s1084601401542
Deb D, Deb K (2012) Investigation of mutation schemes in realparameter genetic algorithms. In: Panigrahi B, Das S, Suganthan P, Nanda P (eds) Swarm, evolutionary, and memetic computing, lecture notes in computer science, vol 7677. Springer, Berlin, pp 1–8. doi:10.1007/9783642353802_1
Deep K, Mebrahtu H (2011) Combined mutation operators of genetic algorithm for the travelling salesman problem. Int J Combin Opt Probl Inf 2(3):1–23
Deep K, Thakur M (2007) A new mutation operator for real coded genetic algorithms. Appl Math Comput 193(1):211–230. doi:10.1016/j.amc.2007.03.046
Dias MB (2004) TraderBots: a new paradigm for robust and efficient multirobot coordination in dynamic environments. PhD thesis, Carnegie Mellon University
Fogel DB, Atmar J (1990) Comparing genetic operators with gaussian mutations in simulated evolutionary processes using linear systems. Biol Cybern 63:111–114
Gerkey BP, Matarić MJ (2004) A formal analysis and taxonomy of task allocation in multirobot systems. Int J Robot Res 23(9):939–954
Goldberg D, Cicirello V, Dias M, Simmons R, Smith S, Stentz A (2003) Marketbased multirobot planning in a distributed layered architecture. In: Multirobot systems: from swarms to intelligent automata: proceedings from the 2003 international workshop on multirobot systems, pp 27–38
Goldberg DE, Lingle R (1985) Alleles, loci, and the traveling salesman problem. In: Grefenstette JJ (ed) Proceedings of the 1st international conference on genetic algorithms and their applications. Lawrence Erlbaum Associates, Publishers, Los Angeles, pp 154–159
Hart PE, Nilsson NJ, Raphael B (1968) A formal basis for the heuristic determination of minimum cost paths. IEEE Trans Syst Sci Cybern 4(2):100–107. doi:10.1109/TSSC.1968.300136
Hasan BHF, Saleh MSM (2011) Evaluating the effectiveness of mutation operators on the behavior of genetic algorithms applied to nondeterministic polynomial problems. Informatica 35(4):513–518
Hernando L, Mendiburu A, Lozano JA (2016) A tunable generator of instances of permutationbased combinatorial optimization problems. IEEE Trans Evol Comput 20(2):165–179. doi:10.1109/TEVC.2015.2433680
Holland JH (1992) Adaptation in natural and artificial systems. MIT Press, Cambridge
Hong TP, Wang HS, Chen WC (2000) Simultaneously applying multiple mutation operators in genetic algorithms. J Heuristics 6(4):439–455. doi:10.1023/A:1009642825198
Jones EG, Dias MB, Stentz A (2011) Timeextended multirobot coordination for domains with intrapath constraints. Auton Robots 30(1, SI):41–56. doi:10.1007/s1051401092023
Karthikeyan P, Baskar S, Alphones A (2013) Improved genetic algorithm using different genetic operator combinations (GOCs) for multicast routing in ad hoc networks. Soft Comput 17(9):1563–1572. doi:10.1007/s0050001209764
Kociecki M, Adeli H (2014) Twophase genetic algorithm for topology optimization of freeform steel spaceframe roof structures with complex curvatures. Eng Appl Artif Intell 32:218–227. doi:10.1016/j.engappai.2014.01.010
Kwak NS, Lee J (2011) An implementation of new selection strategies in a genetic algorithm—population recombination and elitist refinement. Eng Opt 43(12):1367–1384. doi:10.1080/0305215X.2011.558577
Larrañaga P, Kuijpers CMH, Murga RH, Inza I, Dizdarevic S (1999) Genetic algorithms for the travelling salesman problem: a review of representations and operators. Artif Intell Rev 13(2):129–170. doi:10.1023/A:1006529012972
Liu C (2014) Multirobot task allocation for inspection problems with cooperative tasks using hybrid genetic algorithms. PhD thesis, Department of Measurement and Control, Mechanical Engineering, University of Kassel. http://nbnresolving.de/urn:nbn:de:hebis:342014101646126
Liu C, Kroll A (2012a) A centralized multirobot task allocation for industrial plant inspection by using A* and genetic algorithms. In: 11th International conference on artificial intelligence and soft computing (ICAISA 2012). Heidelberg, Dordrecht. Lecture notes in computer science, vol 7268, pp 466–474
Liu C, Kroll A (2012b) On designing genetic algorithms for solving small and mediumscale traveling salesman problems. In: International symposium on swarm intelligence and differential evolution (SIDE 2012). Heidelberg, Dordrecht. Lecture notes in computer science, vol 7269, pp 283–291
Liu C, Kroll A (2015) Memetic algorithms for optimal task allocation in multirobot systems for inspection problems with cooperative tasks. Soft Comput 19(3):567–584. doi:10.1007/s0050001412740
Mc Ginley B, Maher J, O’Riordan C, Morgan F (2011) Maintaining healthy population diversity using adaptive crossover, mutation, and selection. IEEE Trans Evol Comput 15(5):692–714. doi:10.1109/TEVC.2010.2046173
Mitchell M (1998) An introduction to genetic algorithms. MIT Press, Cambridge
Mudaliar DN, Modi NK (2013) Unraveling travelling salesman problemby genetic algorithm using mcrossover operator. In: Bala GJ, Hemanth DJ, Jeyasingh R (eds) International conference on signal processing, image processing and pattern recognition (ICSIPR2013). IEEE electron devices Soc; Minist Def, Def Res and DevOrganisat; Institut Elect and Telecommunicat Engineers (IETE); SciRes Grp Egypt (SRGE); Egypt IRSS Rough Set Chapter; Sci and Engn ResSupport Soc (SERSC), pp 127–130, International Conference onSignal Processing, Image Processing and Pattern Recognition(ICSIPR), Karunya Univ, Sch Elect Sci, Dept Elect & Commun Engn,Coimbatore, INDIA, FEB 07–08, 2013
Ordoñez Müller A, Kroll A (2013) Effects of beam divergence in handheld TDLAS sensors on long distance gas concentration measurements. In: International workshop on advanced infrared technology and applications (AITA 2013), Turin, Italy, vol 12, pp 9–13
Ordoñez Müller A, Kroll A (2014) On the use of cooperativeautonomous mobile robots and optical remote sensing in inspectionrobotics. In: Automation 2014, Baden–Baden, Germany, pp 847–864
Nearchou AC (2004) The effect of various operators on the genetic search for large scheduling problems. Int J Prod Econ 88(2):191–203. doi:10.1016/S09255273(03)001841
Ni J, Yang SX (2012) A fuzzylogic based chaos GA for cooperative foraging of multirobots in unknown environments. Int J Robot Autom 27(1):15–30. doi:10.2316/Journal.206.2012.1.2063553
Osaba E, Carballedo R, Diaz F, Onieva E, de la Iglesia I, Perallos A (2014) Crossover versus mutation: a comparative analysis of the evolutionary strategy of genetic algorithms applied to combinatorial optimization problems. Sci World J. doi:10.1155/2014/154676
Pandey HM, Shukla A, Chaudhary A, Mehrotra D (2016) Evaluation of genetic algorithm’s selection methods. In: Satapathy SC, Mandal JK, Udgata SK, Bhateja V (eds) Information systems design and intelligent applications, Anil Neerukonda Inst Technol and Sci, Det CSE; ANITS CSI Student Branch, Advances in Intelligent Systems and Computing, vol 434, pp 731–738. doi:10.1007/9788132227526_72. 3rd International conference on information system design and intelligent applications (INDIA), ANITS Campus, Visakhapatnam, INDIA, JAN 08–09, 2016
Parker LE (1998) ALLIANCE: an architecture for fault tolerant multirobot cooperation. IEEE Trans Robot Autom 14:220–240
Rossi C, Aldama L, Barrientos A (2015) Simultaneous task subdivision and allocation using negotiations in multirobot systems. Int J Adv Robot Syst 12
Sarangi A, Lenka R, Sarangi SK (2015) Design of linear phase firhigh pass filter using PSO with gaussian mutation. In: Swarm, evolutionalry, and memetic computing, Bhubaneswar, India, pp 471–479
Schiavinotto T, Stützle T (2007) A review of metrics on permutations for search landscape analysis. Comput Oper Res 34(10):3143–3153. doi:10.1016/j.cor.2005.11.022. http://www.sciencedirect.com/science/article/pii/S0305054805003746
Serpell M, Smith JE (2010) Selfadaptation of mutation operator and probability for permutation representations in genetic algorithms. Evol Comput 18(3):491–514. doi:10.1162/EVCO_a_00006
Sörensen K (2007) Distance measures based on the edit distance for permutationtype representations. J Heuristics 13(1):35–47. doi:10.1007/s1073200690013
Taplin JHE, Qui M, Salim VK, Han R (2005) Costbenefit analysis and evolutionary computing: optimal scheduling of Interactive Road Projects. Edward Elgar Publishing, Massachusetts, USA
TayaraniN MH, PrügelBennett A (2014) On the landscape of combinatorial optimization problems. IEEE Trans Evol Comput 18(3):420–434. doi:10.1109/TEVC.2013.2281502
Walkenhorst J, Bertram T (2011) Multikriterielleoptimierungsverfahren für pickupanddeliveryprobleme. In:Proceedings of 21. Workshop computational intelligence, Dortmund, Germany, pp 61–76
Wang L, Zhang L (2006) Determining optimal combination of genetic operators for flow shop scheduling. Int J Adv Manuf Technol 30(3–4):302–308. doi:10.1007/s0017000500821
Werger B, Matarić MJ (2000) Broadcast of local eligibility:Behaviorbased control for strongly cooperative robot teams. In: Proceedings of the 4th international conference on autonomous agents. ACM Press, New YorkS, pp 21–22
Yuan S, Skinner B, Huang S, Liu D (2013) A new crossover approach for solving the multiple travelling salesmen problem using genetic algorithms. Eur J Oper Res 228(1):72–82. doi:10.1016/j.ejor.2013.01.043
Zhang Y, Parker L (2013) IQASyMTRe: forming executable coalitions for tightly coupled multirobot tasks. IEEE Trans Robot 29(2):400–416
Authors' contributions
CL and AK designed the algorithm. CL implemented the algorithm. CL and AK analysed the experimental results and wrote this manuscript. Both authors read and approved the final manuscript.
Acknowlegements
This work was supported by the scholarship awarded by the China Scholarship Council (CSC), the Completion Scholarship awarded by the University of Kassel (Abschlussstipendien für Promovierende der Universität Kassel), and the Fundamental Research Funds for the Central Universities (2016RC29), which are greatly acknowledged.
The author declares that this paper has been posted as arXiv:1606.00601.
Competing interests
The authors declare that they have no competing interests.
Author information
Additional file
40064_2016_3027_MOESM1_ESM.zip
Rights and permissions
Open Access This article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.
About this article
Received
Accepted
Published
DOI
Keywords
 Multirobot task allocation
 Genetic algorithms
 Constrained combinatorial optimization
 Mutation operators
 Subpopulation