Time/sequence-dependent scheduling: the design and evaluation of a general purpose tabu-based adaptive large neighbourhood search algorithm

In intelligent manufacturing, it is important to schedule orders from customers efﬁciently. Make-to-order companies may have to reject or postpone orders when the production capacity does not meet the demand. Many such real-world scheduling problems are characterised by processing times being dependent on the start time (time dependency) or on the preceding orders (sequence dependency), and typically have an earliest and latest possible start time. We introduce and analyze four algorithmic ideas for this class of time/sequence-dependent over-subscribed scheduling problems with time windows: a novel hybridization of adaptive large neighbourhood search (ALNS) and tabu search (TS), a new randomization strategy for neighbourhood operators, a partial sequence dominance heuristic, and a fast insertion strategy. Through factor analysis, we demonstrate the performance of these new algorithmic features on problem domains with varying properties. Evaluation of the resulting general purpose algorithm on three domains—an order acceptance and scheduling problem, a real-world multi-orbit agile Earth observation satellite scheduling problem, and a time-dependent orienteering problem with time windows—shows that our hybridalgorithm robustlyoutperforms general algorithms includingamixedinteger programmingmethod, aconstraint programming method, recent state-of-the-art problem-dependent meta-heuristic methods, and a two-stage hybridization of ALNS and TS.


Introduction
Manufacturing planning is an essential element of supply chain management (Jacobs et al. 2010).In intelligent manufacturing, efficient scheduling of orders from customers plays an important role to maximise productivity and profit.For many make-to-order companies, orders have to be rejected or postponed when the company's capacity cannot meet the demand.This makes the problem become an over-subscribed scheduling problem, consisting of simultaneously selecting a subset of jobs to be processed as well as the associated schedule.This problem is important because it represents a class of real-world problems including the Earth observation satellite scheduling problem (Augenstein et al. 2016;Akturk and KiliÇ 1999), the order acceptance and scheduling problem (Oguz et al. 2010;Wang et al. 2017), the orienteering problem (Verbeeck et al. 2017), and selective maintenance scheduling (Duan et al. 2018).Many real-world instances in this class have time windows (e.g., from the time when the factory receives the raw material to the user-specified deadline (Rebai et al. 2012)) and time/sequence-dependent setup times (e.g., the time to prepare next batches of products in an intelligent manufacturing system): the scheduled start time of each job must be in its time window, and the setup time between every two jobs depends on the specific pair of jobs (Mirsanei et al. 2011) or their scheduled start times (Dong et al. 2014).
For the varying problem instances in this class with time windows and time/sequence-dependent setup times, general approaches such as mixed integer programming do not perform very well (Cesaret et al. 2012;Verbeeck et al. 2017;Liu et al. 2017).There are also problem-specific methods that use highly specialised subroutines (Liu et al. 2017;Silva et al. 2018;Poggi et al. 2010).The design and implementation of such methods requires expertise and effort.Our goal is to provide an intermediate approach: a generic algorithm that performs well on different problem variants.
The major contributions of this paper are as follows: 1. We propose a general algorithm with four algorithmic features: a hybridization of adaptive large neighbourhood search (ALNS) and tabu search (TS), a new randomization strategy for neighbourhood operators, a partial sequence dominance heuristic, and a fast insertion strategy.2. Through factor analysis, we show the robust performance of the new algorithmic features, and we derive useful conclusions on how to use tabu search for problem domains with different properties.3.By means of our algorithm, ALNS/TPF, we illustrate a methodology for solving a larger class of problems with high efficiency, without specifying a specialised method for each domain.4.There exist a limited number of publicly available source codes and benchmark instances for this class of problems.We publish the source codes of the algorithms and the benchmark instances to enable future studies. 1   Two early versions of this hybrid algorithm have been introduced in our preliminary work (He et al. 2018(He et al. , 2019)).We first applied the algorithm to the time-dependent agile Earth observation satellite scheduling problem (He et al. 2018) and then generalized the algorithm to the order acceptance and scheduling problem (He et al. 2019).The method in this paper is a further novel extension of the previous methods.The tabu heuristic, the partial sequence dominance heuristic and the insertion strategy have been upgraded and more neighbourhood operators are introduced.A more complete factor analysis of individual contributions of the new algorithmic features and the correlation between the performances of the algorithm and the properties of problem instances are included.Besides, in this

Background
This section describes the mathematical formulation of the problem, gives a review of approaches to instance domains, and lastly describes the standard ALNS and TS algorithms.

Mathematical formulation
Here we present a high-level abstraction of the common aspects of instances of the problem class.This model is proposed based on the models of different problems from Oguz et al. (2010); He et al. (2018); Verbeeck et al. (2017).Detailed specific constraints of problems are introduced in later sections.
Consider a set of jobs O = {o 0 , o 1 , . . ., o n , o n+1 } that can be potentially scheduled, where o o and o n+1 are two dummy jobs representing the start and end job in the solution sequence respectively.The order of other jobs is not fixed.Each job has a revenue r i , a processing duration time d i , and a time window [b i , e i ].Let x i be a binary variable representing whether job o i is selected, y i j be a binary variable representing whether job o i directly precedes job o j , p i be a decision variable representing the start time of o i , and M be a sufficient large constant.The problem can be formulated as a mixed integer linear programming (MILP) model: (1) subject to p i + d i + s i j + (y i j − 1)M ≤ p j ∀i ∈ {0, . . ., n}, j ∈ {1, . . ., n + 1}, i = j (2) n+1 j=1,i = j y i j = x i ∀i ∈ {0, . . ., n} (3) n j=0,i = j y ji = x i ∀i ∈ {1, . . ., n + 1} (4) (5) p i ≤ e i + (1 − x i )M ∀i ∈ {0, . . ., n + 1} (6) x 0 = 1, x n+1 = 1 (7) x i ∈ {0, 1} ∀i ∈ {1, . . ., n} (8) y i j ∈ {0, 1} ∀i ∈ {0, . . ., n}, j ∈ {1, . . ., n + 1}, i = j (9) The objective function (1) maximizes the total revenue of scheduled jobs.Constraints (2) restrict the time between every two adjacent jobs should be long enough for the setup, where s i j is the setup time between jobs o i and o j .The value of s i j depends on i and j for the sequence-dependent setup time case (e.g., a table of setup times for all pairs of o i and o j ) and depends on p i and p j for the time-dependent setup time case (e.g., a function of p i and p j or a table of setup times for all pairs of p i and p j ).Constraints (3) and (4) restrict that each accepted job is succeeded by only one job and precedes only one job.Constraints ( 5) and ( 6) define the earliest and latest start time of a job.Constraints (7) restrict that the two dummy jobs, the start and end jobs must be selected.Constraints ( 8) and ( 9) define the domains of the variables x i and y i j respectively F.

Domain instances
Due to the large number of problem variants and solution approaches, the reader is referred to Slotnick (2011) and Gunawan et al. (2016) for comprehensive surveys on this class of over-subscribed scheduling problems with time windows and time/sequence-dependent setup times.
The order acceptance and scheduling problem (OAS) is a typical representative of this problem class.The problem happens for instance when a manufacturing system does not have the capacity to meet demand.Oguz et al. (2010) proposed the OAS problem with a penalty for late completion, time windows and sequence-dependent setup times.The problem was approached by MIP (Cesaret et al. 2012), TS (Cesaret et al. 2012), genetic algorithm (Nguyen et al. 2015;Chen et al. 2014;Chaurasia and Singh 2017), artificial bee colony algorithm (Lin and Ying 2013;Chaurasia and Kim 2019), hyper-heuristic based methods (Nguyen 2016) and iterated local search (Silva et al. 2018).Recently, Silva et al. (2018) used Lagrangian relaxation and column generation to find tight upper bounds of problem instances.
The Earth observation satellite scheduling (EOSS) problem is another important problem instance of this problem class.In a limited scheduling horizon, the satellite can usually observe only a subset of the user-specified jobs.Besides, the transition time for the satellite to change its observation angle between two adjacent jobs is time/sequence-dependent (Lemaître et al. 2002).The time windows in the EOSS are usually much shorter than those in the OAS problem (Liu et al. 2017).Akturk and KiliÇ (1999) studied the observation scheduling problem of Hubble Space Telescope, in which the setup times jobs are sequence-dependent.A dispatching rule considering weighted shortest processing time, setup times and nearest neighbour was proposed.Liu et al. (2017) and Peng et al. (2018) studied the agile satellite observation scheduling problem with time-dependent setup times.Liu et al. (2017) proposed a mixed integer program-ming (MIP) method and an ALNS algorithm, where they also integrated ALNS with an insertion algorithm considering time-dependency by introducing forward/backward time slacks.Peng et al. (2018) proposed an iterated local search (ILS) algorithm.They further calculated the minimal transition time, the neighbours and earliest/latest start time of each job to accelerate the insertion.
The selected travelling salesman problem (STSP), also referred to as the orienteering problem (OP), defines a problem where the salesman visits a subset of cities to maximize the total collected reward within a limited travel time.Compared with the above two problem variants, the travelling time (i.e., setup time) between cities is much longer, and there exists a stronger correlation among cities depending on the locations of them.Existing methods include genetic algorithms (Abbaspour and Samadzadegan 2011), iterated local search (Garcia et al. 2013), MIP (Verbeeck et al. 2017), and act colony optimization (ACO) (Verbeeck et al. 2017).Verbeeck et al. (2017) proposed the time-dependent OP with time windows (TDOPTW).In their ACO metaheuristic, they used the max shift to fast determine the feasibility of an insertion, which is similar to the ideas of Peng et al. (2018).
Despite all this work, there is no method capable of finding good solutions to diverse real life instances within the available solving time.In this paper, we propose a general method which performs well on all above problem instances in terms of solution quality and running time.

Standard ALNS and TS
Adaptive large neighbourhood search (ALNS) is one of the most promising approaches for scheduling problems (Ropke and Pisinger 2006).Since ALNS is less sensitive to the initial solution than general local search (Demir et al. 2012), the initial solution is usually generated by a simple greedy heuristic.The solution is updated by removing some jobs from the current solution with the removal operators and inserting some jobs back to the solution with the insertion operators.Multiple removal and insertion operators can be defined according to the problem characteristics.In each iteration, an adaptive mechanism based on a roulette wheel is used to select a pair of removal and insertion operators according to their weights.The weight of the operator w i is updated according to its accumulated score π i in the previous iterations, w i = (1 − λ)w i + λπ i / j π j , where λ is a constant weight update parameter in [0, 1].When a new solution is generated, it is accepted if it is better than the current solution, otherwise its acceptance is determined by a simulated annealing (SA) criterion with probability: , where f (S) and f (S ) are the reward of current solution S and new solution S respectively, and T is the temperature.
Tabu search (TS) was first proposed by Glover (1986).In TS, some simple local search moves are defined to update the solutions.To prevent short-term cycling, recently visited solutions or recently used local search moves are stored in a tabu list, and may not be tried again while in the list.The forbidden solutions or moves lose their tabu status after a certain short time.Žulj et al. (2018) proposed the first hybridization of ALNS and TS and found that a simple hybridization of these two metaheuristics outperformed both the standalone methods for the order batching problem.Their method combines the diversification capabilities of ALNS and the intensification capabilities of TS.It uses ALNS to search for better solutions and, if a certain number of ALNS iterations have passed, invokes TS.Thus ALNS and TS are alternated in a simple two-stage manner.

ALNS/TPF: tabu-based ALNS algorithm
In this section, we introduce four algorithmic features in our approach: a more advanced tabu search hybridization (TS), randomized heuristic neighbourhood operators, partial sequence dominance (PSD), and a fast insertion algorithm (FI) considering time/sequence-dependent setup times.The resulting algorithm, called ALNS/TPF, is shown as Algorithm 1.

Tabu search hybridization
Although ALNS has been widely successful (Thomas and Schaus 2018), a main drawback is that its search efficiency can founder due to re-visiting recent solutions.Although in standard ALNS, large portions of the solution are destroyed and rebuilt, and it would seem less likely a previous solution would be visited than other local search algorithms with simpler moves, the probability of short cycling still exists and could be higher when 'good' jobs are identified and selected a lot by the algorithm.Sometimes although jobs are inserted in different orders by different insertion operators, the resulting solutions are the same.This motivates us to propose the hybrid algorithm of ALNS and TS.
As noted earlier, Žulj et al. (2018) proposed the first hybridization of ALNS and TS.However, since ALNS and TS are used in separate stages, this hybridization does not change the short-term cycling nature of ALNS.In contrast, we propose a tight integration of ALNS with TS, which includes three types of tabu heuristics: the removal tabu, the insertion tabu and the instant tabu.
Removal tabu For each job, we declare a removal tabu attribute.If a new solution is accepted, the removal of newlyinserted jobs is forbidden for the following θ iterations; otherwise, the removal of the jobs removed in this iteration is forbidden for the following θ iterations.
Insert tabu For each job, we declare an insertion tabu attribute.If a new solution is accepted, the reinsertion of newly-removed jobs is forbidden for the following θ iterations.Here we do not forbid the reinsertion of the jobs inserted in this iteration if the new solution is rejected as we do in the removal tabu, because in this case the removal tabu is enough to prevent visiting a recent solution.Preventing the reinsertion of jobs can lead to a lower solution quality, because this problem attempts to schedule as many jobs as possible.
Instant tabu this tabu heuristic is used to prevent producing a new solution same as the current solution.When inserting a job to the destroyed solution by the insertion algorithm introduced in "Fast insertion algorithm" section, if the resulting solution assuming the candidate job is inserted is same as the current solution, this insertion will be forbidden.
All the three heuristics are used in the solution update process (Algorithm 1, line 6).The removal and tabu attributes are updated in Algorithm 1, line 14.For the values of the tabu attribute θ , we follow Cordeau and Laporte (2005) and set it to a random value in [0, √ n/2], where n is the number of jobs.Since the instant tabu is used only once in one iteration, it does not have a tabu attribute.
We compare the three tabu types and the two ALNS-TS hybridizations in "Tabu search" section.

Randomized generic neighbourhood operators
ALNS uses multiple neighbourhood operators to update solutions (Algorithm 1, lines 5-6).To make sure that the algorithm is efficient for a diverse range of problem instances with varying properties, we use the following ten generic removal operators and seven generic insertion operators, and introduce a simple but effective randomization strategy to diverse the search.These operators are adapted from Pisinger and Ropke (2007) and Demir et al. (2012) to fit our problem, while the randomization strategy is new.The randomization strategy is similar to the idea of adding noise to the insertion operators by Pisinger and Ropke (2007).However, we extend this idea to both removal and insertion operators.
The ten removal operators are: 1 All the jobs removed by the above removal operators and other unscheduled operators are stored in a candidate job bank.Seven insertion operators are used to sort the jobs in the job bank and insert them one by one from the top of the list back to the solution.The insertion method is introduced in "Fast insertion algorithm" section.The insertion stops until no jobs can be inserted, or the total revenue of the repaired solution plus the total revenue in the job bank (i.e., the upper bound of the new solution in this iteration) is lower than the current solution.
The seven insertion operators are: 1. Max revenue insertion (MRI) The jobs in the job bank are sorted according to descending revenue.After selecting the removal/insertion operators by the roulette wheel mentioned in "Standard ALNS and TS" section, standard ALNS ranks the jobs according to the heuristic values of the operators: e.g., for the min revenue removal operator, the revenue is regarded as the heuristic value h, the jobs are ranked in an ascending order of h, and the jobs on the top of the list are removed.In order to diverse the search, we add randomness to the heuristic values of selected certain operators: h ← h × (1 + r ), where r is a random value in [0, 1].Here we differ from the common approach of selecting jobs randomly according to a probability that depends on h, because we want to add limited randomness and while keeping emphasis on following h.Our approach here thus introduces a random component without neglecting the heuristic.
When removing and inserting a job, if the job is forbidden to be removed or inserted, the operator skips it and check the next one.However, through an aspiration criterion, the tabu status of a job can be revoked if the number of removed jobs is smaller than p d for the removal tabu, and all other jobs that are not forbidden by tabu have been tested for insertion and there is still open space in the solution for the candidate job for the insertion tabu.This aspiration criterion ensures that there are enough jobs to remove and insert.

Partial sequence dominance
Besides solution cycling, a further drawback of ALNS is that it evaluates a new solution depending on the quality of the whole solution sequence.Hence, during the search process, solutions with some good parts (i.e., parts of the solution might have higher objective value while consume less time) Due to the time-dependency and sequence-dependency, the quality of a solution is influenced significantly by these small parts.
Inspired by genetic algorithms, we propose the partial sequence dominance (PSD) heuristic (Algorithm 1, lines 7-9): we construct a compound solution which keeps better partial sequences from the new solution and the current solution.The partial sequence is defined in Definition 1.An example of the definition of the partial sequence is shown in Fig. 1.The quality of the partial sequence is evaluated by unit revenue: the objective function value divided by the total period of the partial sequence.If the compound solution is better than the new solution and different from the current solution, it replaces the new solution.Figure 2 shows one example of PSD.In standard ALNS, the new solution is given up.However, partial sequence 1 and partial sequence 2 of the new solution are better than the current solution.So according to PSD, we keep partial sequence 1 and partial sequence 2 of the new solution and partial sequence 3 of the current solution, and we get the compound solution, which is better than the current solution.
Definition 1 A partial sequence is a sequence of jobs, starting with the first job of each continuous sequence of unchanged jobs.
The detailed process of constructing a compound solution from two solutions is shown in Algorithm 2. When a new solution is produced, we partition it into multiple partial sequences.We compare each partial sequence of the new solution with the corresponding partial sequence of the current solution.The partial sequence with higher unit revenue is stored in the compound solution.
A challenge for the PSD heuristic is that one job can appear in different partial sequences of the current solution and the new solution.Thus one job might be processed twice in the compound solution.To maintain the feasibility, all the repetitive jobs in the compound solution are removed.Then the start times of jobs in the solution are updated so that all jobs in the compound solution start as early as possible.

Fast insertion algorithm
The last algorithmic feature of the algorithm is a fast insertion algorithm, which is used to insert jobs back to the solution by the insertion operators.We first proposed this method for a scheduling problem with sequence-dependent setup times in a previous paper (He et al 2019).To make sure the algorithm is complete and clear to the reader, we give a short description of the basic ideas of the insertion algorithm, and then we generalize the fast insertion algorithm to the time-dependent case.
The fast insertion algorithm uses the following two steps to insert a candidate job.First, the feasibility of the insertion at all positions of the solution is evaluated rapidly by a concept called time slack.The time slack is the time a job can be postponed before the solution becomes infeasible.Because all the jobs in the current solution are started as early as possible, the candidate job can be inserted before a job if the time that the following job needs to be postponed is smaller than its time slack.Note that in this step, all positions at which if the candidate job is inserted and the resulting solution is the same as the current solution are also forbidden because of the new instant tabu.Then in the second step, the best possible position is selected to insert the task.We select the position which increases the least setup time and adds the least penalty to the postponed jobs in the current solution.More details of the fast insertion algorithm are given in Appendix A.
For the problems put forward in this paper, which have time-dependent setup times, there are two challenges for the above insertion algorithm: (1) how to calculate the latest start time of a job so that we can calculate its time slack?This is more complicated than the sequence-dependent case because the setup time changes with the start time; (2) how to calculate the increased setup time?We cannot know the exact increased setup time unless we calculate the start times of all the postponed jobs and the changed setup times, which is too complex.For challenge 1, we can calculate the latest start time of job o i by solving the equation: ), where p Late j is the latest start time of the following job o j and Setup(time 1 , time 2 ) is a function to calculate the time-dependent setup times.However, for the problem where such an analytic function does not exist, such as the agile Earth observation satellite scheduling problem where the setup time is given by a table, the dichotomy method by Liu et al. (2017) can be used to find the latest start time of a job given the latest start time of its successor.For challenge 2, we use the increased setup time of the insertion position (e.g., if we insert candidate job o c between o i and o j , the increased setup time of the insertion position is s ic + s cj − s i j ) to approximate the actual increased setup time.On a time-dependent agile Earth observation satellites scheduling problem benchmark (Liu et al. 2017) and a timedependent orienteering problem benchmark (Verbeeck et al. 2017), the average error of this approximation of the setup time is 12.43% and 16.12% respectively.

Algorithmic analysis
The proposed ALNS/TPF algorithm consists of four features (i.e., tabu search, randomized generic operators, partial sequence dominance and fast insertion algorithm).In this section, we study how the discussed algorithmic features perform on different problem domains in order to understand how and when to use them depending on the domain properties.
We first introduce three problem domains and the datasets we used to test our algorithm.Then, we analyze the algorithmic features individually.For each new feature, we compare the algorithm without this feature against the full algorithm to understand its performance on the three problem domains.For each removed algorithmic feature, we calcu-late the decrease in solution quality (the percentage of the decrease of the objective function value compared with the full algorithm) and the increase in running time (the percentage of the increase of the running time compared with the full algorithm).A higher decrease in solution quality and increase in running time shows that the corresponding algorithmic feature performs better.

Problem datasets
We choose three representative problem domains, the order acceptance and scheduling (OAS) problem with time windows and sequence-dependent setup times, the agile Earth observation satellite scheduling problem (AEOSS), and the time-dependent orienteering problem with time windows (TDOPTW).
We consider the OAS problem from Cesaret et al. (2012).In this problem, the setup time between two jobs is sequencedependent.Besides, the setup of a job can only start after its release, which makes the setup constraint become: max{b j , p i + d i } + s i j + (y i j − 1)M ≤ p j .This problem is also special because of the tardiness penalty: if a job o i starts after its due time ēi , it receives penalty ω i T i on its revenue, where ω i is the penalty weight and T i is the tardiness, T i = max{ p i − ēi , 0}.Therefore, the objective function becomes max n i=1 x i (r i −ω i T i ).We use the benchmark dataset published by Cesaret et al. (2012).Three main parameters were used to generate these instances.The first parameter is the number of jobs n = 10, 15, 20, 25, 50, 100 and we only test the larger instances with 25, 50 and 100 jobs; the second parameter, τ , influences the length of time windows: when τ is larger, the time windows are smaller; the third parameter, R, influences the range of the end time and the due time of time windows: when R is larger, the deadlines spread broadly, so the overlap of time windows gets smaller.Both τ and R have five values: 0.1, 0.3, 0.5, 0.7, 0.9.Ten random instances are generated for each parameter setting, giving 750 instances in total.
We consider the AEOSS problem from Liu et al. (2017).The transition time between two adjacent jobs o i and o j is calculated by: s where t is constant time for stabilizing the satellite, function A i is represented by a table returning the angle of the satellite for observing o i at the start time of the observation, and v is the satellite transition velocity.The scheduling horizon is 24 hours, which means there are multiple time windows for each observation job.Let w i be the total number of time windows for job i, and k be the k-th time window of job i.The objective function becomes max n i=1 w i k=1 x ik r i , where x ik ∈ {0, 1} is a decision variable, meaning whether the k-th time window is selected.Since each job can only be processed once, an additional constraint should be considered: w i k=1 x ik ≤ 1 ∀i.The original dataset of AEOSS problem was not published, we generate the dataset following the configuration from Liu et al. (2017).The jobs are generated according to a uniform random distribution over two geographical regions: China and the whole world.For the Chinese area distribution mode, fifteen instances are designed and the number of jobs contained in these instances changes from 50 to 400 with an increment of 25.For the worldwide distribution mode, twelve instances are designed and the number of jobs contained in these instances changes from 50 to 600 with an increment of 50.
We consider the TDOPTW problem from Verbeeck et al. (2017).In this problem, the scheduling horizon is divided into several 15-minute time slots and for each time slot, a travelling velocity starting in this time slot is given.Therefore, the travelling time (i.e., setup time) is given by a piecewise linear function, dependent on the end time of the preceding job: where μ and υ are two parameters, and the values of them depend on the time slot of the end time.This dataset was generated by Verbeeck et al. (2017).It has instances with job number 20, 50 and 100.For each set of instances with the same number of jobs, there are four variations in scheduling horizon t max (8, 10, 12 and 14h) and three random variations in the lengths of time windows (small, medium and large).Therefore, in total there are 36 instances.
Although these are sequence/time-dependent scheduling problems with time windows, there are in fact some differences.However, for the AEOSS and the TDOPTW problems, the setup times are calculated based on real locations of the jobs, and jobs influence each other if they are close.We believe such property makes the locationrelated operators such as the worst route removal and the min distance insertion work well on these two problems.

Tabu search
In this section we aim to answer the following questions: how the three tabu types perform on problem domains with varying properties; whether TS helps to avoid recent solutions; whether TS can improve the performance of ALNS on the three problem domains; whether our tight hybridization is better than the two-stage hybridization?These studies help us to understand the performance of the tabu search heuristics so that we can use them efficiently.

Performance of three tabu types
In "Tabu search hybridization" section, we introduced three types of tabu: the insertion tabu, the removal tabu and the instant tabu.The first type is more common in oversubscribed problems (Bianchessi et al. 2007;Cordeau et al. 2001;Cordeau and Laporte 2005;Rogers et al. 2006;Prins et al. 2007).The only removal tabu we found in the literature is from Rogers et al. (2006).However, their strategy is for updating an infeasible solution by inserting jobs first and then removing jobs.Therefore, their removal tabu is used in the intermediate solution (i.e., the infeasible solution) while ours is used in the repaired solution (i.e., the feasible solution).The third tabu type, instant tabu, is new according to our knowledge.
In this section, we study how the three tabu types perform on problem domains with varying properties.We compare the standard ALNS with each tabu type against the standard ALNS without any new algorithmic features except the fast insertion algorithm, which is necessary in the insertion process of the ALNS algorithm.We find that the performance of the removal tabu and insertion tabu correlates with the proportion of jobs that can be fulfilled, which we call the completion ratio,3 and the performance of the instant tabu correlates with the number of jobs in the solution.
According to Fig. 3, the removal and insertion tabu works better when the completion ratio is low.Since all the OAS Fig. 3 The improvement of solution quality (i.e., the value of the objective function) by two types of tabu for different completion ratios on the three problem domains instances have relatively high completion ratio, these two tabu heuristics do not show obvious improvements.The Pearson correlation coefficient is − 0.60 between the completion ratio and the performance of the removal tabu, and − 0.63 between the completion ratio and the performance of the insertion tabu, showing negative correlation between the performance of these two tabu heuristics and the completion ratio.However, when the completion ratio is too low, the performance of the removal and insertion tabu starts to decrease.This is because our tabu length θ is calculated according to the total number of jobs n.If the completion is too low, the jobs that are forbidden to remove or insert are too many for the number of jobs in the solution sequence.This can be improved by decreasing the value of θ .
Although the performance of the removal and insertion tabu is similar, the difference between them is statistical significant: the p value in a paired t test is 4.25 × 10 −3 .We find that the performance of the insertion tabu decreases with the completion ratio faster than the removal tabu.As a result, the insertion tabu works better than the removal tabu when the completion ratio is low (i.e., in Table 2, the the insertion tabu is better for the TDOPTW problem and the AEOSS problem when the completion ratio is low), while the removal tabu works better than the insertion tabu when the completion ratio is high (i.e., in Table 2, the removal tabu is better for the OAS problem and the AEOSS problem when the completion ratio is high).
Then we study the instant tabu.According to Fig. 4, the instant tabu works well when there are fewer jobs in the solution.Therefore, it works much better on the TDOPTW problem than it does on the other two problems.This is because when there are fewer jobs in the solution, the prob-  Overall, we conclude that it is better (although marginally so) to include the insertion tabu and the removal tabu for problems with low completion ratio.But since these two tabu heuristics also help increasing the performance of the algorithm when the completion ratio is high, we suggest using them also for problems with high completion ratio such as the OAS problem.The instant tabu works better when the solution sequence is short; on problems with longer solution sequences, such as the AEOSS and OAS problems, performance is not improved.Further, as the length of the solution sequence increases, the time used for comparing solutions by the instant tabu increases.The instant tabu should not be used in this case.Therefore, in the following experiments, we use the insertion tabu and the removal tabu for the OAS problem and the AEOSS problem, and all the three tabu heuristics for the TDOPTW problem.We refer to it as the TS strategy.

Percentage of revisited recent solutions
In this section, we test whether the TS strategy helps to reduce the probability of short-term cycling search process of ALNS.We run the algorithm with and without TS on the three problems, and the average percentages of iterations visiting a solution which has been visited within the previous 50 iterations are shown in Fig. 5.
According to Fig. 5, it is obvious that the probability that the algorithm re-visits a recent solution is reduced considerably by TS.This proves that the short-term cycling of the standard ALNS is reduced by TS.For the AEOSS problem, the instance with 50 jobs of the worldwide distribution is too simple for the algorithm and it can schedule all the jobs in the initial solution and terminate.Therefore, the percentage of recent solutions in this instance is 0.
We also observe that the gap between the percentages of revisited recent solutions with and without TS tends to increase when the problem grows in size.This is because when the problem instance grows in size, the completion ratio gets lower.According to "Performance of three tabu types" section, the insertion tabu and the removal tabu work better when the completion ratio is lower.

Performance of the TS strategy
We test the performance of the TS strategy as follows.We compare the algorithm without the TS strategy (ALNS/PF) with the full ALNS/TPF algorithm.For the three problems, we divide the instances into three groups (i.e., small, medium and large) according to the number of jobs.Figure 6 shows that without TS, all the gaps are increased on all the three problems.For the three problem, TS contributes to the solution quality more when the instance grows in size.This is consistent with the observations in "Performance of three tabu types" and "Percentage of revisited recent solutions" sections.The performance of TS on the TDOPTW is not very obvious, because the algorithm with our other tech-

Fig. 5
The average percentages of iterations visiting a recent solution.For the OAS problem, each point shows the average value of 50 instances with the same number of orders and the same τ .For the TDOPTW problem, each point shows the average value of four instances with the same number of orders and the same size of time windows niques is already quite efficient for the TDOPTW, especially for small instances (i.e., the decrease in the solution quality when removing TS is 0).For the OAS problem and the AEOSS problem, TS also reduces the CPU time much by forbidding useless removal of jobs from the solution.For the TDOPTW problem, TS increases the CPU time, because the instant tabu is time-consuming for comparing the new solution with the current solution.

Comparison with the two-stage hybridization
We further compare our tight hybridization with the twostage hybridization of ALNS and TS (ALNS-TS).Let us assume for the full ALNS/TPF, the maximum iteration is N .
In ALNS-TS, TS is run for 0.015N iterations after every 0.1N iterations of ALNS.In each TS iteration, 10 new neighbourhoods by our removal and insertion operators are examined to find the best local move.The whole process is run four times, hence for N neighbourhood moves in total.
Recently visited solutions are inserted in a tabu list for √ n/2 iterations.Note that ALNS-TS might examine more neighbours than N in order to find unvisited ones.
From Fig. 7, it is obvious that the two-stage strategy produces much worse solutions.For the OAS problem, the gap increases when the instance gets larger.We also observe that the two-stage hybridization works less well than even the standalone ALNS, by comparing ALNS-TS with ALNS/PF.When ALNS and TS share a total number of iterations, the standalone ALNS performs better than the two-stage hybridization of them.This shows that ALNS has a higher search efficiency than TS does for the OAS problem.For the TDOPTW problem, ALNS-TS does not use as much CPU time as for the other two problems, because the solutions for the TDOPTW problem are relatively short, and the TS component which compares different solutions does not consume much time.

Randomized generic neighbourhood operators
In the proposed algorithm, we use ten removal operators and seven insertion operators to update solutions.

Comparison of the different operators
We compare the performance of these operators on the three problem domains.Figure 8 shows the percentage of usage of different operators.Operators which perform better are selected by the adaptive mechanism of ALNS more often, so that they have higher percentage of usage.
In the removal operators, the max revenue removal (MRR) operator performs best and the max conflict removal (MCR) performs worst on the three domains.In the insertion operators, the max revenue insertion (MRI), the max unit revenue insertion (MURI) and the historical unit revenue insertion (HURI) perform best.We can also observe that location-related operators (worst route removal, min distance insertion) do not work well on OAS, because the setup times of jobs in the OAS problem are generated randomly and the jobs have little dependency on the location.Setup-related operators (max setup time removal, historical setup removal, max setup time insertion) perform well on the TDOPTW problem.This is because the setup times of TDOPTW prob-lem are very long compared with the processing time.The setup times are useful heuristic information.The opportunity operators (max opportunity removal, min opportunity insertion) perform better on the AEOSS problem than the other two problems, because the jobs in the AEOSS problem have multiple time windows.
From the above observations, we can see that the algorithm adapts itself well by selecting different operators according to the different properties of different problems.However, this selection strategy of ALNS can still be improved.For example, although the opportunity operators (max opportunity removal, min opportunity insertion) perform best on the AEOSS problem, they are also used a lot on the other two problems, where these operators should be very inefficient because there is only one time window for each job.If such selections can be avoided or reduced, the search efficiency of ALNS can be improved.We will investigate a better online-learning strategy for these instance-dependent neighbourhood operators in our future work.

Performance of the randomization strategy
Then, we test the performance of the randomization strategy in the operators.We compare the algorithm with neighbourhood operators without randomness (ALNS/TPF (No random)) with the full ALNS/TPF algorithm.Figure 9 shows that the randomization strategy helps to increase the performance on most of the instances of the three problems.For the three problems, the randomization strategy contributes more for larger instances.When there are more jobs, the randomization strategy can help visiting more states in the solution space.

Partial sequence dominance
We test the performance of PSD by comparing the algorithm without PSD (ALNS/TF) with ALNS/TPF.According to Fig. 10, PSD shows obvious improvements on AEOSS problems, while it does not improve the performance of the algorithm much on the OAS problem and the TDOPTW problem.There are two reasons for this.For the OAS problem and the TDOPTW problem, the solution sequences are relatively short.PSD works well when the solution sequence gets long, because more partial sequences can be ignored in the long solution sequence.The second reason is that the time windows of the OAS problem and the TDOPTW problem are relatively long.If the time window is long, one order can exist in different partial sequences in the current solution and in the new solution respectively, reducing the quality of the compound solution.This can be further proved in Fig. 11, where for the OAS problem, PSD works better when τ is larger (i.e., when the time window is shorter).

Fast insertion algorithm
The fast insertion algorithm contains two ideas: the time slack strategy and the best position selection strategy.We study each in turn.

Performance of the time slack strategy
First, to test the performance of the time slack strategy, we compare it with the backward/forward time slack strategy of Liu et al. (2017).Both the strategies have the same time complexity O(n), but ours creates much more space in the schedule by considering postponing all the possible jobs in the solution, while Liu et al. (2017)'s method only creates limited space by moving two jobs.In Fig. 12, ALNS/TPF with Liu et al. ( 2017)'s strategy is denoted as ALNS/TP (no time slack).It is obvious that our time slack strategy uses less time and has higher solution The value of R Fig. 13 The performance of ALNS/TP (no time slack) compared to the full ALNS/TPF algorithm on the OAS problem for different values of τ and R quality.And among all the strategies, the time slack strategy contributes most performance.For all the three problems, the time slack strategy works better when there are more jobs.Because when there are more jobs, the superiority of postponing multiple jobs becomes obvious compared with Liu et al. (2017)'s strategy, which only moves two jobs.Besides, according to Fig. 13, for the OAS problem, the time slack strategy works better when τ is smaller and R is larger.When τ is smaller, the time window is longer and the time slack strategy can make more use of the long time window.When R is larger, the gap between the due time and end time of a time window grows.The due time slack strategy works better in this case.Similarly, according to Fig. 14, for the TDOPTW problem, the time slack strategy works better for longer scheduling horizon and larger variance in the lengths of time windows.

Performance of the best position selection strategy
Second, we study the best position selection strategy.The local optimality of this strategy can be proved in the premise that no look-ahead strategy is considered in this insertion algorithm, which will increase the complexity of the insertion algorithm.If we assume that when inserting a job, the following jobs are not considered, the optimal insertion position should be the one that increases the least setup time.This is because when we try to insert a job, the revenue and the processing time of the job are fixed.Since the total scheduling horizon is limited, the optimal insertion should be the one that inserts the job successfully (i.e., receives the revenue) as well as maximizes the remaining scheduling space for following jobs.The strategy guarantees that if a job can be inserted, the increased setup time is minimal.So this strategy finds the optimal insertion of a job.The algorithm without selection (ALNS/TP (no selection)) is compared with ALNS/TPF in Fig. 15.The strategy works significantly better on the OAS problem than it does on the other two domains.This is because for the AEOSS problem, the time windows of jobs are relatively short compared with the scheduling horizon.And for the TDOPTW problem, the number of jobs in the solution is small.Therefore for these two problems, when inserting a candidate job, the number of possible positions to insert the job is limited compared with the OAS problem.The selection of the best position does not improve the performance of the algorithm on these two domains much.This can also be proved by Fig. 16.For the OAS problem, the selection works better when τ is smaller and R is larger.When the time window is longer, the number of possible insertion positions also gets larger.In this case a sorting strategy to compare the insertion positions works well.When R is larger, the jobs in the current solutions have similar time windows.The candidate job to be inserted can neighbour more jobs in the solution, resulting in a larger number of possible insertion positions.
To sum up, from the algorithmic analysis of this section, we derive the following conclusions: (1) the insertion tabu and the removal tabu work better when the completion ratio is low, and the instant tabu works better when there are fewer jobs in the solution sequence; (2) our tight hybridization of ALNS and TS works better than the two-stage hybridization; (3) the multiple neighbourhood operators can be selected adaptively by the algorithm according to the properties of different problems; the randomization strategy performs well by improving the solution quality and reducing runtime; (4) the PSD works better when the instance grows in size, which proves that it helps to combine parts of different solutions, when the solution sequence gets long; (5) the best position selection contributes much to the solution quality, but also consumes more time; and (6) the time slack strategy works well in terms of solution quality and time complexity.

Comparison with state-of-the-art algorithms
In this section, we compare the performance of the full algorithm, ALNS/TPF, against state-of-the-art algorithms and solvers on each of the three domains.4Furthermore, we compare the proposed algorithm with IBM ILOG CP Optimizer (CPO) (Laborie et al. 2018) on a relaxed OAS problem.We do not compare the algorithm with CPO on the three original problems because CPO does not support the time-dependent setup constraints of the AEOSS problem and the TDOPTW problem and the special setup constraints (i.e., with the 'max' term) of the OAS problem well.More details about this can be found in "Comparison with CP optimizer" section.

Parameter setting
First, we provide the parameter setting of the algorithm for the three problems.The use of TS, the randomized operators, PSD, and FI is set according to the conclusions of the algorithmic analysis reported in "Algorithmic analysis" section.Other parameters such as the number of jobs to remove are set empirically through some exploratory experiments.Although these parameters are not optimal for all the instances, they provide relatively good solutions.The parameters are listed in Table 3.In Table 3, c a is the coefficient of annealing to update the temperature.The temperature at the i th iteration is T i = c a T i−1 .The three score increments are used for different performances of the selected operators: σ 3 is added to the score if a new best solution is found; σ 2 is added to the score if a new solution which is better than the current solution is found; σ 1 is added to the score if a new solution which is worse than the current solution is found, but it is accepted by the SA criterion.
Note that among all these parameters, only the maximum iteration and the use of the instant tabu are different on the three domains, which shows the robust performance of our algorithm on diverse problem instances.
The algorithm has two terminal conditions: when the maximum iteration is reached or when all the jobs are scheduled and get the full revenue (i.e., when the upper bound is reached).The maximum iteration is set so that the algorithm has similar runtime as its competing algorithms on the three domains.For the AEOSS problem, we set another terminal condition, when the solution is not improved for continuous 1000 iterations, because the algorithm converges fast on the AEOSS domain.

OAS problem
The ALNS/TPF algorithm is compared with state-of-theart algorithms including DRGA (Nguyen et al. 2015), LOS (Nguyen 2016), ABC (Lin and Ying 2013), HSSGA (Chaurasia and Singh 2017), EG/G-LS (Chaurasia and Singh 2017), and ILS (Silva et al. 2018).A MILP formulation by the CPLEX solver has been tested by Cesaret et al. (2012), which shows bad performance for large instances with more than 15 instances.Therefore we do not compare ALNS/TPF against CPLEX in this section.
Our ALNS/TPF is run on Intel Core i5 3.20 GHz CPU with 8GB memory, using a single core.The results of other methods are from the respective articles, which were obtained using different machines with Intel Core i5, i7 and Xeon CPU, 3.00-3.40GHz, 4-16 GB memory.Besides, unmen- tioned details such as cache size can have a significant effect on the runtime.Hence we do not report detailed CPU time.
On average, all the methods have comparable performance in terms of CPU time.According to the data reported in the references, ILS uses most time and ABC the least.
The solution quality of instances with 25-100 jobs are shown in Tables 4, 5 and 6. 5 Regarding the solution quality, we compare the gaps of these algorithms to the upper bounds by Cesaret et al. (2012).ALNS/TPF, TDRGA, LOS and ILS are run ten times on each of the instances.The average gaps of the ten runs for each instance are calculated first.Then for each group of instances with the same parameters, we calculate the minimum, average and maximum gaps of the ten instances in this group.The other three algorithms, ABC, HSSGA and EA/G-LS are run only once for each instance.Due to this, these methods can sometimes reach the optimal solution, resulting in a lower solution gap.DRGA and LOS only reported rounded-down integer values.But it is still obvious that ALNS/TPF produces the best solutions on nearly all the instances.

AEOSS problem
We compare the proposed ALNS/TPF with our previous algorithm called ALNS/TPI (He et al. 2018), the standard ALNS (Liu et al. 2017), the ILS algorithm (Peng et al. 2018), and an MIP model from He et al. (2018).We have obtained the source codes for the standard ALNS and the ILS algorithm from the corresponding authors.All algorithms are run on an Intel Core i5 3.20 GHz CPU, 8 GB memory, running Windows 7; only a single core is used.IBM ILOG CPLEX version 12.8 is used for MIP solving.A time limit of 3600 s is set for MIP solving, which uses more than 100x as much running time as ALNS/TPF does.The results for metaheuristics are the average of ten runs.
We compare the solution quality and the CPU time.The solution quality is the percentage of the total revenue of scheduled jobs (i.e., the objective value) divided by the total revenue of all the jobs.Table 7 shows the comparison of the five different algorithms.It shows that the CPU time of the ALNS/TPF increases slowly with the increasing number of jobs, and is about ten times faster than ILS, which is the fastest one among other algorithms.The solution quality is consistently higher than that of ILS, ALNS/TPI and ALNS.As expected, MIP by CPLEX can only find optimal solutions for small-size instances but performs badly when the instance size gets large.For the four small instances with optimal solutions by CPLEX, ALNS/TPF, ALNS/TPI and ILS also find the same optimal solution.Among all the methods, the standard ALNS performs the worst, consuming a long time to produce solutions with the lowest quality.Finally, Fig. 17 shows the anytime quality of different algorithms for the instance with 600 jobs distributed worldwide (CPLEX found no feasible solution within the time limit).
Then we study how the performance gaps between ALNS/TPF and other algorithms change with the increasing number of jobs.We evaluate the performance gap between an algorithm A and ALNS/TPF by the following formula:         We compare the solution quality and the CPU time.The solution quality is the percentage of the total revenue of scheduled jobs (i.e., the objective value) divided by the total revenue of all the jobs."Dis" is short for the distribution type The best results among the algorithms compared are highlighted in bold From Fig. 18 we can find that gaps between the performance of ALNS/TPF and those of other algorithms tend to grow when there are more jobs and when jobs are distributed densely (i.e., when the conflict among jobs is higher).The performance of the standard ALNS decreases quickly when the problem grows in size and our proposed ALNS/TPF performs well for large and difficult instances.

TDOPTW problem
The ALNS/TPF algorithm is compared with the ACS algorithm by Verbeeck et al. (2017).A MILP formulation by the CPLEX solver has been tested by Verbeeck et al. (2017), which shows bad performance for large instances with more than 20 instances.Therefore we do not compare ALNS/TPF against CPLEX in this section.
Our ALNS/TPF is run on Intel Core i5-3470 3.20 GHz CPU with 8GB memory, using a single core.For the ACS method, we present the results from the respective article.Since ACS was run on a high performance computing system (48 Intel Xeon processors and 384 GB memory), the runtime of the two algorithms cannot be compared directly.We do not report detailed CPU time here.
The solution quality of this problem is evaluated by the total revenue of the solution (i.e., the value of the objective function).The total revenue of instances with 25-100 jobs is shown in Table 8.ALNS/TPF produces the best solutions on all the instances.Besides, ALNS/TPF performs much better than ACS when the instances grow in size (i.e., more jobs and longer scheduling horizon).

Comparison with CP Optimizer
Finally, we compare ALNS/TPF with the state-of-the-art commercial optimizer for scheduling problems, the IBM ILOG CP Optimizer (CPO), which is widely used in scheduling problems and shown to be very effective for this class of problems (Laborie et al. 2018).
CPO has a global constraint propagator N oOverlap for setup constraints, which is very efficient (Laborie et al. 2018).However, N oOverlap does not support time-dependent constraints of the AEOSS problem and the TDOPTW problem and the 'max' term in the setup constraints of the OAS problem mentioned in "Problem datasets" section.It is possible to build a constraint programming model that reasons only locally on direct neighbours of jobs.However, such a model turned out to be too slow to be acceptable.According   The best results among the algorithms compared are highlighted in bold value of the objective function) and CPU time of ALNS/TPF and CPO on the relaxed problem, with time limit of ten minutes for each instance.Other settings are as in "OAS problem" section.In this experiment, we only run the algorithms on the first instance in each group of the OAS instances with 100 jobs and the same τ and R, because there are 10 instances in each group, and running the algorithms on all the instances takes too long time.The results of ALNS/TPF and CPO are shown in Table 9.The values of ALNS/TPF are the average of ten runs.It is clear that ALNS/TPF produces better solutions with less time compared with CPO.

Conclusions
The application of artificial intelligence techniques in the intelligent manufacturing industry offers a crucial opportunity to improve productivity and profit (Rao et al. 1999).
This article studied an important class of over-subscribed scheduling problems in the intelligent manufacturing industry, which is characterised by time-dependency and/or sequence-dependency with time windows.We developed a novel hybridization of adaptive large neighbourhood search (ALNS) and tabu search (TS).We further introduced randomized generic neighbourhood operators, a partial sequence dominance heuristic, and a fast insertion strategy to the ALNS-TS hybridization.A detailed analysis of the algorithmic features provided evidence that: (1) the insertion tabu and the removal tabu work better when the completion ratio is low, and the instant tabu works better when there are fewer jobs in the solution sequence; (2) the randomization strategy in the neighbourhood operators works well in terms of the solution quality and the running time; (3) the partial sequence dominance heuristic performs better when the problem instance grows in size, indicating that it helps to combine parts of different solutions, when the solution sequence gets long; and (4) the fast insertion strategy contributes most to the performance, but also consumes the most time compared with other features.
An extensive empirical study on three domains demonstrated that, compared with the state-of-the-art approaches, our proposed ALNS/TPF produces solutions with higher quality in less time.The proposed algorithm is an intermediate approach between general methods and problem-specific methods, which exhibits better efficiency in solving this class of scheduling problems and can be generalized to different problem domains easily.Our work also proves that tight ALNS and TS hybridization is an efficient method for this class of scheduling problems.We believe generalizing this algorithm to other similar scheduling problems such as the multi-machine scheduling problem and the vehicle routing problem is relatively straightforward, since these novel techniques are applicable on such problems with similar sequencing and selecting properties.
In this article, we reported the identified correlations between algorithmic features and problem properties.However, selecting the optimal algorithmic features for new problems remains difficult.A research challenge remaining for further work is to let the algorithm learn this automatically.We believe the combination of online machine learning and optimization is a promising research direction towards this goal.The algorithm could learn such correlations during the optimization process and uses this knowledge to tune itself towards different problem domains, so that it can be applied to a set of problems without careful customization.By publishing the source code of our algorithm and providing all problem instances, we aim to facilitate such further study of the use of artificial intelligence techniques for manufacturing, as well as the use of this algorithm for other real-world problem domains.

Algorithm 1 :35S
Overview of ALNS/TPF Input: Candidate job set: O Output: Best solution: S * 1 function ALNSTPF(O) 2 S I ← GenerateInitialSolution(O) 2 Set S I as the current and the best solution: S ← S I , S * ← S I 4 repeat Choose removal, insertion operators D i , R i based on weights 6 S ← R i (D i (S)) 7 S c ← GenerateCompoundSolution(S, S ) 8 if f (S c ) > f (S ) ∧ S c = S then 9

Fig. 2
Fig. 2 An example of partial sequence dominance

Algorithm 2 :
Process of constructing a compound solution Input: Current solution S, New solution S Output: Compound solution S c 1 function GenerateCompoundSoluion(S, S ) 2 S c ← ∅ 3 Partition S and S into two sets of partial sequences: S p and S p 4 for i ← 1 to #S p do 5 U ← Calculate the unit revenue of the i th partial sequence in S p 6 U ← Calculate the unit revenue of the i th partial sequence in S p S c to remove duplicate ones and start each job as early as possible 12 return S c

Fig. 4
Fig.4The improvement of solution quality (i.e., the value of the objective function) by the instant tabu for different numbers of jobs in the solution on the three problem domains ability that the new repaired solution is the same as the old solution is higher, and the instant tabu can prevent this.Overall, we conclude that it is better (although marginally so) to include the insertion tabu and the removal tabu for

Fig. 14 Fig. 15 Fig. 16
Fig.14The performance of ALNS/TP (no time slack) compared to the full ALNS/TPF algorithm on the TDOPTW problem Gap A = Solution Qualit y AL N S/T P F − Solution Qualit y A Solution Qualit y AL N S/T P F (10) 1

Fig. 17
Fig. 17 Anytime quality of different algorithms for the instance with 600 jobs distributed worldwide

Fig. 18
Fig. 18The gaps of different algorithms to ALNS/TPF on the AEOSS problem.Cplex can only find the optimal solution for four instances within the 3600 s time limit Min distance insertion (MDI)This operator tries to insert the jobs that are closest to the jobs in the solution.First, the shortest distance to the current solution (i.e., the shortest setup time to jobs in the current solution) of each candidate job is calculated.Then the jobs are sorted according to ascending nearest distance.The worst-case time complexity of this operator is O(n 2 ); Table 1 compares all the differences of the three problem domains we have noticed.
5. Late penalty: the OAS problem has a late penalty on the revenue of a job if it starts after its due time;

Table 1
ComparisonEarliest start time of t j max{b j , c i } + s i j max{b j , c i + s i j } max{b j , c i + s i j } is the immediate precursor of job o j .Let p i and p j be the start time, and c i and c j be the completion time of o i and o j respectively 6. Setup time: the setup time of the OAS problem is sequence-dependent, while the setup time of the other two is time-dependent; 7. The length of setup time: the length of setup time is evaluated by the average of setup time divided by the processing time of a job.Among the three problems, the TDOPTW problem has the longest setup times, and the OAS problem has the shortest setup times; 8. Triangle inequality: the setup times of the OAS problem are generated randomly, which means it does not follow the triangle inequality.The setup time from job o i to job o j might be longer than the time for the sequence o i , o k , o j .As a result, when removing a job for the OAS problem, the start time of the job after the removed job should be checked to maintain the feasibility; 9. Conflict of jobs: we use the formula in the max conflict removal operator to calculate the conflict of jobs.The TDOPTW problem has the highest conflict degree, and the AEOSS has the least; 10.Correlation among jobs: since the setup times of the OAS problem are generated randomly, there exists little correlation if two jobs are not adjacent in the solution.

Table 2
The difference between the performance of the removal and insertion tabu

Table 3
Parameter setting of the algorithm for the three problems

99.78 99.78 99.78 99.78 99.78 99.78 99.78 99.78 99.78 99.78 99.78
Cesaret et al. (2012)ed bySilva et al. (2018), we find it smaller than the gaps between their tight upper bounds and the upper bounds byCesaret et al. (2012)The best results among the algorithms compared are highlighted in bold

Table 9
Comparison between ALNS/TPF and CPO on relaxed OAS problem