Makespan Problem Research Articles

New bounds for single-machine time-dependent scheduling with uniform deterioration

We consider the single-machine time-dependent scheduling problem with linearly deteriorating jobs arriving over time. Each job i is associated with a release time ri and a processing time pi(si)=αi+βisi, where αi,βi>0 are parameters and si is the job's start time. In this setting, the approximability of both single-machine minimum makespan and total completion time problems remains open. We develop new bounds and approximation results for the special case of the problems with uniform deterioration, i.e. βi=β, for each i. The main contribution is a O(1+1/β)-approximation algorithm for the makespan problem and a O(1+1/β2) approximation algorithm for the total completion time problem. Further, we propose greedy constant-factor approximation algorithms for instances with β=O(1/n) and β=Ω(n), where n is the number of jobs. Our analysis is based on an approach for comparing computed and optimal schedules via bounding pseudomatchings.

Hybrid Flow Shop Scheduling Problem with Energy Utilization using Non-Dominated Sorting Genetic Algorithm-III (NSGA-III) Optimization

Hybrid flow shop scheduling (HFS) is an on sought problem modelling for production manufacturing. Due to its impact on productivity, researchers from different backgrounds have been attracted to solve its optimum solution. The HFS is a complex dilemma and provides ample solutions, thus inviting researchers to propose niche optimization methods for the problem. Recently, researchers have moved on to multi-objective solutions. In real-world situations, HFS is known for multi-objective problems, and consequently, the need for optimum solutions in multi-objective HFS is a necessity. Regarding sustainability topic, energy utilization is mainly considered as one of the objectives, including the common makespan criteria. This paper presents the existing multi-objective approach for solving energy utilization and makespan problems in HFS scheduling using Non-Dominated Sorting Genetic Algorithm-III (NSGA-III), and a comparison to other optimization models was subjected for analysis. The model was compared with the most sought algorithm and latest multi-objective algorithms, Strength Pareto Evolutionary Algorithm 2 (SPEA -II), Multi-Objective Algorithm Particle Swarm Optimization (MOPSO), Pareto Envelope-based Selection Algorithm II (PESA-II) and Multi-objective Evolutionary Algorithm based on Decomposition (MOEA/D). The research interest starts with problem modelling, followed by a computational experiment with an existing multi-objective approach conducted using twelve HFS benchmark problems. Then, a case study problem is presented to assess all models. The numerical results showed that the NSGA-III obtained 50% best overall for distribution performance metrics and 42% best in convergence performance metrics for HFS benchmark problems. In addition, the case study results show that NSGA-III obtained the best overall convergence and distribution performance metrics. The results show that NSGA-III can search for the best fitness solution without compromising makespan and total energy utilization. In the future, these multi-objective algorithms’ potential can be further investigated for hybrid flow shop scheduling problems.

A scheduling mechanism for hybrid flow shops with reworks under general queue time limits

This study addresses multi-stage hybrid flow shop scheduling in which a job is reworked if the queue time between two arbitrary stages exceeds an upper limit. The problem is to determine the allocations of jobs to machines at each stage and the start times of jobs and rework setups/operations when incurred. A mixed integer programming model is proposed for each of the makespan and the total tardiness measures. Then, because the problem is NP-hard, a scheduling mechanism is proposed that consists of three phases: (a) filtering the jobs to be delayed; (b) searching the jobs to be reworked; and (c) dispatching non-delayed and delayed jobs sequentially. Simulation results show that the mechanism proposed in this study outperforms the conventional dispatching approach in the high rework setup time case for the makespan problem and low/high setup time cases for the tardiness problem. The best priority rules of the mechanism under each of the measures are also reported.

Multi-search-routes-based methods for minimizing makespan of homogeneous and heterogeneous resources in Cloud computing

Cloud computing, as a large-scale distributed computing system dynamically providing elastic services, is designed to meet the requirement of delivering computing services to users as subscription-oriented services. In general, the problems of resource scheduling in Cloud computing like minimizing makespan are usually NP-Hard problems. Various common algorithms including heuristic, meta-heuristic and machine learning are applied in resource scheduling of Cloud computing to obtain the solutions, which however are still probable and imperative to be optimized. Through innovatively applying heuristic algorithms namely LPT (Longest Processing Time) and BFD (Best Fit Decreasing) as the basic search routes and integrating these with neighborhood search algorithm namely OneStep, this paper proposes multi-search-routes-based algorithms containing LPT-OneStep, BFD-OneStep and their combinations for the sake of enhancing theoretical performance and improving solutions of scheduling schemes especially for problems of minimizing makespan for homogeneous and heterogeneous resources. Theoretical derivations prove that the proposed algorithms possess better theoretical approximation ratios for P||Cmax. Extensive experiments on simulation environment demonstrate the proposed algorithms outperform than corresponding compared algorithms for minimizing makespan problems in both homogenous resources and heterogeneous resources, which validates the superiority of the proposed algorithms.

Scheduling multiple two-stage flowshops with a deadline

Recently, motivated by applications in cloud computing, scheduling multiple two-stage flowshops with the objective of minimizing the makespan has drawn increasing attention. Motivated by the same applications, the current paper studies the problem of scheduling multiple two-stage flowshops with a deadline, with the objective of maximizing the profit of the jobs that can be completed by the deadline. Algorithms and complexity of the problem are investigated. For the case where the number of two-stage flowshops is part of the input, we present an efficient approximation algorithm with a constant ratio. The approximation ratio is improved via a study of the relationship between the problem and the multiple knapsack problem, combined with the recent progresses in the research in approximation algorithms for the multiple knapsack problem. By integrating techniques in the study of the classical Knapsack problem and the classical Makespan problem on multiple processors, plus additional new techniques, a polynomial-time approximation algorithm with a further improved approximation ratio is developed for the case where the number of flowshops is a fixed constant.

Modified Heuristics for Scheduling in Flow Shop to Minimize Makespan

The NP-completeness of flow shops scheduling problems has been discussed for many years. Hence many heuristics have been proposed to obtain solutions of good quality with a small computational effort. The CDS (Campbell et al) and NEH (Nawaz, Enscore and Ham) heuristics are efficient among meta-heuristics such as Particle Swarm Optimization (PSO) and Genetic Algorithm (GA).This paper discusses some methods and suggests new developing to the methods of the scheduling in flow shop to minimize makespan problems. Our main object in this paper, from one side, is to improve efficient heuristics which will be better than the existing heuristics given in the literature and yield solutions within a short time like Simple Heuristic Methods (SHM) and the First Heuristic Decreasing Arrange (DR). From other side, we apply two local search methods like GA and PSO algorithms on flow shop problems.Experimental analysis has been given of the performance of the proposed heuristics and local search methods with the relative efficient existing heuristics.

Single-Machine Scheduling Problems with the General Sum-of-Processing-Time and Position-Dependent Effect Function

This paper considers the combination of the general sum-of-processing-time effect and position-dependent effect on a single machine. The actual processing time of a job is defined by functions of the sum of the normal processing times of the jobs processed and its position and control parameter in the sequence. We consider two monotonic effect functions: the nondecreasing function and the nonincreasing function. Our focus is the following objective functions, including the makespan, the sum of the completion time, the sum of the weighted completion time, and the maximum lateness. For the nonincreasing effect function, polynomial algorithm is presented for the makespan problem and the sum of completion time problem, respectively. The latter two objective functions can also be solved in polynomial time if the weight or due date and the normal processing time satisfy some agreeable relations. For the nondecreasing effect function, assume that the given parameter is zero. We also show that the makespan problem can remain polynomially solvable. For the sum of the total completion time problem and a 1 is the deteriorating rate of the jobs, there exists an optimal solution for a 1 ≥ M ; a V-shaped property with respect to the normal processing times is obtained for 0 < a 1 ≤ 1 . Finally, we show that the sum of the weighted completion problem and the maximum lateness problem have polynomial-time solutions for a 1 > M under some agreeable conditions, respectively.

An Optimization Approach to Minimize the Expected Loss of Demand Considering Drone Failures in Drone Delivery Scheduling

This study proposes a drone-based delivery schedul- ing method considering drone failures to minimize the expected loss of demand (ELOD). An optimization model (DDS-F) is developed to determine the assignment of each drone to a subset of customers and the corresponding delivery sequence. Because solving the optimization model is computationally challenging, a Simulated Annealing (SA) heuristic algorithm is developed to reduce the computational time. The proposed SA features a fast initial solution generation based on the Petal algorithm, a binary integer programming model for path selection, and a local neigh- borhood search algorithm to find better solutions. Numerical results showed that the proposed approach outperformed the well-known Makespan problem in reducing the ELOD by 23.6% on a test case. Several case studies are conducted to illustrate the impact of the failure distribution function on the optimal flight schedules. Furthermore, the proposed approach was able to obtain the exact solutions for the test cases studied in this paper. Numerical results also showed the efficiency of the proposed algorithm in reducing the computational time by 44.35%, on average, compared with the exact algorithm.

Sparktope: linear programs from algorithms

In a recent paper, Avis, Bremner, Tiwary and Watanabe gave a method for constructing linear programs (LPs) based on algorithms written in a simple programming language called Sparks. If an algorithm produces the solution x to a problem in polynomial time and space then the LP constructed is also of polynomial size and its optimum solution contains x as well as a complete execution trace of the algorithm. Their method led us to the construction of a compiler called sparktope which we describe in this paper. This compiler allows one to generate polynomial sized LPs for problems in that have exponential extension complexity, such as matching problems in non-bipartite graphs. In this paper, we describe sparktope, the language Sparks, and the assembler instructions and LP constraints it produces. This is followed by two concrete examples, the makespan problem and the problem of testing if a matching in a graph is maximum, both of which are known to have exponential extension complexity. Computational results are given. In discussing these examples, we make use of visualization techniques included in sparktope that may be of independent interest. The extremely large linear programs produced by the compiler appear to be quite challenging to solve using currently available software. Since the optimum LP solutions can be computed independently they may be useful as benchmarks. Further enhancements of the compiler and its application are also discussed.

Closing the Gap for Makespan Scheduling via Sparsification Techniques

Makespan scheduling on identical machines is one of the most basic and fundamental packing problems studied in the discrete optimization literature. It asks for an assignment of n jobs to a set of m identical machines that minimizes the makespan. The problem is strongly NP-hard, and thus we do not expect a ([Formula: see text])-approximation algorithm with a running time that depends polynomially on [Formula: see text]. It has been recently shown that a subexponential running time on [Formula: see text] would imply that the Exponential Time Hypothesis (ETH) fails. A long sequence of algorithms have been developed that try to obtain low dependencies on [Formula: see text], the better of which achieves a quadratic running time on the exponent. In this paper we obtain an algorithm with an almost-linear dependency on [Formula: see text] in the exponent, which is tight under ETH up to logarithmic factors. Our main technical contribution is a new structural result on the configuration-IP integer linear program. More precisely, we show the existence of a highly symmetric and sparse optimal solution, in which all but a constant number of machines are assigned a configuration with small support. This structure can then be exploited by integer programming techniques and enumeration. We believe that our structural result is of independent interest and should find applications to other settings. We exemplify this by applying our structural results to the minimum makespan problem on related machines and to a larger class of objective functions on parallel machines. For all these cases, we obtain an efficient PTAS with running time with an almost-linear dependency on [Formula: see text] and polynomial in n.

On the extension complexity of scheduling polytopes

We study the minimum makespan problem on identical machines in which we want to assign a set of n given jobs to m machines in order to minimize the maximum load over the machines. We prove upper and lower bounds for the extension complexity of its linear programming formulations. In particular, we prove that the canonical formulation for the problem has extension complexity 2Ω(n∕logn), even if each job has size 1 or 2 and the optimal makespan is 2.

Two Parallel-Machine Scheduling Problems with Function Constraint

The objective of this paper is to minimize both the makespan and the total completion time. Since parallel-machine scheduling which contains the function constraint problem has been a new issue, this paper explored two parallel-machine scheduling problems with function constraint, which refers to the situation that the two machines have a same function but one of the machines has another. We pointed out that the function constraint occurs not only in the manufacturing system but also in the service system. For the makespan problem, we demonstrated that it is NP-hard in the ordinary sense. In addition, we presented a polynomial time heuristic for this problem and have proved its worst-case ratio is not greater than 5/4. Furthermore, we simulated the performance of the algorithm through computational testing. The overall mean percent error of the heuristic is 0.0565%. The results revealed that the proposed algorithm is quite efficient. For the total completion time problem, we have proved that it can be solved in On4 time.

Breaking symmetries to rescue sum of squares in the case of makespan scheduling

The Sum of Squares (SoS) hierarchy gives an automatized technique to create a family of increasingly tighter convex relaxations for binary programs. There are several problems for which a constant number of rounds give integrality gaps matching the best known approximation algorithm. In many other, however, ad-hoc techniques give significantly better approximation factors. The lower bounds instances, in many cases, are invariant under the action of a large permutation group. The main purpose of this paper is to study how the presence of symmetries on a formulation degrades the performance of the relaxation obtained by the SoS hierarchy. We do so for the special case of the minimum makespan problem on identical machines. Our first result is to show that a linear number of rounds of SoS applied over the configuration linear program yields an integrality gap of at least 1.0009. This improves on the recent work by Kurpisz et al. [30] that shows an analogous result for the weaker LS\(_+\) and SA hierarchies. Then, we consider the weaker assignment linear program and add a well chosen set of symmetry breaking inequalities that removes a subset of the machine permutation symmetries. We show that applying the SoS hierarchy for \(O_\varepsilon (1)\) rounds to this linear program reduces the integrality gap to \((1+\varepsilon )\). Our results suggest that the presence of symmetries were the main barrier preventing the SoS hierarchy to give tight relaxations.

The no-wait flow shop with rejection

We consider the no-wait flow shop scheduling problem with rejection. We first show how to augment the travelling salesman problem formulation for the no-wait flow shop minimum makespan problem to incorporate the rejection option. We then focus on polynomially solvable cases by considering problems with ordered jobs. We present a third-order polynomial-time dynamic programming algorithm to minimise the sum of makespan and total rejection cost and faster quadratic algorithms for two special cases. We also present a third-order polynomial-time dynamic programming algorithm to minimise the sum of total completion time and total rejection cost with ordered jobs. We also exploit the duality between no-wait and no-idle flow shops to determine which operations to outsource in a no-idle flow shop with an outsourcing option.

Improved Scheduling for the Three-Machine Proportionate Open Shop and Mixed Shop Minimum Makespan Problems

Open shop scheduling problems have many practical applications, in which the jobs can be in any order with the only restriction that their durations do not overlap with each other. In some cases, the order of a subset of jobs dictates the flow shop model while the remaining jobs can be processed in any order according to the open shop model, and the corresponding problem is called mixed shop scheduling. For every job, if its processing times on all machines are the same, then the shop is called proportionate shop. In this article we investigate the three-machine proportionate open shop and mixed shop minimum makespan problems proposed by Koulamas and Kyparisis. Our result improves the previous work in three ways. First, for both the open shop and the mixed shop scheduling problems, we derive additional sufficient conditions under which the corresponding problems are solvable in polynomial time. Second, for the non-solvable cases of the open shop scheduling problem we present an improved 13/12-approximation algorithm. Third, for the non-solvable cases of the mixed shop scheduling problem we present an improved approximation algorithm with the worst-case ratio bound of (7/6 + ϵ). All the algorithms proposed in this article run in polynomial time.

Improved approximation algorithms for two-stage flowshops scheduling problem

This paper considers the problem of scheduling n two-stage jobs on m two-stage flowshops so as to minimize the makespan. By studying the relationship between the problem and the classical makespan problem, we prove that if there is an α-approximation algorithm for the makespan problem, then for the general case of the problem, we can construct a 2α-approximation algorithm, and for two restricted cases which are of practical importance, we can construct an (α+1/2)-approximation algorithm. As a result, by employing the polynomial-time approximation scheme for the makespan problem, we get a (2+ϵ)-approximation algorithm for the general case and a (1.5+ϵ)-approximation algorithm for the two restricted cases, which significantly improve the previous approximation ratios 2.6 and 11/6 respectively.

New Bounds for Truthful Scheduling on Two Unrelated Selfish Machines

We consider the minimum makespan problem for n tasks and two unrelated parallel selfish machines. Let Rn be the best approximation ratio of randomized monotone scale-free algorithms. This class contains the most efficient algorithms known for truthful scheduling on two machines. We propose a new Min − Max formulation for Rn, as well as upper and lower bounds on Rn based on this formulation. For the lower bound, we exploit pointwise approximations of cumulative distribution functions (CDFs). For the upper bound, we construct randomized algorithms using distributions with piecewise rational CDFs. Our method improves upon the existing bounds on Rn for small n. In particular, we obtain almost tight bounds for n = 2 showing that |R2 − 1.505996| < 10− 6.

SINGLE-MACHINE SCHEDULING OF THE INDIVISIBLE MULTI-OPERATION JOBS

This paper considers a single-machine scheduling problem of multi- operation jobs where each job consists of several operations processed contiguously, rather than being intermingled with the operations of different jobs. That is, the jobs are indivisible. A sequence-independent setup is required if the machine switches from one operation to another. However, no setup is necessary before the first operation of a job if this first operation is the same as the last operation of the immediately previous job. A job is complete when all of its operations have been processed. We investigate the problem for two cases. Makespan, which is the time needed to complete all jobs, is minimised in the first case; whereas the total completion time, which is the sum of the job completion times, is minimised in the second case. We show that the makespan problem is solvable in polynomial time. For the problem of minimising total completion time, we develop a mixed integer linear programming (MILP) model, which is capable of solving small and medium-sized problem instances optimally, and obtain a very small gap between the solution found and the best possible solution for the unsolved large-sized problem instances.

Single machine and flowshop scheduling problems with sum-of-processing time based learning phenomenon

<p style='text-indent:20px;'>This paper addresses single machine and flowshop machines with the learning phenomenon. The learning phenomenon means that the actual jobs processing time of a job is a non-increasing function of the sum of processing times of jobs already processed. Under single machine, some properties firstly are presented to solve the objectives of minimizing the makespan problem, the total (weighted) completion time problem, the maximum lateness problem and the total tardiness problem. We show that minimizing the makespan problem and the total completion time problem can be solved in polynomial time. For the weighted completion time problem, the maximum lateness problem and the total tardiness problem, we give heuristic algorithm based on the corresponding optimal schedule and analyze the worst case error bound. Furthermore, we also show that the three problems are polynomially solvable under certain conditions. Under flowshop machines, we finally show that the makespan problem and the total completion time problem under more specialized proportional job processing times can be solved in polynomial time.

An improved PSO algorithm with genetic and neighborhood-based diversity operators for the job shop scheduling problem

ABSTRACTThe job shop scheduling problem (JSSP) is an important NP-hard practical scheduling problem that has various applications in the fields of optimization and production engineering. In this paper an effective scheduling method based on particle swarm optimization (PSO) for the minimum makespan problem of the JSSP is proposed. New variants of the standard PSO operators are introduced to adapt the velocity and position update rules to the discrete solution space of the JSSP. The proposed algorithm is improved by incorporating two neighborhood-based operators to improve population diversity and to avoid early convergence to local optima. First, the diversity enhancement operator tends to improve the population diversity by relocating neighboring particles to avoid premature clustering and to achieve broader exploration of the solution space. This is achieved by enforcing a circular neighboring area around each particle if the population diversity falls beneath the adaptable diversity threshold. The adaptive threshold is utilized to regulate the population diversity throughout the different stages of the search process. Second, the local search operator based on critical path analysis is used to perform local exploitation in the neighboring area of the best particles. Variants of the genetic well-known operators “selection” and “crossover” are incorporated to evolve stagnated particles in the swarm. The proposed method is evaluated using a collection of 123 well-studied benchmarks. Experimental results validate the effectiveness of the proposed method in producing excellent solutions that are robust and competitive to recent state-of-the-art heuristic-based algorithms reported in literature for nearly all of the tested instances.