Flight Schedule Problem Optimization Based on Discrete Memory-Enhanced Restructured Particle Swarm Optimization Algorithm

Abstract

Flight Schedule Problem optimization is a typical NP-hard combinatorial optimization problem that is challenging to solve using traditional algorithms, so metaheuristic algorithms are commonly adopted for such problems. This paper proposes a Discrete Memory-Enhanced Restructured Particle Swarm Optimization algorithm (DMERPSO) to address Flight Scheduling Problem optimization. Firstly, this paper designs a hybrid particle encoding scheme capable of simultaneously handling flight time adjustments (integer variables) and route selections (categorical variables) for the Flight Schedule Problem. Secondly, a new update equation of particle positions is provided based on probability selection within the three terms of the Memory-Enhanced Restructured Particle Swarm Optimization (MERPSO) algorithm, and the calculation of the selection probability is designed. Thirdly, the two strategies and perturbation terms of MERPSO are improved in order to be adapted to optimize the discrete Flight Schedule Problem. Finally, simulation experiments are conducted using DMERPSO based on real flight data from multiple Chinese airports with the objective of minimizing total flight delays, leading to better solutions that are faster than various benchmark algorithms. The DMERPSO algorithm exhibits significant advantages in reducing total delays, improving solution stability, and enhancing robustness, which validates that DMERPSO provides an effective new approach for solving Flight Schedule Problem optimization problems.

1. Introduction

Flight Schedule Problem optimization is aimed at efficiently allocating resources, such as aircraft and crews, in order to enhance overall efficiency, which represents a complex combinatorial optimization problem constrained by aircraft routes, runway slot capacities, and turnaround requirements [1]. Traditional methods for solving the Flight Schedule Problem rely primarily on mathematical programming and precise algorithms [2]. The classical paradigm of traditional Flight Schedule Problem optimization is centered on mathematical programming, particularly relying on Mixed-Integer Linear Programming (MILP) to construct precise deterministic models [3]. This paradigm rigorously formulates objective functions—such as maximizing the total operational profit or minimizing overall costs—alongside a set of hard constraints [4]. Because the Flight Schedule Problem is an NP-hard problem, solving it primarily depends on exact algorithms such as branch-and-bound [5] and branch-and-price [6]. The branch-and-price algorithm decomposes the problem into a master problem (selecting optimal flight strings/crew pairings) and pricing subproblems (generating new feasible task columns within resource-constrained networks), thereby effectively handling large-scale combinatorial spaces. The seminal work of Barnhart et al. [7] systematically established this framework, laying the algorithmic foundation for theoretical research on core issues such as fleet assignment and crew scheduling. However, pure methods of this kind often face computational intractability when addressing ultra-large-scale problems, multi-stage integration or dynamic stochastic disruptions. In response, current research frontiers focus on enhancing the scalability and practicality of the traditional paradigm through several key avenues [8,9,10]. These innovations allow the traditional cornerstone of mathematical programming to sustain its vitality, offering interpretable and high-performance solutions for complex scheduling problems through integration with modern computational intelligence.

However, with the increase in the scale of the Flight Schedule Problem, these traditional algorithms have become computationally impractical. To overcome the computational bottlenecks of traditional methods, both academic and industrial communities commonly employ metaheuristic algorithms to obtain high-quality approximate optimal solutions, which demonstrate strong compatibility with the large-scale and high-dimensional characteristics of Flight Schedule Problem optimization problems [11,12]. Metaheuristic algorithms have emerged as a significant computational paradigm in modern combinatorial optimization and have been widely and successfully applied in the field of Flight Schedule Problem [13]. Their core advantages lie in their strong generality, low dependency on specific problem structures, and their ability to effectively explore vast solution spaces. For example, the Genetic algorithm approach was used to build feasible daily schedules and assign optimal aircraft for hub-and-spoke airlines [14]; Ant Colony Optimization mimics the pheromone communication of ants to find optimal paths through positive feedback, making it particularly suitable for flight string or aircraft routing optimization [15]; and Tabu Search utilizes memory structures to avoid cyclical searching, which has been successfully applied to flight schedule development, tail assignment, and crew scheduling [16].

The Particle Swarm Optimization (PSO) algorithm is a metaheuristic approach which is characterized by its conceptual simplicity, fast convergence speed, and strong global search capability, and has demonstrated significant potential in solving complex optimization problems [17]. However, when addressing Flight Schedule Problem optimization involving numerous discrete variables and complex multimodal search spaces, the standard PSO algorithm’s inherent “global best” guidance mechanism often leads to premature loss of population diversity, thereby trapping the algorithm in local optima—a phenomenon known as “premature convergence”. To address these limitations, researchers have explored algorithmic improvements through two primary approaches, for example, integrating PSO with neighborhood search [18].

In recent years, the Restructured Particle Swarm Optimization (RPSO) algorithm was developed based on the linear system theory of PSO, which kept the optimization performance alongside algorithmic simplicity [19]. RPSO simplified a standard PSO framework by designing a new particle position updating formulation with convergent term and perturbation term, introduced novel search mechanisms [20]. RPSO has relatively good convergence theoretical support and is simple and easy to use. However, RPSO loses the population’s memory, including the historical positions and fitness information of the particles. A variant of RPSO was designed, the memory-enhanced reconfigured particle swarm algorithm (MERPSO), which uses an experience selection strategy and a block search strategy to store the memory, constructing two new learning samples to replace the original learning samples so to balance local development and global exploration [21].

However, the original RPSO algorithm was primarily designed for continuous optimization problems, whereas Flight Schedule Problem optimization involves discrete decision variables. Its reliance on a single global best still risks premature convergence, particularly in highly multimodal problems such as Flight Schedule Problem optimization. This paper presents a discretized RPSO by transforming the variant of RPSO, the MERPSO algorithm, into a Discrete Memory-Enhanced Restructured Particle Swarm Optimization algorithm (DMERPSO), which is then applied to solve single-objective Flight Schedule Problem optimization. Experimental results demonstrate significant improvements in both computational efficiency and solution reliability. The main contributions of this work are as follows:

(1)

The deep analysis of the model of Flight Schedule Problem optimization is conducted so that a complete flight route can be mathematically described. For the Flight Schedule Problem optimization model to be solved by the RPSO algorithm, the decision variables affecting flights are obtained and the equation of particle expression is designed. A hybrid particle encoding scheme capable of simultaneously handling integer-type (adjustment time) and categorical-type (route selection) decision variables is designed.

(2)

A probability-based discrete position update formula is developed, enabling particles to probabilistically select between “exploitation” samples (sg), “exploration” samples (mp), and random perturbation terms (dt) to achieve balanced trade-offs between exploitation and exploration in discrete solution spaces.

(3)

The core learning strategies are restructured through discretization: the “mean” operation in continuous EDS was transformed into a “voting/majority rule” mechanism for discrete EDS; the “hyper-rectangular block” structure in continuous BSS was reformulated into adaptive “integer interval blocks” and “discrete set blocks” suitable for different variable types, while preserving its core concept of dynamic splitting and merging.

2. Memory-Enhanced Restructured Particle Swarm Optimization Algorithm

This section first introduces the standard Particle Swarm Optimization (PSO) algorithm and its significant variant—Restructured Particle Swarm Optimization (RPSO). Then, it elaborates on how the Memory-Enhanced Restructured Particle Swarm Optimization (MERPSO) algorithm significantly improves performance by incorporating the memory-enhancement mechanisms of three terms: “experience selection”, “block search” and “random perturbation”.

2.1. Restructured Particle Swarm Optimization (RPSO)

PSO was inspired by the foraging behavior of bird flocks in 1995 [22]; the classical equations for updating velocity and position are as the Equations (1) and (2):

$$v_{id}(t+1)=w.v_{id}(t)+c_1{r}_1(pbes{t}_{id}(t)-x_{id}(t))+c_2{r}_2(gbe{s}_d(t)-x_{id}(t))$$

(1)

$$x_{id}(t+1)=x_{id}(t)+v_{id}(t+1)$$

(2)

where pbest is the particle’s own historically optimal position and gbest is the globally best-known position of the entire swarm; $v_{id}(t)$ and $x_{id}(t)$ represent the velocity and position of particle i in the d-th dimension during the t-th iteration, respectively; w denotes the inertia weight; c₁ and c₂ are learning factors; r₁ and r₂ are random numbers uniformly distributed within [0, 1]. The PSO is highly susceptible to premature convergence toward a non-global optimal gbest, leading to diversity loss and entrapment in local optima [23].

Based on the results of linear system theoretical analyses of PSO, the Restructured Particle Swarm Optimization (RPSO) algorithm was proposed [19,20], which employs only a single position update equation, as shown in Equation (3):

$$x_{i+1}=c_r\times pb\mathrm{e}st+(1-c_r)gbest+G(t)$$

(3)

where c_r represents the acceleration coefficient, a random number within the interval [0, 1], and G(t) denotes the perturbation term that can be designed by the user. For instance, the calculation method for G(t) was formulated as in Equation (4) [19]:

$$G(t)=(s\times r_3)\times (0.8+\omega )\times (1-{\displaystyle \frac{t}{T}})$$

(4)

Here, s is set to one-quarter of the problem search range, r₃ is a random number within the interval [−1, 1], ω is similar to the inertia weight of the PSO algorithm, with its value linearly decreasing between 0.2 and 0.8, t denotes the current iterating generation, and T signifies the maximum iteration. The RPSO algorithm simplifies the parametric structure and directly “restructures” new particle positions, wherein each particle has a certain probability of either learning from the global best particle (gbest) and the personal best particle (pbest) to take on the exploitation, while G(t) controls the exploration which is set by the designer.

2.2. Memory-Enhanced Restructured Particle Swarm Optimization (MERPSO)

RPSO remains dependent on the single gbest. Therefore, if gbest is trapped in a local optimum of the searching area, the evolutionary trajectory of the entire particles will still be severely misguided. To address the issue of RPSO’s over-reliance on gbest, a Memory-Enhanced Restructured Particle Swarm Optimization (MERPSO) algorithm is proposed [21]. Effective guiding information should not be derived solely from the current single “champion” gbest, but rather from the collective wisdom crystallized by all “elites” of the entire search history.

2.2.1. Core Idea and Update Mechanism

In MERPSO, the concepts of pbest and gbest are completely abandoned, and the position update mechanism is transformed into a probabilistic selection-based learning approach. The position updates of particles are determined through probabilistic selection from three “learning samples”, representing distinct search strategies, instead of by velocity and displacement [21]. The position update formula is as shown in Equation (5):

$$x_{i,d}^{t+1}=\left\{\begin{array}{llll}s{g}_d^t,\hfill & \hspace{1em}\hfill & \begin{array}{cc}if& rand()\le P_{sg}\end{array}\hfill & \hfill \\ m{p}_{i,d}^t,\hfill & \hspace{1em}\hfill & \begin{array}{cc}if& P_{sg}<rand()\le p_{sg}+p_{mp}\end{array}\hfill & \hfill \\ d{t}_{i,d}^t,\hfill & \hspace{1em}\hfill & otherwise\hfill & \hfill \end{array}\right.$$

(5)

where $x_{i,d}^{t+1}$ denotes the new position of particle $i$ in the d-th dimension at the (t + 1)th iteration. The three core learning samples are defined as follows: (1) The experience-guided sample (sg), which represents exploitation of promising regions. This sample is generated from an “experience set” storing numerous historical optimal solutions. (2) The block exploration sample (mp), representing exploration of uncharted regions. This sample is generated through a “block search strategy” designed to guide particles toward exploring less visited novel regions of the solution space. (3) The random perturbation term (dt), which introduces minor stochastic variations to the current particle position for maintaining population diversity and preventing premature algorithm stagnation.

2.2.2. Core Learning Strategies

The generating quality of sg and mp of the MERPSO algorithm is critical, which incorporates two sophisticated memory-enhanced strategies.

(1) 

Experience Selection Strategy (EDS)

The core of the EDS strategy lies in maintaining an external archive called the Experience Set (ES), which maintains the top Np solutions with the best fitness performance throughout the entire search history. The ES is updated after each iteration following fitness evaluation, preserving the most promising positions. The EDS strategy generates learning samples from the ES, denoted as SG. Each dimension of SG is independently determined according to Equation (6), meaning that every dimension of SG is computed as the average value of that dimension across K randomly selected solutions from the ES. In this algorithm, the value of K is set to 10.

$$s{g}_d={\displaystyle \frac{1}{K}}\times {\displaystyle \sum _{k=1}^{K}E}{S}_d(r_k)$$

(6)

where ES_d(r_k) denotes the d-th dimension of the r_k-th solution in the ES, and r_k is a random integer within the interval [1, Np]. To enhance the algorithm’s exploitation capability in the later stages, Np is gradually reduced to narrow the scope of solutions preserved in the experience set. Np is calculated according to Equation (7):

$$N_p=‖ps\times \left(1-{\displaystyle \frac{t-1}{T}}\right)‖$$

(7)

where ps represents the population size, || || denotes the ceiling operation, t is the current generation number, and T is the maximum iteration limit.

ESD stores the most historically fit solutions discovered by the algorithm since its initiation. When generating $sg$ samples to guide the entire population, the algorithm randomly selects multiple elite historical solutions from the ES and forms a “consensus” direction by calculating their mean.

(2) 

Block Search Strategy (BSS)

The block search strategy (BSS) dynamically partitions the entire multi-dimensional search space into a series of hyper-rectangular “blocks” and continuously monitors the frequency of particle visits to each block. The block search strategy (BSS) generates learning samples, denoted as MP. The method involves each particle X_i having its corresponding learning sample, labeled as mp_i. The vector mp_i is generated by randomly combining its personal best pb_i and a randomly selected position pr in the block, as determined by Equation (8):

$$m{p}_{i,d}=\left\{\begin{array}{ll}p{b}_{i,d},\hfill & rand>q_i\hfill \\ p{r}_d\left\{b\right\},\hfill & else\hfill \end{array}\right.$$

(8)

where mp_i,d denotes the position of the d-th dimension in the i-th learning sample mp_i. For each dimension, it has a probability q_i of being pr_i,d{b} and a probability (1 − q_i) of being pb_i. Here, pr_i,d{b} represents a random position within the b-th block of the d-th dimension; b is the selection result from a roulette wheel choice among all blocks in that dimension. The selection weight for each block is given by W_b = M_b − n_p, where n_p is the number of particles within that block and M_b is the upper limit for the number of particles in a block. For the algorithm’s exploration, BSS tends to generate exploratory samples $mp$ from those “less visited” (low-visit-frequency) blocks, thereby guiding particles to explore new search territories.

(3) 

The random perturbation term (DT)

The learning sample SG generated by EDS enhances the algorithm’s exploitation capability, while the learning sample MP produced by BSS strengthens its exploration capability. The position update equation of particles in the MERPSO algorithm is given by Equation (9):

$$X_i^{t+1}=c_s^{\prime }\times s{g}^t+c_s\times m{p}_i^t+D(t)$$

(9)

$$D(t)=(space\times r)\times (0.8+\omega )\times {(1-{\displaystyle \frac{t}{T}})}^{\left({\mathrm{C}}_m\times {\displaystyle \frac{t}{T}}\right)}$$

(10)

where X_i^t+1 represents the position of the i-th particle at generation t + 1. SG_t denotes the SG selected at generation t, and mp_i^t is the i-th MP at generation t. D(t) is a time-varying perturbation term, calculated according to Equation (10). The parameter space is set to 20% of the problem’s search space, r is a random number uniformly distributed in the interval [−1, 1], ω is the inertia weight ranging from 0.8 to 0.2, and C_m is the perturbation coefficient.

3. Discrete MERPSO Algorithm for Solving Single-Objective Flight Schedule Problem Optimization

The MERPSO algorithm demonstrates competitive performance in continuous optimization problems. However, the Flight Schedule Problem constitutes a discrete optimization problem characterized by two functionally distinct decision variables: adjusted times and selected routes. So that the MERPSO algorithm can solve Flight Schedule Problem optimization, this section designs Discrete Memory-Enhanced Restructured Particle Swarm Optimization (DMERPSO), which involves the strategies of constructing particle representations, reformulating position update equations, designing learning strategies, incorporating perturbation terms, and implementing parameter discretization.

3.1. The Representation of Flight Schedule Problem Optimization for RPSO Algorithm

3.1.1. A 4D Trajectory Model for the Flight Schedule Problem Optimization

The primary flight schedule information includes the number of flights, departure and arrival locations, scheduled departure times, estimated arrival times, and flight routes.

Table 1. An example of flight schedule.

Flight Number	Departure Airport	Landing at the Airport	Estimated Time of Departure	Estimated Time of Landing	Flight Routes
F1	Xi’an	Beijing	9:00	11:20	r(1,1), r(1,2), r(1,3)
F2	Shanghai	Shenzhen	10:15	12:30	r(2,1), r(2,2)
F3	Xi’an	Shanghai	18:20	21:15	r(3,1), r(3,2), r(3,3), r(3,4)
F4	Beijing	Shenzhen	7:45	9:10	r(4,1)
F5	Shenzhen	Xi’an	11:35	15:00	r(5,1), r(5,2), r(5,3)

Note: The Set of flights number are denoted as F = {F₁, F₂, F₃,…, F_Nf}, where N_f is the total number of flights; r^(i,j) denotes the j-th route of the i-th flight F_i.

presents a basic flight schedule.

The routes in flight scheduling are planned with one or more candidate routes, and different routes may exist for the same origin and destination. During the actual implementation of flight operations, the flight schedule often considers factors of adverse weather conditions and airspace congestion levels. While the departure location (orig) and landing location (des) remain unchanged, the actual departure time τ^orig is dynamically adjusted according to real-time situations. The arrival time of a flight τ^des is influenced by multiple factors, including the route distance, flight speed v^f, and congestion level, at the destination airport. In practical flight execution, routes are selected based on operational requirements.

Evaluating the flight schedule requires real-time position information for each flight within the flight plan. The 4D trajectory model is a commonly used framework which encompasses three spatial dimensions (flight position coordinates) and one temporal dimension (time information). An aircraft’s flight path along route r can be conceptualized as straight-line segments between waypoints (wp) as navigation checkpoints. The connecting paths between waypoints are termed flight segments L. A complete flight route r^(i,j) can be mathematically described using either waypoints or flight segments using Equation (11):

$$r^{\left(i,j\right)}=\left(ori{g}^i,w{p}_1^{\left(i,j\right)},w{p}_2^{\left(i,j\right)},\cdot \cdot \cdot ,de{s}^i\right)=\left(L_1^{\left(i,j\right)},L_2^{\left(i,j\right)},\cdot \cdot \cdot \right)\in {\Gamma }^{\left(i,j\right)}$$

(11)

where origⁱ and desⁱ denote the origin and destination of flight F_i, ${\Gamma }^{\left(i,j\right)}$ represents the set of flight route, and Figure 1 illustrates a basic example of a flight route. Once the flight schedule parameter τ_i^orig, the decision variable S_i for route selection, and the flight speed v^f_i are determined, the flight trajectory can be calculated accordingly.

3.1.2. Particle Representation and Flight Position Calculation in the RPSO Algorithm

For the Flight Schedule Problem optimization model, the decision variables affecting flights include the adjustment time of departure t^a and the selected route S^r for each flight. A particle X in the RPSO algorithm represents an adjustment scheme for the flight schedule, denoted as X ≤ t^s. The dimension D of particle X equals 2N_f, so the i-th particle X_i can be expressed by Equation (12):

$$X_i=〈t_{\left(i,1\right)}^a,t_{\left(i,2\right)}^a,\cdot \cdot \cdot ,t_{\left(i,Nf\right)}^a,S_{\left(i,1\right)}^r,S_{\left(i,2\right)}^r,\cdot \cdot \cdot ,S_{\left(i,Nf\right)}^r〉$$

(12)

where t^a_(i,1) denotes the adjusted departure time (in integer minutes) for the first flight of the i-th particle. Flight departure times are typically set at 5 min intervals, where t^a = 3 indicates a 15 min delay and t^a = −4 corresponds to a 20 min advance. S^r_(i,1) represents the selected route for the first flight of particle i.

Since the altitude of flights is neglected and only their horizontal positions are considered, once the adjustment scheme X is determined, the position of flight j can be calculated using Equations (13)–(16):

$$T_j\left(w{p}_j^0\right)={\tau }^{orig}+5\times t_{\left(i,j\right)}^a=T_j\left(ori{g}_j\right)$$

(13)

$$T_j\left(w{p}_j^k\right)=T_j\left(w{p}_j^{k-1}\right)+{\displaystyle \frac{len\left(w{p}_j^k-w{p}_j^{k-1}\right)}{v_j^f}},j=1,2,\cdot \cdot \cdot , Nf$$

(14)

$$\begin{array}{c}dis=2\mathrm{R}\times \arcsin (\sqrt{{\sin }^2\left(\left(latB-latA\right)/2\right)})+\cos \left(latA\right)\times \cos \left(latB\right)\\ \times {\sin }^2\left(\left(lonB-lonA\right)/2\right)\end{array}$$

(15)

$$lo{c}_j\left(t^s\right)={\displaystyle \frac{t^s-T_j\left(w{p}_j^{z-1}\right)}{T_j\left(w{p}_j^z\right)-T_j\left(w{p}_j^{z-1}\right)}}\times \left(w{p}_j^z-w{p}_j^{z-1}\right)$$

(16)

where T_j(wp_j^k)) denotes the time when flight j passes the k-th waypoint, τ^orig represents the scheduled departure time in the flight plan, T_j(orig_j) indicates the adjusted departure time of flight j, and the arrival time is denoted as T_j(des_j); v^f_j signifies the average flight speed of flight j provided by the dataset; len(A-B) is a function calculating the distance between two waypoints A and B using the Haversine formula as Equation (15), where R represents the Earth’s radius (6371 km), and latA and lonA respectively indicate the latitude and longitude coordinates of point A measured in radians; loc_j(t^s) specifies the position of flight j at timestamp t^s, with t^s being discrete time points separated at 5 min intervals.

3.1.3. The Objective and Constraint Conditions of Flight Schedule Problem Optimization

The objective of Flight Schedule Problem optimization takes minimizing flight delay time (Delay) as the optimization objective, which consists of total ground delay (T^dep) and total arrival delay (T^arr). The calculation method is shown in Equations (17)–(19):

$$\min Delay=T^{dep}+T^{arr}$$

(17)

$$T^{dep}={\displaystyle \sum _{j=1}^{Nf}\left(5\times t_j^a\right)}$$

(18)

$$T^{arr}={\displaystyle \sum _{j=1}^{Nf}\left(T_j\left(de{s}_j\right)-{\tau }_j^{des}\right)}$$

(19)

The constraints of Flight Schedule Problem optimization primarily consider the utilization of airport runways, with the constraint conditions shown as Equations (20)–(23):

$$N_{ap}^{dep}\left(t^s\right)\le Q_{ap}^{dep},\forall ap\in \Omega ,\forall t^s\in \left[0,T^{\max }\right]$$

(20)

$$N_{ap}^{arr}\left(t^s\right)\le Q_{ap}^{arr},\forall ap\in \Omega ,\forall t^s\in \left[0,T^{\max }\right]$$

(21)

$$\left|t_{j,ap}-t_{j+1,ap}\right|\ge {\tau }_{sep} ,i=1,\cdot \cdot \cdot ,Nf-1,\forall ap\in \Omega$$

(22)

$$t^a\in \left[T_{\min }^a,T_{\max }^a\right]$$

(23)

where all airports ap constitute the set Ω. For each airport, the number of flights simultaneously taking off and landing within a given period is subject to upper limits, known as the airport’s departure capacity Q_ap^dep and arrival capacity Q_ap^arr; therefore, Equations (20) and (21) ensure that the number of departing and arriving flights at a given airport do not exceed its respective capacity. Furthermore, the interval between two consecutive departures at the same airport must exceed a specified threshold τ_sep, so Equation (22) guarantees that the separation time between consecutive departures at the same airport adheres to the safety threshold Tsc, which is set to 5 min. Equation (23) constrains the adjustment time for an individual flight within the schedule to a reasonable operational range; $T_{\min }^a,T_{\max }^a$ respectively represent the minimum and maximum values of the flight schedule adjustment.

3.2. Discrete MERPSO Algorithm

The MERPSO algorithm framework was originally proposed to address continuous optimization problems, whereas discrete optimization problems possess a different feasible solution space. This section extends the MERPSO framework to the Discrete MERPSO (DMERPSO) so to solve discrete optimization problems. Firstly, the methodology of the DMERPSO algorithm is designed; secondly, the discretization processing of each strategy of the algorithm is introduced; finally, the particle initialization method is presented.

3.2.1. Position Update Formula of DMERPSO

The discretization method of the PSO algorithm employs a transfer function to map velocity values onto the interval [0, 1]. Subsequently, these mapped values within the [0, 1] interval are converted into binary values (0 and 1) through stochastic probability.

Since the MERPSO algorithm does not require particle velocity for position updates, the position update of particles in the DMERPSO algorithm is influenced by three components: the learning samples sg and mp, as well as the perturbation term dt. Specifically, sample sg enhances both the convergence speed and precision of the particle, mp strengthens the particle’s exploration capability, while dt maintains particle diversity. These three components directly take on particle position updates while serving distinct functional roles. Therefore, MERPSO directly updates particle positions based only on probability. The corresponding particle update equation is presented in Equation (24):

$$x_{i,d}^{t+1}=\left\{\begin{array}{llll}s{g}_d^t,\hfill & \hspace{1em}\hfill & rand\le P_{i,d}^{sg}\hfill & \hfill \\ m{p}_{i,d}^t,\hfill & \hspace{1em}\hfill & P_{i,d}^{sg}<rand\le \left(P_{i,d}^{sg}+P_{i,d}^{mp}\right)\hfill & \hfill \\ d{t}_{i,d}^t,\hfill & \hspace{1em}\hfill & \mathrm{o}ther\hfill & \hfill \end{array}\right.$$

(24)

where the update value of each dimension of a particle is selected from the corresponding dimensions of sg, mp, or dt with selection probabilities P^sg, P^mp, and P^dt respectively, where the sum of these three probabilities equals 1. The probability of selecting each term is determined based on factors including particle characteristics and the population’s search status.

3.2.2. Calculation of Selection Probability

The DMERPSO algorithm determines the probability of updating particle positions by evaluating and scoring multiple scenarios, followed by normalizing the evaluated scores to obtain probabilities, thereby ensuring that the sum of the three probabilities equals 1. Each evaluation score can be expressed as SC = W (weight value) × B (base score). The parameter values or ranges in this section are presented in

Table 2. Relevant parameters of selection probability.

Parameter	Size or Range
w1	[0.5, 2]
w2	0 or 1
B1	20
B2	100
B3	20

. The three selection probabilities P^sg, P^mp, and P^dt in Equation (25) are calculated with Equations (26)–(28).

$$P^l={\displaystyle \frac{S{C}^l}{S{C}^{sg}+S{C}^{mp}+S{C}^{dt}}},l\in \left\{sg,mp,dt\right\}$$

(25)

$$S{C}^{sg}=w_1\times b_{sg}$$

(26)

$$S{C}^{mp}=w_1\times b_{mp}$$

(27)

$$S{C}^{dt}={\displaystyle \frac{w_2}{w_1}}\times B_3$$

(28)

where the weight w₁ is a parameter that linearly iterates with the number of generations within the interval [0.5, 2], which makes particles to undergo random mutation with a higher probability during the early stages, thereby expanding the population’s search scope while reducing the mutation probability in later stages so to enhance the convergence precision. The weight w₂ governs the maintenance of convergence in one-dimensional space, where particles remain identical to both learning samples $sg$ and $mp$ during the pursuit of convergence accuracy in later evolutionary stages, which is calculated using Equation (29).

$$w_2(i,d)=\left\{\begin{array}{ll}0,\hfill & x_{i,d}=s{g}_{i,d}=m{p}_{i,d} \& t>{\displaystyle \frac{T}{4}}\hfill \\ 1,\hfill & other\hfill \end{array}\right.$$

(29)

The scores b_sg and b_mp function similarly to offset parameters in continuous MERPSO algorithms, computed through Equations (30) and (31), which regulate particles to exhibit greater displacement probability during initial exploration phases while maintaining positional stability or enabling minor adjustments with increased probability in subsequent optimization stages. In the two equations, ps denotes the number of particles of each generation of the algorithm, and rank(f(X_i)) is the sorting number of fitness of the objective function for the ith particle with the population.

$$b_{sg}(i,d)=\left\{\begin{array}{ll}{b}_2\times {\displaystyle \frac{\mathrm{rank}\left(f\left(X_i\right)\right)}{ps}},\hfill & t<{\displaystyle \frac{T}{2}} \& di{s}_s\ge di{s}_m \& d\le Nf\hfill \\ b_2\times \left[1-{\displaystyle \frac{\mathrm{rank}\left(f\left(X_i\right)\right)}{ps}}\right],\hfill & t\ge {\displaystyle \frac{T}{2}} \& di{s}_s<di{s}_m \& d\le Nf\hfill \\ B_1,\hfill & \mathrm{other} \hfill \end{array}\right.$$

(30)

$$b_{mp}(i,d)=\left\{\begin{array}{ll}{b}_2\times {\displaystyle \frac{\mathrm{rank}\left(f\left(X_i\right)\right)}{ps}},\hfill & t<{\displaystyle \frac{T}{2}} \& di{s}_s<di{s}_m \& d\le Nf\hfill \\ b_2\times \left[1-{\displaystyle \frac{\mathrm{rank}\left(f\left(X_i\right)\right)}{ps}}\right],\hfill & t\ge {\displaystyle \frac{T}{2}} \& di{s}_s\ge di{s}_m \& d\le Nf\hfill \\ B_1,\hfill & \mathrm{other} \hfill \end{array}\right.$$

(31)

Since the particle consists of two components, the adjustment time and trajectory, for the former $di{s}_m(i,d)=|x_{i,d}-m{p}_{i,d}|$ and $di{s}_s(i,d)=|x_{i,d}-s{g}_d|$, larger values indicate greater temporal discrepancies between the particle’s corresponding dimension and the learning samples, which carries practical physical significance; for the latter component, differences between these two values merely reflect distinct route selections, making comparative magnitude analysis meaningless. Consequently, the scoring mechanisms for these two particle components differ, with parameter b₂ calculated using Equation (32).

$$b_2=B_2*\left|{\displaystyle \frac{1}{1+e^{0.01\times \left(t-\frac{T}{2}\right)}}}-0.5\right|+B_1$$

(32)

3.2.3. Improvement of Strategies and Perturbation Terms

Although the previous subsection adapted the position update formula of the MERPSO algorithm to Equation (24) and introduced a probability-based selection method to better solve discrete optimization problems, it still cannot guarantee that the resulting positions are integers, as is required for solutions to the Flight Schedule Problem optimization problem. Therefore, this section improves the experience selection strategy (ES), the block search strategy (BSS), and the algorithm’s perturbation term, thereby transforming the MERPSO algorithm into the discrete variant, the MERSPO algorithm, tailored for solving the Flight Schedule Problem optimization problem.

(1) 

Experience Selection Strategy

In the discrete experience selection strategy, the storage principle and method of the Experience Set (ES) remain unchanged. The ES maintains an archive of the N_p best-performing solutions in terms of fitness throughout the entire search history, which is updated after each iteration’s fitness evaluation. Each dimension of the learning sample $sg$ is still selected independently; however, instead of calculating the average value of the selected solutions during the selection process, K solutions are randomly selected with replacement from the ES, and the most frequently occurring value among these selected solutions is chosen as the corresponding dimensional value for $sg$. In cases where multiple values have equal frequencies, one of these values is randomly selected as the dimensional value for $sg$. Here, K = 10, and N_p is calculated using Equation (33):

$$N_p=‖\left(ps-5\right)\times \left(1-{\displaystyle \frac{t-1}{T}}\right)+5‖$$

(33)

(2) 

Block Search Strategy

In the discrete block search strategy, the configuration of blocks varies according to particle dimensions. For the first to N_f-th dimensions of particles (i.e., flight adjustment time), blocks still maintain boundaries, where all integers on these boundaries can serve as selection ranges for $mp$. Taking Figure 2 as an example, which represents a block with a lower boundary of 1 and an upper boundary of 3, when selecting pr_d{b} according to Equation (15), $mp$ can take any integer value within {1,2,3}. The splitting and merging operations continue to be applied to blocks in the first to Nf-th dimensions. An additional operation is introduced: when the difference between block boundaries is even and splitting becomes necessary, a new block will be formed by combining the original lower boundary with the integer value of (upper boundary + lower boundary)/2, as illustrated in Figure 2. However, for the (Nf + 1)-th to 2Nf-th dimensions of particles (i.e., route selection components), there exists no continuous practical significance between adjacent integers. Consequently, blocks in this dimension range are defined without boundaries—for instance, block {5,8} indicates that eight particles have selected route number 5 in this dimension. Therefore, neither merging nor splitting operations are performed on blocks within this dimensional range.

With the increase in particle dimensions, higher demands are placed on memory storage. To conserve memory and reduce the computational time, this section stores the data blocks of dimensions 1 to Nf and dimensions Nf + 1 to 2Nf separately in two matrices, BL1 and BL2. Two additional matrices are employed to record the starting positions of each dimension, which are referred to as boundary matrices (Edge Matrices) EM1 and EM2. The correspondence between BL and EM is illustrated in Figure 3.

(3) 

Perturbation Term

The perturbation operation performs single-point mutation on the original particle basis, with a mutation probability of P^dt for each dimension. The parameter P^dt linearly decreases from 0.6 to 0.2 as the number of generations increases. The variation range for the first Nf dimensions is [R^dt_min, R^dt_max], while the variation range for the last Nf dimensions corresponds to any selectable flight path, as formulated in Equations (33)–(36):

$$spac{e}_t^{dt}={\displaystyle \frac{\left(T_{\max }^a-T_{\min }^a\right)}{2}}\times \left(1-0.8\times {\displaystyle \frac{t}{T}}\right)$$

(34)

$$R_{\min }^{dt}=\max \left(T_{\min }^a,x_{i,d}-spac{e}_t^{dt}\right)$$

(35)

$$R_{\max }^{dt}=\min \left(T_{\max }^a,x_{i,d}+spac{e}_t^{dt}\right)$$

(36)

3.2.4. The Methods for Initializing Particles and Satisfying Constraints

The adjustment time is categorized into five levels: slightly early, almost no adjustment, slightly delayed, moderately delayed, and severely delayed, defined as t^a = (−6, 0], (0, 3], (3, 8], (8, 18], (18, 36]. During population initialization, dimensions 1 to Nf of each particle randomly select one of these five intervals to generate adjustment times, while route selection dimensions are chosen randomly. This process forms the initial population p⁰. After evaluating p⁰, the top 1/3 particles with the best fitness performance are retained. These preserved particles undergo single-point mutation with probability P^p0, where each particle performs three mutation operations. All mutated particles constitute the new population p¹, which serves as the initialized population for the algorithm. This initialization approach ensures sufficient uniformity in particle distribution across the search space, enhances population diversity, and facilitates global exploration. Simultaneously, eliminating the worst-performing particles avoids excessive computational resource consumption on inferior solutions, thereby improving convergence precision.

During the optimization process, in order to ensure that the position of each particle in the population is always within the feasible region that satisfies the constraint limits (such as the capacity limits for runway takeoff and landing, and the minimum takeoff interval limit), the particle solution after each position update is always compared with the constraint conditions. If it does not meet the constraint condition limits, a random method is used to generate a new position, thereby repairing the particle solution to ensure that the search solution satisfies the operational constraints.

4. Simulation Experiment and Verification

4.1. Flight Data Collection and Processing

The dataset used in the experiments consists of real flight plans provided by an aviation data communication company. The flights originate from eight flight schedule instances from different operational periods across nearly 200 airports in China, ensuring authenticity and generalizability [24]. Each dataset contains the following information: flight number, coordinates of departure airport, coordinates of arrival airport, scheduled departure time (τ^orig), scheduled arrival time (τ^des), route (including waypoints), actual trajectory, and average speed during actual flight. To simulate temporary adjustments to flight plans before execution and introduce additional scheduling difficulty, the departure and arrival times of certain flights were modified. The characteristics of these flight datasets are summarized in

Table 3. Initial features of the experimental dataset.

Dataset	Number of Flights	Number of Airports	Number of Waypoints	Number of Routes	Initial Delay (min)	Adjusted Initial Delay (min)
M1	937	181	826	2053	10,812	-
M2	925	171	794	2113	10,752	-
M3	952	181	845	2331	13,734	15,297
M4	932	164	790	2374	18,392	20,752
M5	953	182	817	2076	26,596	28,361
M6	920	171	792	2036	48,905	51,802
M7	810	172	863	1983	20,744	23,850
M8	809	164	854	2130	26,744	29,501

.

Among them, the initial delay refers to the sum of delay times for all flights when the flight schedule is actually executed, while the adjusted initial delay represents the sum of delay times under increased optimization difficulty during actual execution. Datasets M1 and M2 represent original flight schedules; M3 and M4 simulate mild delay scenarios by randomly selecting 10% of flights in the original schedules and simultaneously advancing or delaying both departure and arrival times by identical time intervals (ranging from 30 min early to 30 min late); M5 and M6 simulate moderate delay scenarios by randomly selecting 3% of flights in the original schedules with adjusted time windows (either advanced by 30–60 min or delayed by 30–60 min); M7 and M8 first implement mild delay simulations on 10% of randomly selected flights as in M3/M4, then additionally apply moderate delay adjustments to 3% of remaining unadjusted flights (representing 3% of total flights) with modified time windows (advanced by 30–60 min or delayed by 30–60 min).

4.2. Experimental Performance

To validate the effectiveness of the DMERPSO algorithm, comparative experiments were conducted with RPSO [19], ADFPSO [25], SpadePSO [26], L-SHADE [27] and JSO [28] algorithms. For several continuous algorithms, in order to discretize them into integer encoding, the real-valued solutions of these algorithms underwent decimal rounding processing techniques to obtain integers. If their integer was greater than or less than the maximum and minimum values of each dimension integer within the given range of Flight Schedule Problem optimization problem, then the maximum and minimum values were taken, which ensured that the solutions of the comparison algorithms fell within the integer solution space of the Flight Schedule Problem optimization problem.

For each comparison algorithm, parameter settings followed the recommended values specified in their respective original papers. Each algorithm was independently executed 30 times on every dataset. To ensure fair comparison, all algorithms shared identical initial populations and employed the same stopping criterion based on maximum fitness evaluations (MaxFEs). The population size was set to 30 and MaxFEs was configured as 30,000 for all compared algorithms. All experiments were performed on a computer running the 64-bit version of Windows 11 Pro, with hardware specifications including an Intel Core i5 @3 GHz CPU and 32 GB RAM. All algorithms were implemented in MATLAB R2023a.

The optimization results of the DMERPSO algorithm and these comparative algorithms are presented in

Table 4. Total delay optimization results of the DMERPSO algorithm and the comparative algorithms (The bold data represents the best result).

Dataset	Total Delay	DMERPSO	RPSO	ADFPSO	SpadePSO	L-SHADE	JSO
M1	mean	1.07 × 103	7.52 × 104 (+)	2.31 × 104 (+)	8.88 × 104 (+)	1.59 × 104 (+)	9.43 × 103 (+)
	std.	1029.6	2761	1847.3	1331.8	10360.0	3859.4
M2	mean	2.15 × 103	7.71 × 104 (+)	2.27 × 104 (+)	8.63 × 104 (+)	1.44 × 104 (+)	1.05 × 104 (+)
	std.	1104.8	2721.2	2586	1387.1	4938.7	1977.0
M3	mean	3.16 × 103	7.83 × 104 (+)	2.20 × 104 (+)	9.22 × 104 (+)	2.03 × 104 (+)	9.80 × 103 (+)
	std.	745.27	3820.6	2271.8	888.88	13375.1	3325.8
M4	mean	4.23 × 103	8.29 × 104 (+)	2.56 × 104 (+)	9.02 × 104 (+)	1.36 × 104 (+)	1.45 × 104 (+)
	std.	1097.3	3818.9	2632.3	1560.7	8303.3	3917.3
M5	mean	6.13 × 103	8.05 × 104 (+)	2.91 × 104 (+)	9.73 × 104 (+)	2.53 × 104 (+)	1.34 × 104 (+)
	std.	1061.1	2250.6	2107.7	1611.6	12115.3	3013.3
M6	mean	2.16 × 103	7.36 × 104 (+)	2.50 × 104 (+)	9.14 × 104 (+)	1.88 × 104 (+)	1.10 × 104 (+)
	std.	1499	3405.5	1627	1522.4	12011.1	3525.0
M7	mean	3.27 × 103	5.64 × 104 (+)	2.29 × 104 (+)	7.83 × 104 (+)	1.85 × 104 (+)	1.31 × 104 (+)
	std.	1119.5	2496.8	2788.4	1562.5	9224.8	3852.6
M8	mean	1.89 × 103	6.02 × 104 (+)	1.65 × 104 (+)	7.83 × 104 (+)	8.21 × 103 (+)	8.25 × 103 (+)
	std.	667.87	3513	2584.3	1257.8	4020.4	2882.0

. The data in the table represent the mean and variance of total delays (in minutes) across 30 independent experiments. The symbols (+), (−), and (≈) indicate that the corresponding algorithm is significantly better, significantly worse, or approximately equivalent to the DMERPSO algorithm in terms of performance based on t-test results with p ≤ 0.05. The minimum mean total delay for each dataset is highlighted in bold. Experimental results demonstrate that the DMERPSO algorithm can significantly reduce total flight delays and optimize flight schedules. It achieves superior performance over other comparative algorithms across all eight datasets, particularly showing the best performance on the more challenging M7 and M8 datasets.

To better demonstrate the advantages of the proposed algorithm, the Friedman test was first applied to the mean values of the Total Delay Optimization Results from Table 4, followed by the Wilcoxon signed-rank test to compare the performance of the RMERSPO algorithm with other algorithms.

Table 5. The rank of algorithms based on the Total Delay Mean of dataset and Friedman test.

Dataset	DMERPSO	RPSO	ADFPSO	SpadePSO	L-SHADE	JSO
M1	1	6	5	7	4	3
M2	1	6	5	7	4	3
M3	1	6	5	7	4	3
M4	1	6	5	7	3	4
M5	1	6	5	7	4	3
M6	1	6	5	7	4	3
M7	1	6	5	7	4	3
M8	1	6	5	7	3	4
Mean rank	1	6	5	7	3.75	3.25
Friedman Test		χ2 = 24, p = 1.5880 × 10−8

presents the rankings of algorithms based on the mean Total Delay. The last row of the table shows the Friedman test results; the p-value is very small, indicating a significant difference in algorithm performance.

The Wilcoxon signed-rank test was used to compare two algorithms in all pairwise comparisons. The DMERSPSO algorithm was compared with the other three algorithms using the Wilcoxon signed-rank test at a significance level of α = 0.05. The summarized results are presented in

Table 6. The Wilcoxon signed-rank results of DMERPSO versus other algorithms (α = 0.05).

Algorithm	+/≈/−
RPSO	8/0/0
ADFPSO	8/0/0
SpadePSO	8/0/0
L-SHADE	8/0/0
JSO	8/0/0

, with the signs +, ≈, and −. The sign ‘+’ means that DMERSPSO performs significantly better than the compared algorithm; ‘−’ means that DMERSPSO performs significantly worse; while ‘≈’ means that there is no significant difference between the two algorithms. From the results in the table, it can be seen that DMERSPSO performs overwhelmingly better than the other algorithms.

To verify the stability of the algorithm’s operation, box plots were generated to analyze the total delay obtained from 30 independent runs on eight datasets, with the results shown in Figure 4. The experimental results demonstrate that the DMERPSO algorithm achieves superior optimization performance and exhibits higher stability.

4.3. Effectiveness Analysis of the Initialization Method

The DMERPSO algorithm introduces a population initialization method that incurs the computational cost of one generation. To analyze the effectiveness of this strategy, convergence curves were plotted by comparing the average best fitness per generation across 30 independent experiments between the DMERPSO algorithm, the DMERPSO-I variant (without the initialization strategy), and three baseline algorithms. The convergence curves of these algorithms on eight datasets are presented in Figure 5. As observed from the convergence results, the DMERPSO algorithm demonstrates strong sustained convergence capability. In the middle to late iteration stages, when other algorithms become trapped in local optima, DMERPSO exhibits superior ability to escape local optima through continuous exploration and exploitation of the solution space to seek better solutions. Although the DMERPSO-I variant without the initialization strategy achieves better performance than DMERPSO in early iterations, the population diversity introduced by the initialization strategy enables DMERPSO to achieve better convergence accuracy in later stages. This validates the effectiveness of the proposed initialization strategy.

5. Conclusions

To effectively address the discrete optimization problem of single-objective Flight Schedule Problem optimization, a Discrete Memory-Enhanced Restructured Particle Swarm Optimization algorithm (DMERPSO) is proposed. Experimental results demonstrate that the DMERPSO algorithm can effectively reduce flight delays, optimize air traffic capacity allocation, and achieve superior performance compared to benchmark algorithms.

The core innovation of the DMERPSO algorithm is designing the calculation of the selection probabilities from three components. More importantly, the DMERPSO algorithm improves the three terms—the experience selection strategy (ES), the block search strategy (BSS), and the algorithm’s perturbation term—to directly transform them so as to be tailored to solve the integer code problem of the Flight Schedule Problem. The proposed integer coding scheme for Flight Schedule Optimization is significant and can be extended to other related problems. In the experiments conducted in this study, continuous algorithms were employed as comparisons. These algorithms performed decimal rounding on real-number solutions to obtain integers, which makes it difficult to maintain the favorable optimization characteristics of the solution space search, thereby introducing certain discrepancies in the experimental comparison.