No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Iterated greedy algorithms for customer order scheduling with dedicated machines
Abstract
The customer order scheduling problem has received much attention recently due to its relevance to real world applications. In this study, the minimization of the total completion time of customer orders is studied in a dedicated machine environment, i.e. each order consists of one job on each machine. Two iterated greedy algorithms are presented that make use of problem properties and apply a new local search as well as a new construction function. In a computational experiment, both algorithms outperform two state-of-the-art approaches and prove their suitability to solve the customer order scheduling problem with dedicated machines.
... Furthermore, Hazür et al. (2008) performed a comparative study of the performance of four different metaheuristics applied to the COSP in a single-machine environment. A metaheuristic that has been used in more recent COSP studies is the iterated greedy algorithm (IGA); see Wu et al. (2019), Wu et al. (2021), andHoffmann et al. (2022) for examples. ...
... Because of the good performance in Hoffmann et al. (2022), the six IGAs that we develop follow the concept of an IGA from that paper, which is called an IGN. For a general overview of the IGA, the reader is referred to Zhao et al. (2022). ...
... Each of the six IGAs uses four parameters: y, z, d min , and d max . As in Hoffmann et al. (2022), d min and d max were set to d min = 1 and d max = n 2 . The other two parameters were determined experimentally. ...
The customer order scheduling problem has garnered considerable attention in the recent scheduling literature. It is assumed that each of several customer orders consists of several jobs, and each customer order is completed only if each job of the order is completed. In this paper, we consider the customer order scheduling problem in a machine environment where each customer places exactly one job on each machine. The objective is to minimize the earliness–tardiness, where tardiness is defined as the time an order is finished past its due date, and earliness is the time a job is finished before its due date or the completion time of the corresponding order, whichever is later. Even though the earliness–tardiness criterion is an important objective for just-in-time production, this problem has not been studied in the context of the customer order scheduling problem. We provide a mixed-integer linear programming (MILP) formulation for this problem and derive multiple problem properties. Furthermore, we develop six different heuristics for this problem configuration. They follow the structure of the iterated greedy algorithm and additionally use a refinement function in which they differ. In a computational experiment, the algorithms were compared with each other and outperformed a solver solution of the MILP, which proves their ability to efficiently solve the problem configuration.
... Actual life manifestations of this machine setting are, e.g., the scenario where each machine is contracted to a specific agent (client) or that each machine can process only a specific product. Papers addressing parallel dedicated machines that were published recently include, for instance, Cheng et al., (2019), Lee and Jang (2019), Harbaoui and Khalfallah (2020), Cheng et al., (2021), Kim and Lee (2021), Módos et al., (2021), Demirtas (2022), Hoffmann et al., (2022), Hajji et al., (2023), Lee et al., (2023), Mor and Mosheiov (2024), and the overview of manufacturing systems by Dlamini et al. (2023). ...
We study scheduling problems on parallel dedicated machines and assume that a specific job can only be processed on one specific machine. We concentrate on solving scheduling problems involving convex resource allocation and address three of the most fundamental measures in scheduling theory, i.e., makespan, total load, and total weighted completion time. Firstly, we focus on position-independent workloads, and then we study the setting of general position-dependent workloads, i.e., the workloads are not restricted to be either monotone functions of the job positions or any specific functions. In all problems, we assume a common continuous and non-renewable (limited) resource and adapt known results from scheduling theory to solve the considered problems.
The dynamic nature of modern industries demands innovative strategies to tackle the challenges of customer order scheduling, particularly in environments characterized by fluctuating demands and constrained resources. This paper introduces a novel approach known as Dynamic Grouping for Customers Order Scheduling (DGCOS), a paradigm that leverages adaptive grouping and strategic optimization to enhance operational efficiency. DGCOS dynamically segments orders into clusters based on shared attributes such as delivery timelines, production requirements, and resource dependencies, enabling real-time adjustments and efficient resource allocation. By streamlining the decision-making process and integrating dynamic grouping computational techniques, DGCOS achieves significant reductions in delivery delays, enhances resource utilization, and fosters robust adaptability to unforeseen disruptions. Experimental results, derived from diverse problem instances, highlight the efficiency of the DGCOS in balancing operational constraints with customer satisfaction. The findings underscore the potential of DGCOS to redefine scheduling paradigms in dynamic and competitive business environments.
In this paper, we study the problem of multi-institutional regionalization of primary health care units. The problem consists of deciding where to place new facilities, capacity expansions for existing facilities, and demand allocation in a multi-institutional system to minimize the total travel distance from demand points to health care units. It is known that traditional exact methods as branch-and-bound are limited to solving small- to medium-size instances of the problem. Given that real world-instances can be large, in this paper we propose an iterated greedy algorithm with variable neighborhood descent search for handling large-scale instances. Within this solution framework, several methods are developed. A greedy constructive method and two deconstruction strategies are developed. Another interesting component is the exact optimization of a demand allocation subproblem that is obtained when the location of facilities is previously fixed. An empirical assessment using real-world data from the State of Mexico’s Public Health Care System is carried out. The results demonstrate the effectiveness of the proposed metaheuristic in handling large-scale instances.
Customer Order Scheduling Problem (COSP) with minimisation of the total completion time as the objective is NP-Hard. COSP has many applications that include the pharmaceutical and the paper industries. However, most existing COSP algorithms struggle to find very good solutions in large-sized problems. One key reason behind is that those algorithms are based on generic templates and as such lack problem specific structural knowledge. In this paper, we capture such knowledge in the form of heuristics and then embed those heuristics within constructive and perturbative search algorithms. In the proposed deterministic constructive search algorithm, we use processing times in various ways to obtain initial dispatching sequences that are later used in prioritising customer orders during search. We also augment the construction process with solution exploration. In the proposed stochastic perturbative search, we intensify its diversification phase by prioritising rescheduling of customer orders that are affected badly. Our tailoring of the search in this case is to make informed decisions when the search has lost its direction. On the contrary to that, in the intensification phase, we then take diversifying measures and use multiple neighbourhood operators randomly so that the search does not get stuck very quickly. Our experimental results show that the proposed algorithms outperform existing state-of-the-art COSP algorithms.
The problem addressed in this paper belongs to the topic of order scheduling, in which customer orders - composed of different individual jobs - are scheduled so the objective sought refers to the completion times of the complete orders. Despite the practical and theoretical relevance of this problem, the literature on order scheduling is not very abundant as compared to job scheduling. However, there are several contributions with the objectives of minimising the weighted sum of completion times of the orders, the number of late orders, or the total tardiness of the orders. In this paper, we focus in the last objective, which is known to be NP-hard and for which some constructive heuristics have been proposed. We intend to improve this state-of-the-art regarding approximate solutions by proposing two different methods: Whenever extremely fast (negligible time) solutions are required, we propose a new constructive heuristic that incorporates a look-ahead mechanism to estimate the objective function at the time that the solution is being built. For the scenarios where longer decision intervals are allowed, we propose a novel matheuristic strategy to provide extremely good solutions. The extensive computational experience carried out shows that the two proposals are the most efficient for the indicated scenarios.
In this paper, we study a customer order scheduling problem where a number of orders, composed of several product types, have to be scheduled on a set of parallel machines, each one capable to process a single product type. The objective is to minimise the sum of the completion times of the orders, which is related to the lead time perceived by the customer, and also to the minimisation of the work-in-process. This problem has been previously studied in the literature, and it is known to be NP-hard even for two product types. As a consequence, the interest lies on devising approximate procedures to obtain fast, good performing schedules. Among the different heuristics proposed for the problem, the ECT (Earliest Completion Time) heuristic by Leung et al (2005) has turned to be the most efficient constructive heuristic, yielding excellent results in a wide variety of settings. These authors also propose a tabu search procedure that constitutes the state-of-the-art metaheuristic for the problem.
We propose a new constructive heuristic based on a look-ahead mechanism. The computational experience conducted shows that it clearly outperforms ECT, while having both heuristics the same computational complexity. Furthermore, we propose a greedy search algorithm using a specific neighbourhood that outperforms the existing tabu search procedure for different stopping criteria, both in terms of quality of solutions and of required CPU effort.
Over the last decade, many metaheuristics have been applied to the flowshop scheduling problem, ranging from Simulated Annealing or Tabu Search to complex hybrid techniques. Some of these methods provide excellent effectiveness and efficiency at the expense of being utterly complicated. In fact, several published methods require substantial implementation efforts, exploit problem specific speed-up techniques that cannot be applied to slight variations of the original problem, and often re-implementations of these methods by other researchers produce results that are quite different from the original ones. In this work we present a new iterated greedy algorithm that applies two phases iteratively, named destruction, were some jobs are eliminated from the incumbent solution, and construction, where the eliminated jobs are reinserted into the sequence using the well known NEH construction heuristic. Optionally, a local search can be applied after the construction phase. Our iterated greedy algorithm is both very simple to implement and, as shown by experimental results, highly effective when compared to state-of-the-art methods.
We are interested in the problem of scheduling orders for different product types in a facility with a number of machines
in parallel. Each order asks for certain amounts of various different product types which can be produced concurrently. Each
product type can be produced on a subset of the machines. Two extreme cases of machine environments are of interest. In the
first case, each product type can be produced on one and only one machine which is dedicated to that product type. In the
second case, all machines are identical and flexible; each product type can be produced by any one of the machines. Moreover,
when a machine in this case switches over from one product type to another, no setup is required. Each order has a release
date and a weight. Preemptions are not allowed. The objective is minimizing the total weighted completion time of the orders.
Even when all orders are available at time 0, both types of machine environments have been shown to be NP-hard for any fixed
number (≥2) of machines. This paper focuses on the design and analysis of approximation algorithms for these two machine environments.
We also present empirical comparisons of the various algorithms. The conclusions from the empirical analyses provide insights
into the trade-offs with regard to solution quality, speed, and memory space.
We consider m machines in parallel with each machine capable of producing one specific product type. There are n orders with each one requesting specific quantities of the various different product types. Order j may have a release date rj and a due date dj. The different product types for order j can be produced at the same time. We consider the class of objectives ∑ fj(Cj) that includes objectives such as the total weighted completion time ∑ wjCj and the total weighted tardiness ∑ wjTj of the n orders. We present structural properties of the various problems and a complexity result. In particular, we show that minimizing ∑ Cj when m ≥ 3 is strongly NP-hard. We introduce two new heuristics for the ∑ Cj objective. An empirical analysis shows that our heuristics outperform all heuristics that have been proposed for this problem in the literature.
An iterated greedy algorithm (IGA) is a simple and powerful heuristic algorithm. It is widely used to solve flow-shop scheduling problems (FSPs), an important branch of production scheduling problems. IGA was first developed to solve an FSP in 2007. Since then, various FSPs have been tackled by using IGA-based methods, including basic IGA, its variants, and hybrid algorithms with IGA integrated. Up until now, over 100 articles related to this field have been published. However, to the best of our knowledge, there is no existing tutorial or review paper of IGA. Thus, we focus on FSPs and provide a tutorial and comprehensive literature review of IGA-based methods. First, we introduce a framework of basic IGA and give an example to clearly show its procedure. To help researchers and engineers learn and apply IGA to their FSPs, we provide an open platform to collect and share related materials. Then, we make classifications of the solved FSPs according to their scheduling scenarios, objective functions, and constraints. Next, we classify and introduce the specific methods and strategies used in each phase of IGA for FSPs. Besides, we summarize IGA variants and hybrid algorithms with IGA integrated, respectively. Finally, we discuss the current IGA-based methods and already-solved FSP instances, as well as some important future research directions according to their deficiency and open issues.
Note to Practitioners
—Many practical scheduling problems can be transformed into flow-shop scheduling problems (FSPs), most of which are NP-hard. In order to solve them in an industrial system setting, designing effective heuristics is important and practically useful and has, thus, attracted much attention from both researchers and engineers. As an easy and high-performance heuristic, an iterated greedy algorithm (IGA) is widely used and adapted to solve numerous FSPs. Its simple framework makes it easy to be implemented by practitioners, and its high performance implies its great potential to solve industrial scheduling problems. In this work, we aim to give practitioners a comprehensive overview of IGA and help them apply IGA to solve their particular industrial scheduling problems. We review the papers that solve FSPs with IGA-based methods, including basic IGA, its variants, and hybrid algorithms with IGA integrated. First, we provide practitioners with a tutorial on IGA, where an example for solving an FSP is introduced and an open platform is constructed. The platform collects and shares the related materials, e.g., open-source code, benchmarks, and website links of important papers. Then, we introduce various FSPs and specific designs of IGA-based methods. Finally, we discuss the current research and point out future research issues.
In this study, we propose an efficient optimization algorithm that is a hybrid of the iterated greedy and simulated annealing algorithms (hereinafter, referred to as IGSA) to solve the flexible job shop scheduling problem with crane transportation processes (CFJSP). Two objectives are simultaneously considered, namely, the minimization of the maximum completion time and the energy consumptions during machine processing and crane transportation. Different from the methods in the literature, crane lift operations have been investigated for the first time to consider the processing time and energy consumptions involved during the crane lift process. The IGSA algorithm is then developed to solve the CFJSPs considered. In the proposed IGSA algorithm, first, each solution is represented by a 2-D vector, where one vector represents the scheduling sequence and the other vector shows the assignment of machines. Subsequently, an improved construction heuristic considering the problem features is proposed, which can decrease the number of replicated insertion positions for the destruction operations. Furthermore, to balance the exploration abilities and time complexity of the proposed algorithm, a problem-specific exploration heuristic is developed. Finally, a set of randomly generated instances based on realistic industrial processes is tested. Through comprehensive computational comparisons and statistical analyses, the highly effective performance of the proposed algorithm is favorably compared against several efficient algorithms.
Note to Practitioners
—The flexible job shop scheduling problem (FJSP) can be extended and applied to many types of practical manufacturing processes. Many realistic production processes should consider the transportation procedures, especially for the limited crane resources and energy consumptions during the transportation operations. This study models a realistic production process as an FJSP with crane transportation, wherein two objectives, namely, the makespan and energy consumptions, are to be simultaneously minimized. This study first considers the height of the processing machines, and therefore, the crane lift operations and lift energy consumptions are investigated. A hybrid iterated greedy algorithm is proposed for solving the problem considered, and several problem-specific heuristics are embedded to balance the exploration and exploitation abilities of the proposed algorithm. In addition, the proposed algorithm can be generalized to solve other types of scheduling problems with crane transportations.
The customer’s order (CO) issues have received growing attention in the scheduling research community. In the CO design, a customer’s order consists of several components, and the processed orders are assigned to m parallel machines. The completion time of an order is assumed at the time at which all components in a customer’s order are finished. In the published articles, the processing times of all components were considered as fixed and known numbers in customer order scheduling problems. This assumption is indeed at odds in many real practical productions in which there exist a lot of relevant uncertainty factors; for example, machine may break down, the working situation may change, some operator’s performance may become instability, and so on. In such a situation, the processing times of given jobs are impropriate assumed as fixed and constant numbers. Thus, this article introduces a customer’s order scheduling problem on m parallel machines along with scenario-dependent processing times of all components and scenario-dependent due dates. Based on the worse case, the measurement rule is to find an appropriate policy to minimize the maximum total tardiness of given n customer’s orders across the possible scenarios among all possible schedules. In this study we derive several dominant rules and lower bounds used in a branch-and-bound method searching for exact solutions. Subsequently, we propose several heuristics and an iterated greedy algorithm with and without a population-based for finding approximate solutions. Finally, the computational results of all proposed algorithms are tested and reported.
This paper addresses the scheduling problem for customer orders on a set of unrelated parallel machines. Each order consists of multiple product types with various workloads that can be assigned to and processed by the machines. The objective is to minimise the total weighted completion time of all customer orders. Several optimality properties are developed, and an easily computable lower bound is established. Besides, for two important special cases, the corresponding optimal schedules are further provided. Inspired by these results, three heuristic algorithms are proposed, and their worst case performances are proved to be bounded. The effectiveness of the lower bound and the proposed algorithms are demonstrated through numerical experiments. This study brings new perspectives to the management of differentiated customers in complicated production environment.
The customer order scheduling problem is becoming a major topic in the research community, but the research regarding customer order scheduling problems with ready times remains relatively limited. This study examined an order scheduling problem with ready times where the measurement criterion was minimizing the total weighted completion time of all the given orders. To solve this intractable problem, we first derived several dominance rules and two lower bounds to use in a branch-and-bound method for finding an exact solution. We then modified five existing heuristics and adopted an iterative greedy (IG) algorithm to determine a near-optimal solution. Specifically, we used a fixed proportion of destruction and a linear function of destruction in the IG algorithm. Pairwise improvement was applied to all the proposed heuristics to achieve high-quality solutions, and we performed one-way analysis of variance and Fisher's least significant difference tests to evaluate and compare the performance of all the proposed algorithms.
An order scheduling problem arises in numerous production scheduling environments. Makespan, mean flow time, and mean tardiness are the most commonly discussed and studied measurable criteria in the research community. Although the order scheduling model with a single objective has been widely studied, it is at odds with real-life scheduling practices. In practice, a typical manager must optimize multiple objectives. A search of the literature revealed that no articles had addressed the issue of optimizing an order scheduling problem with multiple objectives. Therefore, an order scheduling model to minimize the linear sum of the total flowtime and the maximum tardiness is introduced in this study. Specifically, several dominance relations and a lower bound are derived to expedite the search for the optimal solution. Three modified heuristics are proposed for finding near-optimal solutions. A hybrid iterated greedy algorithm and a particle swarm colony algorithm are proposed to solve this problem. Finally, a computational experiment is conducted to evaluate the performances of all proposed algorithms.
This paper addresses the order scheduling problems under configurations of single batch machine and parallel batch machines. Each order consists of several kinds of jobs from different incompatible job families with specific quantities. The batch machine is able to handle a group of jobs simultaneously. Incompatible job families are considered. The objectives are to minimise the order makespan and total weighted order completion time. We prove that the problems with minimising order makespan can be solved in polynomial time for single batch machine and parallel batch machines. As for minimising the total weighted order completion time, efficient heuristic algorithms together with the worst-case analysis are proposed. Numerical results show that the proposed algorithms can achieve high-quality solutions.
The order scheduling problem is receiving increasing attention in the relatively new but creative area of scheduling research. In order scheduling, several orders are processed on multiple machines, and each order comprises multiple components. The order completion time is defined as the time at which all components in an order are completed. In previous studies, the processing times of all components were fixed in order scheduling problems. This is unreasonable because a steady decline in processing time usually occurs when the same task is performed repeatedly in practical situations. Therefore, we propose a multiple-machine order scheduling problem with a learning effect to minimize the total tardiness. We develop a branch-and-bound algorithm incorporating certain dominance rules and three lower bounds for obtaining the optimal solution. Subsequently, we propose simulated annealing, particle swarm optimization, and order-scheduling MDD algorithms for obtaining a near-optimal solution. In addition, the experimental results of all proposed algorithms are provided.
This paper presents a variable iterated greedy algorithm for solving the traveling salesman problem with time windows (TSPTW) to identify a tour minimizing the total travel cost or the makespan, separately. The TSPTW has several practical applications in both production scheduling and logistic operations. The proposed algorithm basically relies on a greedy algorithm generating an increasing number of neighboring solutions through the use of the idea of neighborhood change in variable neighborhood search (VNS) algorithms. In other words, neighboring solutions are generated by destructing a solution component and re-constructing the solution again with variable destruction sizes. In addition, the proposed algorithm is hybridized with a VNS algorithm employing backward and forward 1_Opt local searches to further enhance the solution quality. The performance of the proposed algorithm was tested on several benchmark suites from the literature. Experimental results confirm that the proposed algorithm is either competitive to or even better than the best performing algorithms from the literature. Ultimately, new best-known solutions are obtained for 38 out of 125 problem instances of the recently proposed benchmark suite, whereas 15 out of 31 problem instances are also further improved for the makespan criterion.
This paper considers the order scheduling problem to minimize total tardiness. The system is composed of multiple machines, and each order consists of multiple components, with each component being manufactured on a dedicated machine (specified in advance). The completion time of each order is represented by the time at which all the components comprising the order are completed. The tardiness minimization is the performance objective of this paper. In the problem analysis, this paper first derives some dominance properties to determine the sequence of some orders, and then analyzes problem complexities for some special cases. Three heuristic algorithms are derived with a performance bound. Moreover, three lower bounds of objective are derived and tested along with the derived properties in a branch-and-bound scheme. The overall performances of the proposed property, branch-and-bound and heuristic algorithms are evaluated via numerical experiments.
This paper addresses the problem of scheduling jobs in a permutation flowshop with the objective of minimizing the total tardiness of jobs. To tackle this problem, it is suggested that a procedure based on a greedy algorithm is employed that successively iterates over an increasing number of candidate solutions. The computational experiments carried out show this algorithm outperforms the best existing one for the problem under consideration. In addition, out some tests are carried out to analyse the efficiency of the adopted design.
In a general flow-shop situation, where all the jobs must pass through all the machines in the same order, certain heuristic algorithms propose that the jobs with higher total process time should be given higher priority than the jobs with less total process time. Based on this premise, a simple algorithm is presented in this paper, which produces very good sequences in comparison with existing heuristics. The results of the proposed algorithm have been compared with the results from 15 other algorithms in an independent study by Park [13], who shows that the proposed algorithm performs especially well on large flow-shop problems in both the static and dynamic sequencing environments.
The concurrent open shop problem is a relaxation of the well known open job shop problem, where the components of a job can be processed in parallel by dedicated, component specific machines. Recently, the problem has attracted the attention of a number of researchers. In particular, Leung et al. (2005) show, contrary to the assertion in Wagneur and Sriskandarajah (1993), that the problem of minimizing the average job completion time is not necessarily strongly NP-hard. Their finding has thus once again opened up the question of the problem's complexity. This paper re-establishes that, even for two machines, the problem is NP-hard in the strong sense.
This paper considers scheduling problems where jobs are dispatched in batches. The objective is to minimize the sum of the completion times of the batches. While a machine can process only one job at a time, multiple machines can simultaneously process jobs in a batch. This simple environment has a variety of real world applications such as part kitting and customer order scheduling.
A heuristic is presented for the parallel machine version of the problem. Also, a tight worst case bound on the relative error is found. For the case of two parallel machines, we examine two heuristics, which are based on simple scheduling rules. We find tight worst case bounds of 6/5 and 9/7 on the relative error and show that neither procedure is superior for all instances. Finally, we empirically evaluate these two heuristics. For large problems, the methods find solutions that are close to optimal.
Consider m identical machines in parallel, each of which can produce k different product types. There is no setup cost when the machines switch from producing one product type to another. There are n orders each of which requests various quantities of the different product types. All orders are available for processing at time t = 0, and preemption is allowed. Order i has a weight wi and its completion time is the time when its last requested product type finishes. Our goal is to find a preemptive schedule such that the total weighted completion time [summation operator]wiCi is minimized. We show that this problem is NP-hard even when all jobs have identical weights and there are only two machines. Motivated by the computational complexity of the problem, we propose a simple heuristic and show that it obeys a worst-case bound of 2 - 1/m. Finally, empirical studies show that our heuristic performs very well when compared with a lower bound of the optimal cost.