Meta-Heuristic Solver with Parallel Genetic Algorithm Framework in Airline Crew Scheduling

Abstract

Airline crew scheduling is a very important part of the operational planning of commercial airlines, but it is a linear integer programming problem with multi-constraints. Traditionally, the airline crew scheduling problem is determined by solving the crew pairing problem (CPP) and the crew rostering problem (CRP), sequentially. In this paper, we propose a new heuristic solver based on the parallel genetic algorithm and an innovative crew scheduling algorithm, which improves traditional crew scheduling by integrating CPP and CRP into a single problem. The innovative scheduling method includes a global heuristic search and an adjustment for flights and crew so as to realize crew scheduling. The parallel genetic algorithm is used to divide the population into multiple threads for parallel calculation and to optimize the randomly generated flight sequence to maximize the number of flights that meet the crew configuration. Compared with the genetic algorithm, CPLEX and Gurobi, it shows high optimization efficiency, with a time reduction of 16.57–85.82%. The experiment shows that our crew utilization ratio is higher than that for traditional solvers, achieving almost 44 flights per month, with good scalability and stability in both 206 and 13,954 flight datasets, and can better manage airline crew scheduling in times of crew scarcity.

1. Introduction

Air traffic planning plays an important role in the planning and the management of an airline [1,2,3]. With the globalization of economies and the rapid development of information and technology, the choice to travel by air and the use of airplanes as a means of transportation are becoming increasingly common today [2,4,5,6]. Before the coronavirus pandemic, air transport demand had been growing consistently. In 2019, the number of flights boarded by passenger airlines in mainland China reached 4.611 million, representing an increase of 6.1% over the previous year [7,8]. In the same year, the Boeing Company estimated that the civil aviation industry will need 790,000 new pilots in the next 20 years, with a scarcity of pilots, meaning that the number of monthly flights is projected to far outweigh the number of crew members. Therefore, it is likely that some flights will not have crew matches, which is an issue that cannot be solved in a short time because it takes an average of seven years for a general pilot to become a captain and costs between 0.2 and 1 million dollars to train an individual to this level [9,10]. Although the coronavirus pandemic has had a huge impact on the air transport industry, it is expected that air traffic will recover quickly [7,11]. The rapid increase in the demand for airline transportation and air traffic has led airline companies to use their resources more effectively, and the need for operation optimal planning has arisen [12,13,14,15,16]. Airline operation plans include a route plan [17,18], flight plan [19,20], and crew scheduling plan [21,22,23], among which crew scheduling is an important part. The aircraft and crew are two fundamental factors to consider in the operating costs of the airline industry; the flight is the direct means of income of the airline, and crew expenditures represent their second-highest source of spending after fuel costs [21,24]. Airline crew scheduling is related to the flight and crew, and it is significant in the management and decisions of commercial airlines. Therefore, how to develop a high-quality crew scheduling methodology with a limited number of crew members but a large number of flights is an important issue [25,26,27,28]. High-quality crew scheduling means a more rational crew schedule that minimizes total costs and maximizes total profitability, which is particularly important for commercial airlines to optimize their operation costs. For example, a 1% increase in flights meeting crew configurations or 1% decrease in crew scheduling equates to billions of dollars in additional profits in large commercial airlines [26,29,30,31].

Airline crew scheduling is the process of assigning flights to pilots and flight attendants within a flight plan in accordance with the relevant Civil Aviation Administration (CAA) airworthiness documents and a set of regulations set by the specific airline. The crew scheduling problem concerns the development of a crew schedule for a specific period (generally a month) under the condition that the flight information and the crew information are known; schedules should make clear when and where each crew member will perform what task in which flight so as to minimize the total cost and maximize the total profit of the flight [32]. In view of crew scarcity, the number of planned monthly flights exceeds the availability of crew members, which could lead to some flights not having a crew match, meaning that crew configuration of the flight cannot be met. In this paper, a high-quality crew scheduling method is developed to ensure as many flights as possible are made to meet the crew configuration. The airline crew scheduling problem is a constraint integer linear programming problem, which is NP-hard [33,34]. Because the flight and the crew that satisfy the constraints can be matched, the possible matching combination increases exponentially as the number of flights and crew increases. Finding a viable crew scheduling solution manually is almost impossible, leading to difficulty in finding a cost-effective solution [25,35].

In the definition of airline crew scheduling, a flight is considered as the take-off and landing of an aircraft. The tasks performed by the crew are divided into fly and deadhead. Fly refers to the crew that includes the captain or co-captain of the flight, while deadhead refers to the crew who board as passengers to take a flight to another airport to perform fly tasks. Duty consists of a series of flights (fly or deadhead) and intervals of rest. Pairing defines a series of duties and layovers that begin and end at the same base (the airport where the crew is stationed) [25]. Traditionally, the airline crew scheduling problem is divided into two sub-problems that need to be solved sequentially, namely CPP and CRP [21,36,37]. The goal of CPP is to find a feasible set of pairings that cover a given set of flights at the lowest cost [26]. CRP is the process of assigning all necessary staff members by using the pairing generated by CPP to create a work schedule for each crew member [38,39]. Alternatively, the CPP and the CRP could be integrated into a single problem [29,40,41,42].

However, traditional crew scheduling models and solvers face the following three problems:

• A higher time complexity. An NP-hard large-scale integer programming problem is decomposed into two large-scale integer programming sub-problems, resulting in almost double the time complexity [43,44,45].
• Poor generalization and reliance on the feasible sub-solutions generated by initialization. Once faced with the new flight dataset, it is necessary to create a large number of feasible sub-solutions that meet the constraints, which does not facilitate parallel calculation and consumes nearly 80% of the computation time of the total program [29,31,46].
• Due to the need to store the large number of feasible sub-solutions and branch-cut tree searches, they usually need to run on servers equipped with professional multi-core and multi-threaded CPUs, such as Intel Xeon processors [21,26].

In order to alleviate the problem of time-consuming initialization, we propose an integrated crew scheduling solver based on the parallel genetic algorithm. The randomly generated flight sequence is defined to guarantee that each flight is represented as a 0–1 independent variable. The value of each position in the flight sequence corresponding to this flight successfully matched with the crew is equal to 1; otherwise, it is 0. After four optimization processes of matching the flight with the crew, the operation of removing ‘0’, returning to base, and pairing adjustment to the flight sequence, we obtain the maximum number of flights successfully matched with a crew as the fitness value and the qualified flight sequence. The genetic algorithm [9,27,47] performs evaluation, selection, crossover and mutation for the flight sequence to calculate the optimal flight sequence. MPI is used to divide the population into multiple threads for parallel calculation [48,49]. Drift strategy performs information exchange between subpopulations in parallel calculation. We integrate the above algorithms and develop the computational framework PGAF. Based on the parallel genetic algorithm and innovative crew scheduling algorithm, our heuristic solver achieves global random search iterative optimization and parallel calculation to match and optimize flights and crew directly. Our solver avoids spending multiple hours on initialization to generate feasible sub-solutions and improves the generalization with lower time complexity and model complexity. Meanwhile, the parallel optimization efficiency depends on the number of processor cores and running memory, but it can be run on ordinary personal computers and maximizes the use of processing cores and running memory to improve optimization efficiency. Its advantages can be exploited to a greater extent in formal laboratory clusters.

The integrated crew scheduling solver with the computational framework PGAF performs a parallel calculation of innovative the crew scheduling algorithm and genetic algorithm to ensure that the number of flights that meet the crew configuration can be maximized and then improves optimization efficiency. It avoids high time complexity and model complexity, which has high generalization and is suitable for research in common experimental environment. Compared with the traditional genetic algorithm and commercial solvers, such as CPLEX and Gurobi, which are at the core of the traditional crew scheduling model, our solver reduces the computation time by 16.57–85.82% on a small-scale dataset with 206 flights. Meanwhile, a more than 45.75% reduction in calculation time is achieved on a large-scale dataset with 13,954 flights, requiring only 284.59 min. More importantly, it achieves a near−optimal flight matched percentage of 97% and higher crew utilization ratio of nearly 44 flights than traditional models with a DCA [40] and GENCOL column generation library with the commercial solver CPLEX [26], which is more suitable in solving crew scarcity and reduces crew costs.

The remainder of this paper is structured as follows. Section 2 is the literature review on airline crew scheduling. Section 3 describes the construction of the integrated airline crew scheduling model, including its assumptions, objectives and constraints. Section 4 introduces the parallel genetic algorithm in crew scheduling, including the innovative crew scheduling algorithm, genetic algorithm, MPI multi-thread parallel calculation, and drift strategy. Section 5 demonstrates the calculation results, and we provide the conclusions in Section 6.

2. Literature Review

2.1. Description of CPP and Research Results

Let F be a set of flights that are likely to be operated in a given period (usually a week or a month) and $\mathsf{\Omega }$ be the set of all feasible pairings that can be used to cover this set of flights. Let $a_f{}_p$, $f\in F$, $p\in \mathsf{\Omega }$ be a constant equal to 1 if pairing p contains flight f, and 0 otherwise. Let $c_p$ be the cost of this pairing. For each $p\in \mathsf{\Omega }$, we define $x_p$ as a binary variable with a value of 1 if pairing p is selected, and 0 otherwise. Therefore, the solution of the crew pairing problem (CPP) is usually transformed into the solution of the set-partitioning problem as follows [26,30,39,45]:

$$\sum _{p\in \mathsf{\Omega }}{c}_p{x}_p$$

(1)

$$s.t.\sum _{p\in \mathsf{\Omega }}{a}_f{}_p{x}_p=1\forall f\in F$$

(2)

$$x_p\in \left\{0,1\right\}\forall p\in \mathsf{\Omega }$$

(3)

where (1) is the objective function, (2) ensures each flight is only covered once by the pairing set exactly, and (3) enforces a binary value on whether the pairing is selected.

Frédéric Quesnel et al. [25] proposed an acceleration technique to compute high-quality solutions at the root node of the search tree. Desaulniers et al. [30] combined dynamic constraint aggregation (DCA) with column generation (CG) [45], and DCA in rolling horizon (RH) [23], which provided a wider time window and produced a better solution. In CPP instances with up to about 50,000 flights per month, the calculation time is reduced by 33% compared to traditional CG/RH, of just 60 h and 20 min. Yaakoubi et al. [50] improved the solver of Desaulniers et al. [30] by adding a dynamic control strategy to obtain an efficient solver for large-scale CPP, named Commercial-GENCOL-DCA, and used machine learning to generate high-probability consecutive executions by the same crew in the flight cluster.

2.2. Description of CRP and Research Results

Let M be the set of crew members, let B be the set of bases of the crew members, and $M_b$ be the set of crew members that belongs to base $b\in B$. Let $\mathsf{\Gamma }$ be a set of feasible pairings such that ${\displaystyle \sum _{p\in \mathsf{\Gamma }}}{a}_f{}_p=1,\forall f\in F$ (i.e., each flight is exactly covered by one pairing in $\mathsf{\Gamma }$).

For the CRP, Gamache et al. [31] introduced a column-generating method capable of solving paired instances with up to 3000 task rings in less than 4 h. Similar results were obtained by Kasirzadeh et al. [26] for paired instances containing up to 1648 mission loops and 305 crew members. Frédéric Quesnel et al. [25] developed a branch-and-price heuristic model and solved an instance with language constraints in only 6.5 h using the dataset.

2.3. The Integrated Crew Scheduling and Research Results

Traditional airline crew scheduling is divided into two sub-problems, namely CPP and CRP, and solved sequentially. In general, fully integrating these subproblems into a single operation to find a more economical plan remains a difficult issue. Therefore, improving cost-effectiveness by integrating airline crew scheduling into a single problem has been the goal of some scholars in recent years [41,51]. Papadakos first proposed several integration models for optimizing airline scheduling and solved them by applying enhanced Benders decomposition methods combined with accelerated column generation [41]. Wu considered the quality and efficiency of pairing formation in crew scheduling, and optimizes the pairing formation in terms of the airline operating cost, production schedule stability, production schedule quality, and flight time balance by using Genetic Algorithm [42]. Chen et al. proposed a multi-objective combinatorial optimization model by integrating aircraft scheduling and crew scheduling problems, and used the NSGA-II variant method combined with a repair strategy to solve the problem [24]. Liu et al. proposed an optimal solution to airline crew scheduling based on satisfiability modulo theories (SMTs), which convert various constraints in airline crew scheduling into a first-order logical formulation and solve it using the SMT solver Z3 [51].

3. Airline Crew Scheduling

3.1. Model Assumptions

In order to make airline crew scheduling more applicable and to ensure it is in compliance with the real common needs of different commercial airlines, we make the following assumptions for our crew scheduling model:

• Only pilots are considered for the crew of our model. Pilots, flight attendants, flight police, etc., are not interchangeable. However, due to the constraints and commonality of their scheduling, our crew scheduling model is equally applicable.
• Crew scheduling only considers the human resources planning, without considering airline hardware resources, such as fleet resources, ground facilities, communication and navigation facilities.
• Flight scheduling is determined without considering flight delays in our model. That is, every flight departs and arrives on time according to its schedule. All crew members work according to schedules and scheduling plans, without personal preferences, contingencies, etc.

3.2. Problem Analysis

Based on the feasible path method, $P^k$ is denoted as the flight number sequence of pilot k performing fly and deadhead. $Q^k$ is the flight number sequence of pilot k only performing deadhead. $P^k\left(m\right)$ is denoted as the flight number at the mth position in $P^k$. If pilot k performs deadhead on the flight with flight number $P^k\left(m\right)$, then $P^k\left(m\right)\in Q^k$, otherwise $P^k\left(m\right)\cap Q^k=\mathsf{Ø}$. Assuming that each flight only needs one captain and one co-captain to satisfy the crew configuration, there are $\underset{k\in NC}{\cap }{P}^k\backslash Q^k=\mathsf{Ø}$, where NC is the set of pilot.

For duty, the sequence $B^k$ is introduced to record the position, where each duty starts in $P^k$. $B^k\left(r\right)$ is denoted as the number at the rth position in $B^k$, which is the position where the rth duty starts in $P^k$; therefore, $B^k\left(r\right)\subseteq m$. We note that $B^k\left(r\right)=b_r^k$ and we know that the flight with the flight number from $P^k\left(b_r^k\right)$ to $P^k\left(b_{r+1}^k-1\right)$ in $P^k$ is a duty of pilot k; therefore, $b_1^k=1$.

When dividing the pairing for crew scheduling, the sequence $D^k$ is introduced to represent the starting position of each pairing in the duty sequence $B^k$. $D^k\left(s\right)$ is denoted as the number at the sth position in $D^k$, which is the position where the sth pairing starts in $B^k$; therefore, $D^k\left(s\right)\subseteq r$ and we define $D^k\left(s\right)=d_s^k$, so we find that the flight with the flight number from $P^k\left(B^k\left(d_s^k\right)\right)$ to $P^k\left(B^k\left(d_{s+1}^k-1\right)\right)$ in $P^k$ is a pairing of pilot k, which means that $d_1^k=1$.

3.3. Model Description

With the changing attitude toward COVID-19 in various countries and regions, the air transport industry will gradually return to normal levels [7,8,9,10,11]. In view of crew scarcity, the number of planned monthly flights exceeds the availability of crew members, which means that it is possible for some flights to not have crew matching; therefore, the necessary crew configuration of the flight cannot be met. In this paper, a high-quality crew scheduling method is developed to ensure that as many flights as possible meet the necessary crew configuration. The crew scheduling problem is transformed into the following optimization problem with constraints:

$$max{n}_F$$

(4)

According to the financial revenue of commercial airlines, the primary goal of airline crew scheduling is to maximize the number of flights that can satisfy the crew configuration in crew scarcity [52,53]. $n_F$ is the total number of flights meeting the crew configuration; therefore, our objective function is to maximize $n_F$:

$${DT}^{P^k\left(m+1\right)}-{AT}^{P^k\left(m\right)}⩾MinCT\forall k,m$$

(5)

The connection time between two adjacent flights of pilot k to have interval rest not less than $MinCT$:

$$\sum _m\sum _i{F}_i^{P^k\left(m\right)}=\sum _m\sum _i{\overline{F}}_i^{P^k\left(m\right)}\forall k,m,i$$

(6)

The constraint condition of flow conservation. ${\displaystyle \sum _m}{\displaystyle \sum _i}{F}_i^{P^k\left(m\right)}$ is used to measure the indegree of airport i in $P^k$ of pilot k; ${\displaystyle \sum _m}{\displaystyle \sum _i}{\overline{F}}_i^{P^k\left(m\right)}$ is used to measure the outdegree of airport i in $P^k$ of pilot k. According to the requirements, no aircraft will stay at airports without base attribute and they should come back to their base, so the airport’s outdegree is equal to the indegree. This ensures all aircraft and pilots eventually return to their bases:

$$\left[{DT}^{P^k\left(b_r^k\right)}\right]<\left[{DT}^{P^k\left(b_{r+1}^k\right)}\right]\forall r,k$$

(7)

Comparing the start time of two adjacent duties with their dates means they cannot be on the same day.

$${DT}^{P^k\left(b_{r+1}^k\right)}-{AT}^{P^k\left(b_{r+1}^k-1\right)}⩾MinRTbAD\forall r,k$$

(8)

The rest time between two adjacent duties of pilot k is not less than $MinRTbAD$:

$${AT}^{P^k\left(b_{r+1}^k-1\right)}-{DT}^{P^k\left(b_r^k\right)}⩽MaxDT\forall r,k$$

(9)

The maximum time of each duty of pilot k is not more than $MaxDT$:

$$\sum _{b_r^k⩽m<b_{r+1}^k}\left({AT}^{P^k\left(m\right)}-{DT}^{P^k\left(m\right)}\right)-\left({AT}^{Q^k\left(m\right)}-{DT}^{Q^k\left(m\right)}\right)⩽MaxDFT\forall r,k$$

(10)

The maximum flight time of each duty, because the time when the pilot performs deadhead belongs to the time of duty, but not the fly time of duty, has to subtract the deadhead time $\left({AT}^{Q^k\left(m\right)}-{DT}^{Q^k\left(m\right)}\right)$ on duty:

$${AT}^{P^k\left(B^k\left(d_{s+1}^k-1\right)\right)}-{DT}^{P^k\left(B^k\left(d_s^k\right)\right)}⩽MaxPT\forall s,k$$

(11)

The maximum total time of pairing is not more than $MaxPT$ in the crew scheduling:

$${DT}^{P^k\left(B^k\left(d_{s+1}^k\right)\right)}-{AT}^{P^k\left(B^k\left(d_{s+1}^k-1\right)\right)}⩾MinRTbAP\forall s,k$$

(12)

The interval rest time between two adjacent pairings of pilot k is not less than $MinRTbAP$:

$$\left[{DT}^{P^k\left(b_{r+MaxSuccOn}^k\right)}\right]-\left[{DT}^{P^k\left(b_r^k\right)}\right]\ge MaxCDD\forall r,k$$

(13)

For the upper limitation of continuous duty days, the continuous duty can only belong to the same pairing due to the limitation of the minimum rest time between pairings. For $\forall r$, if continuous duty days more than $MaxCDD$, the crew scheduling plan of this pilot does not meet the requirements.

Table 1. Variable and its explanation.

Variable	Explanation
$P^k$	the flight number sequence of pilot k performing fly and deadhead
$Q^k$	the flight number sequence of pilot k only performing deadhead
$P^k\left(m\right)$	the flight number at the mth position in $P^k$
$B^k$	the sequence of recording the position where each duty starts in $P^k$
$b_r^k$	the position of the rth duty starts in $P^k$
$D^k$	the sequence of recording the starting position of each pairing in $B^k$
$d_s^k$	the position of the sth pairing starts in $B^k$
${DT}^{num}$	departure time of the flight with flight number $num$
${AT}^{num}$	arrival time of the flight with flight number $num$
$MinRTbAD$	minimum connection time between adjacent flights
$\left[a\right]$	select the date of a
$MinCT$	minimum rest time between adjacent duties
$MaxDT$	maximum duty time
$MaxDFT$	maximum duty flight time
$MaxPT$	maximum pairing time
$MinRTbAP$	minimum rest time between adjacent pairings
$MaxCDD$	maximum continuous duty days

is a summary of the variables and their explanations mentioned in the above mathematical model:

4. The Proposed Airline Crew Scheduling with Parallel Genetic Algorithm

The mathematical model of airline crew scheduling proposed in the Section 3 is solved in this section. An innovative crew scheduling algorithm is proposed, which contains four optimization processes of matching the flight with the crew, the operation of removing ‘0’, returning to base, and pairing adjustment, to adjust the randomly generated flight sequence. After adjustment, we obtain the maximum number of the flight matched with the crew as the fitness value and the qualified flight sequence. The genetic algorithm performs evaluation, selection, crossover and mutation for the flight sequence to calculate the optimal flight sequence and maximum number of flights that meet the crew configuration. MPI is used for multi-thread parallel calculation to improve the calculation efficiency of the genetic algorithm. The drift strategy leads to the effect of information exchange between subpopulations after mutation in genetic algorithm parallel calculations. Algorithm 1 is the mathematical model for airline crew scheduling using the parallel genetic algorithm.

Algorithm 1 Heuristic crew scheduling algorithm.

1: Process data to meet input standards   2: Generate the initial population   3: Divide the subpopulation of thread   4: Match crew and flight according to flight sequence   5: Adjust the flight sequence   6: for$i=0$… do   7:       if all flights are matched or $i\ge max\_iteration$ then   8:             return flight sequence with the highest number   9:             break; 10:      else 11:           Calculate the number of flights after adjustment 12:           Perform selection, crossover, mutation 13:           Execute Drift Strategy on subpopulation 14:           Update flight sequence as new population 15:     end if 16:     $i=i+1$ 17: end for

The following section details the process of solving the model. Section 4.1 describes the preprocessing of flight data, which standardizes the flight data and crew data. Section 4.2 provides an introduction to generating the initial randomly generated flight sequence (generating initial populations) and the input of the genetic algorithm. Section 4.3 explains the process of matching the crew member and the planned flight based on the randomly generated flight sequence. Section 4.4 shows the three detailed steps used to adjust the randomly generated flight sequence, which ensures that the maximum number of flights meet the crew configuration under each flight sequence. Section 4.5 provides a description of the parallel genetic algorithm, with the construction of the genetic algorithm, MPI multi-thread parallel calculation, and drift strategy.

4.1. Data Preprocessing

Sort the planned flight data from smallest to largest by departure time. (Note: in this paper, flight rank number $rnum$ refers to the position of the sorted flight in the randomly generated flight sequence $List$ and the planned flight data $Flight$, and flight number $num$ refers to the number of each flight in $Flight$.)

Assume that there are m crew members in $Crew$, and each crew member is recorded as $cre{w}_i$. For the crew information data $Crew$, we add the following six kinds of information:

• $FD$: The list of $rnum$ performing fly and deadhead.
• H: The list of $rnum$ only performing deadhead.
• $DP$: Departure time.
• $AR$: Arrival time.
• $AIR$: The passing airport for each flight performing fly and deadhead (the first passing airport of each flight is its base).
• $DT$: Duty list.

4.2. Generate the Initial Randomly Generated Flight Sequence—Initial Population

Suppose there are n flight in $Flight$, and $List$ is the list that records whether each flight takes off, so $List$ is an n-dimensional vector. We write down the take-off situation of the ith flight in $Flight$ as $lis{t}_i$, and its value is as follows:

$$lis{t}_i=\left\{\begin{array}{cc}1,& \mathrm{the}ith\mathrm{flight}\mathrm{take}\mathrm{off}\\ 0,& \mathrm{the}ith\mathrm{does}\mathrm{not}\mathrm{flight}\mathrm{take}\mathrm{off}\end{array}\right.$$

(14)

So $List={[lis{t}_1,lis{t}_2,\dots \dots ,lis{t}_{n-1},lis{t}_n]}^T={[1,0,0,\dots \dots ,0,1,1,0]}^T$, and $List$ is the chromosome in the genetic algorithm. If 10 $List$ is required as the initial population $LIST$ in the genetic algorithm, then $LIST=\left(Lis{t}_1,Lis{t}_2,\dots \dots ,Lis{t}_{10}\right)$; its population size is $NP$ = 10. Figure 1 shows the population of the genetic algorithm.

4.3. Match the Crew and the Flight

We searched $List$ from the beginning. When the ith position in $List$ is retrieved, if $lis{t}_i$ = 0, the flight does not take off, and crew matching is not required. If $lis{t}_i$ = 1, we will verify whether the flight with $rnum$ = i can satisfy the crew configuration, and we also verify whether it is possible to find qualified crew members. The matching is based on the fact that the currently located airport of the crew member is the same as the departure airport of the flight and the crew is allowed to perform the fly task at the departure time point of the flight. If the flight cannot meet the crew configuration requirements, it is not allowed to take off and $lis{t}_i$ is changed to 0. If successfully matched, i.e., if the crew can be found to meet the crew configuration requirements, we select the crew with the lowest work cost from the crew members who meet the requirements, and update the information of the selected crew in $Crew$. The pseudo code is shown in Algorithm 2.

Algorithm 2 Match the crew and the flight.

1: $\mathrm{len}\left(Flight\right)=n$   2: for$i=1\dots \dots n$do   3:       if $List\left[i\right]=0$ then   4:             $i=i+1$   5:       else   6:             if (the set of crew meet requirements) $C=\mathsf{Ø}$ then   7:                 $List\left[i\right]=0$   8:             else   9:                 Select the crew with lowest cost in C 10:               Update these crews’ information in $Crew$ 11:           end if 12:           $i=i+1$ 13:       end if 14: end for

4.4. Adjust the Randomly Generated Flight Sequence

4.4.1. Operation of Removing ‘0’

We traversed $List$, as adjusted in Section 4.3. Suppose $lis{t}_i$ = 0, that is, the flight with $rnum$ = i does not take off. First of all, we find that the crew can match this flight from $Crew$, which is adjusted in Section 4.3. If we find out the crew requirements, we update their information.

If we cannot find out the crew match for this flight, traverse forward from the $i-1$ position of $Flight$ to find the flight from the airport with base attribute to the departure airport of this flight that meets the time requirement. Suppose that the flight with $rnum$ = j meets these requirements. Find the crew who can perform fly in the flight with $rnum$ = j and perform deadhead in the flight with $rnum$ = i from $Crew$ adjusted in Section 4.3. If the flight and the crew meeting above requirements are found, update $Crew$ and change $lis{t}_i$ to 1. If it cannot be found after the traversal is completed, the flight cannot take off.

4.4.2. Handling of Crew Returning to Base

Adjust $Crew$ for each crew member finally needs to return to their base. After successfully matching $Flight$ with $Crew$ through above operations, we also need to meet the constraint for each crew to initially depart from base and eventual return to base. We find that the final airport of some crew members is not the base they belong to in $Crew$. So we will return the unqualified crew members to their base by performing fly or deadhead tasks. Assuming that $cre{w}_i$ does not meet this requirement, the following is how to deal with it.

Solution 1: Find the flight with the closest departure time to the time point when $cre{w}_i$ is allowed to perform the task and meet the requirement that the flight that departs from the airport $cre{w}_i$ is located to his base in $List$ adjusted above. If the sign of this flight is $lis{t}_i$ = 0, $cre{w}_i$ performs the fly task on this flight and we change the sign of the flight to $lis{t}_i$ = 1. If the sign of this flight is $lis{t}_i$ = 1, then $cre{w}_i$ performs the deadhead task. Finally, update the information of $cre{w}_i$ according to the above situation.

Solution 2: If the flight in the above situation does not exist, the crew will not be able to return to his base by performing fly or deadhead. We find the last $rnum$ of $cre{w}_i$ in his $FD$ and delete all information about this flight from $cre{w}_i$, so that this flight does not meet the crew configuration. We modify $lis{t}_{rnum}$ to 0 in $List$. The information of $cre{w}_i$ is used for performing the previous flight. If the final airport of the crew at this state is the base he belongs to, the requirements are met; otherwise, we apply Solution 1.

When using Solution 2, we still cannot solve the problem of $cre{w}_i$ eventually returning to his base; repeat the solution and the worst result is that $cre{w}_i$ does not match any flight. The pseudo code of Section 4.4 is shown in Algorithm 3.

Algorithm 3 Adjust the randomly generated flight sequence.

1: $\mathrm{len}\left(Flight\right)=n$   2: $\mathrm{len}\left(Crew\right)=m$   3: for$i=1\cdots \cdots n$do   4:       if $List\left[i\right]=1$ then   5:             $i=i+1$   6:       else   7:             if (the set of crew meets requirements) $C\ne \mathsf{Ø}$ then   8:              Select the crew with lowest cost in   9:              Update these crew information in $Crew$ 10:           else 11:               $j=i-1$ 12:               while $j⩾1$ do 13:                  if $F\left[j\right]ar\_ap$ = $F\left[i\right].de\_ap$and$F\left[j\right].de\_ap\mathrm{in}base$ then 14:                    Update crew information in $Crew$ 15:                    continue; 16:                  else 17:                    $j=j-1$ 18:                  end if 19:               end while 20:           end if 21:      end if 22: end for 23: for$i=1\cdots \cdots m$do 24:      while $Crew\left[i\right].AIR\left[last\right]\ne Crew\left[i\right].base$ do 25:           for $rn=Crew\left[i\right].FD\left[last\right]\cdots \cdots n$ do 26:               if $F\left[rn\right].de\_ap=C\left[i\right].AIR\left[last\right]$ and$F\left[rn\right].ar\_ap=Crew\left[i\right].base$ then 27:                  Update these crews’ information in $Crew$ 28:                  break; 29:               end if 30:               if $rnumn$ then 31:                  Delete the last flight information of $Crew\left[i\right]$ 32:               end if 33:           end for 34:     end while 35:     $i=i+1$ 36: end for

4.4.3. Pairing Adjustment

We adjust the crew that does not meet the constraints of pairing in $Crew$ after the above operations. Each crew has a duty list $DT$, which is used to record the information of each duty. According to the constraint that both the departure and arrival airport belong to the base of the crew, $DT$ is divided into pairings, and each pairing is independent of the other. After dividing $DT$ into pairings, judge whether each pairing meets the constraints, find out whether the pairings do not meet the constraints and find the other crew members who can complete the pairings. If there are no other crew members who can complete them, this input is illegal.

4.5. Construction of Parallel Genetic Algorithm

$ThreadDIm$ threads are allocated in CPU by MPI; each thread is responsible for calculating $EachThread$ chromosomes, that is, the total population is divided into $ThreadDIm$ subpopulations. Each subpopulation contains $EachThread$ solution. On the premise that the number of cores occupied by each thread is an integer, each thread performs parallel computations on allocated cores and memory.

The fitness function of the Genetic Algorithm is $f\left(x\right)=new\_sum\left(x\right)$, and x is the randomly generated flight sequence before processing $List$. We remember the randomly generated flight sequence after it is adjusted as $List\_pr$, and the fitness function can be expressed as follows:

$$F\left(List\right)=new\_sum\left(List\right)=sum\left(List\_pr\right)$$

(15)

It is the number of 1 in $List\_pr$.

Calculate the fitness function $F_i=F\left(Lis{t}_i\right)$ and sort from large to small according to the fitness value for all chromosomes in each subpopulation $subp$. Record each maximum value $F_{Bes{t}_{subp}}$ and its chromosome $Bes{t}_{subp}$. Note the global maximum fitness value $F_{Best}=max{F}_{Bes{t}_{subp}}$ and the corresponding chromosome $Best$.

Figure 2 demonstrates the iterative process of fitness function calculation, selection, crossover and mutation in the genetic algorithm. The selection strategy of the genetic algorithm is roulette wheel selection. The probability of each chromosome in the population being selected for genetic operations is proportional to its fitness value. In crossover, we use a single-point crossover method, which obtains two different sub-chromosomes by selecting two chromosomes, dividing them at a randomly selected position, and exchanging their right part. The traditional method of single gene mutation is used in mutation.

After the above four operations are completed, we need to exchange information between each subpopulation. The drift strategy is to replace the first-to-last, second-to-last and $Exchange$-to-last solution in the subsequent $Exchage$ subpopulations with its optimal solution, respectively. Figure 3 shows the drift strategy, supposing there are a total of four subpopulations and $Exchange=3$.

For each new subpopulation obtained, if the maximum fitness value of the subpopulation $subp$ is greater than $F_{Bes{t}_{subp}}$, update $Bes{t}_{subp}$ and $F_{Bes{t}_{subp}}$; otherwise, there is no need to update $Bes{t}_{subp}$. It is the same for $F_{Best}$ and $Best$.

5. Experiments

The algorithm proposed in this paper is coded using PYTHON 3.7.6. Microsoft MPI v10.0. CPLEX 12.8.0. Gurobi 9.1.1. All experiments were executed on a computer equipped with 14-core Intel(R) Core(TM) i7-12700H CPU @ 2.3 GHz and 16 GB memory. Section 5.1 provides a description of our dataset. Section 5.2 shows the experimental results. Section 5.3 provides a comparison of experiments according to different solvers and datasets.

5.1. Dataset Description

The experimental data were derived from “Huawei Cup”, The 18th China Post-Graduate Mathematical Contest, which contains two datasets, as shown in

Table 2. Dataset description.

Dataset	Base	Duration of Schedule	Flight	Crew Member	Airport
Dataset A	1	14 days	206	21	7
Dataset B	2	31 day	13,954	465	39

.

Table 3. Parameter value of the crew scheduling.

MinCT	MaxDFT	MaxDT	MinRTbAD	MaxPT	MinRTbAP	MaxCDD
40 min	600 min	720 min	660 min	14,400 min	2 day	4 day

describes the values of parameters for the airline crew scheduling.

5.2. Experimental Results

For two datasets, random independent experiments are performed 20 times for 10 cases in which the value of 10–100% of positions is 1 in $List$; then, we take the average value of each case.

5.2.1. Dataset A Result

Figure 4 displays the experimental results of Dataset A. The left y-axis is the number of flights after adjustment and the right y-axis is the ratio of the number of flights after adjustment to the initial number of flights. When the initial number of flights taking off is increased, the number of flights after adjustment also increases, and their ratio also increases and tends to 1. The maximum number of flights after adjustment is 199, which accounts for 96.60% of the total number of flights in Dataset A.

Because the above experiments are only randomized independent experiments for 10 cases, we did not experiment with each possible initial value. We propose an assumption, which is that there is a kind of $List$ whose initial values are not all 1, but the result of $List\_pr$ is better than a case where the initial values are all 1 (assuming that all flights take off at the beginning). The number of flights satisfying the crew configuration in $List\_pr$ is greater than 199.

We use the algorithm proposed in Section 4 to retrieve and optimize $List$ and use the parallel genetic algorithm to complete the optimal value iteration. According to the changing trend of Figure 4, we set the value of 80% random position in $List$ to 1 as the chromosome of the initial population, which can accelerate the iteration and make it difficult to reach the local optimal value. After comparative experiments, we take the most stable and optimal results, in which the population is set as 40, the maximum iteration is 100, and the number of genes on the chromosome is the total number of flights, i.e., 206.

To reduce the chance of experimental results, make them more convincing and reflect the stability of our algorithm, 20 repeated experiments were performed under these parameters. We chose the average optimal value instead of the maximum optimal value as the more representative result. In order to show the superiority of the drift strategy with the subpopulation proposed in Section 4.5, we selected the fourteen-thread parallel genetic algorithm with drift strategy for iterative optimization and compared it with the traditional single-thread serial genetic algorithm without drift strategy based on the results of the following parallel calculations. Figure 5 shows the change in the optimal values in the single-thread and fourteen-thread methods. The red dots represent the change in the maximum optimal value in each iteration of the 20 repeated experiments, and the blue line represents the change in the average optimal value. (a) shows that the maximum optimal value is equal to the average optimal value, which is 206; the improvement with the single-thread serial genetic algorithm is 3.40%. The maximum optimal value converges at iteration number 69, and the average optimal value converges at iteration number 73. In contrast to (b), which uses the fourteen-thread parallel genetic algorithm with drift strategy, the optimal value for both is 206 and the improvement is also 3.40%, but the maximum optimal value converges at iteration number 52, and the average optimal value converges at iteration number 57. Clearly, the multiple-thread with drift strategy has faster convergence, which benefits from the information exchange effect between subpopulations.

We integrated the genetic algorithm and the MPI tool package in Python mpi4py into a Python tool package named PGAF (a parallel genetic algorithm framework in Python). Consequently, PGAF is a computational framework that integrates an innovative crew scheduling algorithm, traditional genetic algorithm, drift strategy, and a tool package in Python named mpi4py that acts on MPI for computer multi-thread communication. On the premise that the number of cores occupied by each thread is an integer, we have four divisions of threads, namely single-thread, double-thread, seven-thread, and fourteen-thread. Figure 6 shows the calculation time and optimization ratio under the parallel calculation of different threads.

The optimization ratio of $ThreadDIm$-thread is defined as $\frac{single\text{-}threadcalculationtime}{ThreadDIm\text{-}threadcalculationtime}$. Using MPI for the parallel genetic algorithm greatly reduces the calculation time of the traditional genetic algorithm by 1/5 and improves the efficiency of our solver in the fourteen-thread method. With the increase in the number of threads, the calculation time gradually decreases; however, due to the priority of computer memory, the ratio of optimization to the number of threads also gradually decreases.

5.2.2. Dataset B Result

Figure 7 shows the experimental results of Dataset B. When the initial number of flights that take off increases, the number of flights after adjustment also increases, but their percentage first decreases and then increases, and tends to 1. The maximum number of flights after adjustment is 13,039, which is 93.44% of the total number of flights in Dataset B.

We also make the above assumption for Dataset B. To verify this, we also use the parallel genetic algorithm to search and optimize $List$. In Figure 7, the number of flights after adjustment increases with the increase in the number of flights that take off; however, the ratio decreases first and then increases, and reaches the minimum at 0.3. It is not until ratio = 0.7 that it begins to perform better than 0.1. Therefore, a ratio below 0.7 is not ideal. So, we set the value of 70% random position in $List$ to 1 as the genetics of the initial population. Similarly, after several comparative experiments, the population is set as 60, the maximum iteration is 200, and the number of genes on the chromosome is the total number of flights, which is 13,954.

Similarly, a total of 20 repeated experiments were performed for Dataset B under the above parameters. Based on the effect of the following parallel calculations, we selected the seven-thread parallel genetic algorithm with drift strategy for iterative optimization and compared it with the traditional single-thread serial genetic algorithm without drift strategy. Figure 8 shows the change in the optimal values in single-thread and seven-thread. Similarly, the red dots represent the change in the maximum optimal value in each iteration of 20 repeated experiments, and the blue line is the change in the average optimal value. (a) shows that the maximum optimal value is 13,548 and the average optimal value is 13,480, and the error rate between the average optimal value and the maximum optimal value is 0.502%. We choose the average optimal value as the more representative result by iteration, and the improvement with the single-thread serial genetic algorithm is 3.16%. The maximum optimal value converges at iteration number 146, and the average optimal value converges at iteration number 151. Compared with (b) using the seven-thread parallel genetic algorithm with drift strategy, the maximum optimal value is 13,532, and the average optimal value is 13,496, where the improvement is 3.28% and the error rate is 0.266%. The maximum optimal value converges at iteration number 104 and the average optimal value converges at iteration number 113. Apparently, the seven-thread parallel genetic algorithm with drift strategy has higher efficiency, stability and faster convergence of airline crew scheduling optimization, which benefits from the information exchange effect between subpopulations.

Similarly, we use the PGAF encapsulated with mpi4py to perform the parallel genetic algorithm in Dataset B. The calculation time and optimization ratio are shown in Figure 9. When the number of threads is not greater than 7, the optimization ratio increases, and the calculation time decreases gradually with the increase in the number of threads. However, when the number of threads is 14, the optimization ratio is not as good as it is when fewer threads are implemented. Because of the multi-thread parallel calculation, MPI divides the CPU and running memory according to the preset thread, and the CPU and running memory of each thread are independently calculated. Since the running memory occupied by each thread is almost equal, and the total running memory of the computer is determined, the more threads there are, the less CPU and running memory they occupy. We assume there is a certain threshold that makes it impossible to support the running memory required by the program, and the running efficiency is greatly slowed down.

Although there is an inflection point of the optimization ratio in Dataset B with the increase in the number of threads, this inflection point does not appear in Dataset A. As for the mechanism of computer CPU and running memory allocation described above, the size of Dataset B is about 67.38 times that of Dataset A. According to the innovative crew scheduling algorithm in Section 4, the model complexity is $n\times {\left(logn\right)}^2$, and the required running memory is positively correlated with the complexity. Therefore, there are no inflection points in Dataset A; however, inflection points appear in Dataset B that are largely caused by the size of the dataset.

According to the experimental results of Dataset A and Dataset B, the maximum number of flights after adjustment is significantly improved by 3.40% and 3.28%, respectively, after the iterative calculation using the single-thread genetic algorithm, which is further improved when the flight matched percentage is more than 93%. More importantly, we use PGAF, a Python tool package that encapsulates the genetic algorithm and MPI, to perform the parallel genetic algorithm iterative calculation, which greatly shortens the calculation time and improves our model execution efficiency by 2.5 to 5 times. Meanwhile, the iterative convergence of parallel computation is faster, and the error rate between the average optimal value and maximum optimal value is lower and more stable.

5.3. Experiment Comparison

5.3.1. Comparison of Parallel Genetic Algorithm, CPLEX and Gurobi

We use the nonlinear integer programming solver CPLEX, large-scale mathematical programming optimizer Gurobi and the parallel genetic algorithm to solve Dataset A and Dataset B. The experimental comparison results are shown in

Table 4. Parallel genetic algorithm, CPLEX and Gurobi.

Dataset	Solver	Time (Min)	Per. of Time Reduction	Num. of Flight Matched
Dataset A	$CPLEX$	147.26	85.82%	198
	$PG{A}_1$	103.57	79.84%	206
	$Gurobi$	24.34	16.57%	206
	$PG{A}_{14}$	20.88	-	206
Dataset B	$CPLEX$	7200+	∞	-
	$PG{A}_1$	722.86	60.63%	13,480
	$Gurobi$	524.63	45.75%	13,225
	$PG{A}_7$	284.59	-	13,496

. There are more flights that meet the crew configuration in the shortest time when using the parallel genetic algorithm, while CPLEX cannot solve large-scale planning problems directly. The time complexity of Gurobi is positively related to the data size, and it does not facilitate parallel calculation. Our solver has a relative reduction of 16.57–85.82% in time consumption, and the larger the dataset, the more obvious the optimization; therefore, our solver has good scalability. The difference in the number of flights matched in different threads is caused by drift strategy, and its improvement is 0.119%.

5.3.2. Comparison with Current Research Results

The current method is to use the commercial GENCOL Column Generation Library to find the initial cluster of the pairing and then use CPLEX as the solver to optimize the pairing. Saddoune et al. [40] solved CPP and CRP with DCA. Kasirzadeh et al. [26] solved CPP and CRP with a simple preferences of up to 7765 flights and 305 crew for a large dataset.

Table 5. Results comparison.

Dataset	No. of Flight	No. of Airport	No. of Pilot	Per. of Flight Matched	Crew Utilization Ratio
$S_1$	1854	41	44	96.71%	40.75
$S_2$	5613	49	141	97.38%	38.77
$K_1$	1013	26	33	100%	30.69
$K_2$	7765	54	305	99.52%	25.45
Dataset A	206	7	8	100%	25.12 × 2
Dataset B	13,954	39	308	96.72%	43.82

shows the comparison of results between ours and theirs.

It can be seen in Table 5 that, regardless of smaller or larger datasets, our solver can achieve almost the same flight matched percentage, so it has good stability. Meanwhile, there are fewer crew members required, and our crew utilization ratio is higher, which is more favorable when faced with crew scarcity. The higher the crew utilization ratio, the less the crew is used, reducing the cost of the crew. Our model and algorithm are traditional with few parameters, no need to use some commercial solvers and computing machines with large running memory, and lower requirements on software and hardware.

6. Conclusions

We improve the traditional airline crew scheduling model by integrating the different problems into a single problem, and match the flight and crew that meet the requirements by performing local-scope optimal search and parallel calculation. A series of operations are innovatively proposed to ensure the number of flights that meet the crew configuration can be maximized. The genetic algorithm calculates the maximum number of flights that satisfy the crew configurations in each $List$ by iterating through the global search. The drift strategy provides higher efficiency, stability and faster convergence of airline crew scheduling optimization with the information exchange effect between subpopulations. Using multi-thread parallel calculation with MPI greatly reduces the calculation time, improves our solver efficiency and optimizes the high time complexity of generating initial feasible clusters in traditional methods. We integrate the innovative crew scheduling algorithm, genetic algorithm, drift strategy, and MPI into a computational framework PGAF, which is the synthesis of all algorithms and innovations in this paper. In the experimental results of Dataset A and Dataset B, the maximum number of flights after adjustment is significantly improved by 3.40% and 3.28%, respectively, with the genetic algorithm. The parallel genetic algorithm greatly shortens the calculation time and improves our model calculation efficiency by 2.5 to 5 times. Furthermore, the iterative convergence of parallel computation is faster, and the error rate between the average optimal value and maximum optimal value is lower and more stable with drift strategy. Compared with the traditional genetic algorithm, commercial solver CPLEX and Gurobi, the parallel genetic algorithm has significant optimization efficiency in terms of calculation time due to a reduction of 16.57–85.82% for time complexity and the maximum number of flights that meet the crew configuration being much higher. A comparison with the methods of the traditional model shows that our solver has good scalability and stability and that the flights-matched percentage is high and stable, of up to nearly more than 97% both in small and large datasets. Furthermore, fewer crew members are required and the crew utilization ratio is higher by our solver, achieving almost 44 flights per month; therefore, it could be universally applicable in times of crew scarcity. It has lower requirements for the software and hardware, which is more suitable for a general experimental research environment and has a strong generalization ability.

7. Discussion

Traditional airline crew scheduling is divided into two sub-problems and solved sequentially. We improve the time-effectiveness by integrating airline crew scheduling into a single problem, which has been the goal of some scholars in recent years. The experiments show that it alleviates the problem of time-consuming initialization and has a lower time and model complexity, resulting in better generalizability.

The airline crew scheduling problem is a type of resource scheduling problem. Using the solver based on the parallel genetic algorithm for an integrated solution means that the constraints of time costs of CPLEX and the commercial solver Gurobi are overcome so as to obtain a large number of feasible solutions for comparative optimization. Compared with the traditional intelligent optimization method, the genetic algorithm has the characteristics of multivariate coding processing and random optimization iteration, and parallel computing greatly shortens the total calculation time and improves the efficiency of our solver.

For MPI used in parallel calculation, if there is a laboratory cluster with multiple high-configuration hosts sharing a large running memory server, the optimization efficiency will be greatly improved.

We assume that if an airline’s scheduling is relatively stable, then we can use the machine learning method to train a scheduling prediction model that can predict the next most likely flight based on the information of the previous flight, using the scheduling of previous years as training data.