Minimizing total weighted tardiness on a single machine with release dates and equal-length jobs

In this paper we study the problem of scheduling n jobs with release dates, due dates, weights, and equal processing times on a single machine. The objective is to minimize total weighted tardiness. We formulate the problem as a time-indexed ILP after which we solve the LP-relaxation. We show that for certain special cases (namely when either all due dates, all weights, or all release dates are equal, or when all due dates and release dates are equally ordered), the solution for the LP-relaxation is either integral or can be adjusted in polynomial time into an integral one. For the general case we present a branching rule that performs well. Furthermore we show that the same approach holds for the m identical, parallel machines variant of the problem. Finally we show that with a minor modification the same approach also holds for the single-machine problems of minimizing the sum of weighted late jobs (1|r _j ,p _j =p|∑w _j U _j ) and the sum of weighted late work (1|r _j ,p _j =p|∑w _j V _j ) as well as their respective variants with m identical, parallel machines. We further show how we can solve these problems by applying column generation when there is not sufficient memory available to apply the direct ILP-approach.     

Preemptive scheduling on uniform machines to minimize mean flow time

A set of jobs has to be scheduled on parallel uniform machines. Each machine can handle at most one job at a time. Each job becomes available for processing at its release date. All jobs have the same execution requirement, and each machine has a known speed. The processing of any job may be interrupted arbitrarily often and resumed later on any machine. We want to find a schedule that minimizes the sum of completion times, i.e., we consider problem Q|_rj,_pj=p,pmtn|∑_Cj$Q|r_j,p_j=p,\mathrm{pmtn}|\sum C_j$ whose complexity status was open. In this paper, we give a polynomial algorithm for the above problem. The algorithm is based on a reduction of the scheduling problem to a linear program. The crucial condition for implementing the proposed reduction is the known order of job completion times.     

Algorithms for some maximization scheduling problems on a single machine

In this paper, we consider two scheduling problems on a single machine, where a specific objective function has to be maximized in contrast to usual minimization problems. We propose exact algorithms for the single machine problem of maximizing total tardiness 1‖max-ΣT _j and for the problem of maximizing the number of tardy jobs 1‖maxΣU _j . In both cases, it is assumed that the processing of the first job starts at time zero and there is no idle time between the jobs. We show that problem 1‖max-ΣT _j is polynomially solvable. For several special cases of problem 1‖maxΣT _j , we present exact polynomial algorithms. Moreover, we give an exact pseudo-polynomial algorithm for the general case of the latter problem and an alternative exact algorithm.     

A note on the paper “Minimizing total tardiness on parallel machines with preemptions” by Kravchenko and Werner (2012)

In this note, we point out two major errors in the paper “Minimizing total tardiness on parallel machines with preemptions” by Kravchenko and Werner (2012). More precisely, they claimed to have proved that both problems P|pmtn|∑T _j and P|r _j ,p _j =p,pmtn|∑T _j are $\mathcal{NP}$ -Hard. We give a counter-example to their proofs, letting the complexity of these two problems open.     

Minimizing Makespan and Preemption Costs on a System of Uniform Machines

It is well known that for preemptive scheduling on uniform machines there exist polynomial time exact algorithms, whereas for non-preemptive scheduling there are probably no such algorithms. However, it is not clear how many preemptions (in total, or per job) suffice in order to guarantee an optimal polynomial time algorithm. In this paper we investigate exactly this hardness gap, formalized as two variants of the classic preemptive scheduling problem. In generalized multiprocessor scheduling (GMS) we have a job-wise or total bound on the number of preemptions throughout a feasible schedule. We need to find a schedule that satisfies the preemption constraints, such that the maximum job completion time is minimized. In minimum preemptions scheduling (MPS) the only feasible schedules are preemptive schedules with the smallest possible makespan. The goal is to find a feasible schedule that minimizes the overall number of preemptions. Both problems are NP-hard, even for two machines and zero preemptions. For GMS, we develop polynomial time approximation schemes, distinguishing between the cases where the number of machines is fixed, or given as part of the input. Our scheme for a fixed number of machines has linear running time, and can be applied also for instances where jobs have release dates, and for instances with arbitrary preemption costs. For MPS, we derive matching lower and upper bounds on the number of preemptions required by any optimal schedule. Our results for MPS hold for any instance in which a job, J_j, can be processed simultaneously by ρ_j machines, for some ρ_j ≥ 1.     

Single machine scheduling with unequal release date using neuro-dominance rule

A neuro-dominance rule (NDR) for single machine total weighted tardiness problem with unequal release date is presented by the author. To obtain the NDR, backpropagation artificial neural network (BPANN) has been trained using 10,000 data and also tested using 10,000 another data. Inputs of the trained BPANN are starting date of the first job (t), processing times (p_i and p_j), due dates (d_i and d_j), weights of the jobs (w_i and w_j) and r_i and r_j release dates of the jobs. Output of the BPANN is a decision of which job should precede. Training set and test set have been obtained using Adjusted Pairwise Interchange method. The proposed NDR provides a sufficient condition for local optimality. It has been proved that if any sequence violates the NDR then violating jobs are switched according to the total weighted tardiness criterion. The proposed NDR is compared to a number of competing heuristics (ATC, COVERT, EDD, SPT, LPT, WDD, WSPT, WPD, CR, FCFS) and meta heuristics (simulated annealing and genetic algorithms) for a set of randomly generated problems. The problem sizes have been taken as 50, 70, 100. NDR is applied 270,000 randomly generated problems. Computational results indicate that the NDR dominates the heuristics and meta heuristics in all runs. Therefore, the NDR can improve the upper and lower bounding schemes.     

Parallel batch scheduling of equal-length jobs with release and due dates

In this paper we study parallel batch scheduling problems with bounded batch capacity and equal-length jobs in a single and parallel machine environment. It is shown that the feasibility problem 1|p-batch,b<n,r _j ,p _j =p,C _j ≤d _j |− can be solved in O(n ²) time and that the problem of minimizing the maximum lateness can be solved in O(n ²log n) time. For the parallel machine problem P|p-batch,b<n,r _j ,p _j =p,C _j ≤d _j |− an O(n ³log n)-time algorithm is provided, which can also be used to solve the problem of minimizing the maximum lateness in O(n ³log ² n) time.     

A decomposition scheme for single stage scheduling problems

This paper introduces a general decomposition scheme for single stage scheduling problems with jobs that have arbitrary release dates. We assume that the objective function is monotone in the completion time of each job. The decomposition scheme has significant theoretical and practical relevance. When assuming equal processing times, we can reduce the number of steps required to solve several well-known nonpreemptive single machine scheduling problems by O(n³)\mathcal{O}(n^{3}), provided the processing time p is constant. Specifically, we develop new approaches that solve the problems 1|r _i ,p _i =p|∑f _i (C _i ) and 1|r _i ,p _i =p|∑w _i U _i in O(n⁴)\mathcal{O}(n^{4}) time; the algorithms that have been described in the literature for these problems operate in O(n⁷)\mathcal{O}(n^{7}). Moreover, solution approaches for NP\mathcal{NP}-hard problems with unequal processing times may also benefit from our decomposition rule. This is particularly true if p _max/p _min is close to 1. Using the decomposition rule, either the problem size is reduced or additional information about the maximal schedule length is obtained.     

A special case of the single-machine total tardiness problem is NP-hard

In this paper, it is shown that the special case B-1 of the single-machine total tardiness problem 1 ∥ ΣT _j is NP-hard in the ordinary sense. For this case, there exists a pseudo-polynomial algorithm with run time O(n σp _j). Published in Russian in Izvestiya Akademii Nauk. Teoriya i Sistemy Upravleniya, 2006, No. 3, pp. 120–128. Article was translated by the authors.     

Sequencing unreliable jobs on parallel machines

This paper addresses an allocation and sequencing problem motivated by an application in unsupervised automated manufacturing. There are n independent jobs to be processed by one of m machines or units during a finite unsupervised duration or shift. Each job is characterized by a certain success probability p _i , and a reward r _i which is obtained if the job is successfully carried out. When a job fails during processing, the processing unit is blocked, and the jobs subsequently scheduled on that machine are blocked until the end of the unsupervised period. The problem is to assign and sequence the jobs on the machines so that the expected total reward is maximized. This paper presents the following results for this problem and some extensions: (i) a polyhedral characterization for the single machine case, (ii) the proof that the problem is NP-hard even with 2 machines, (iii) approximation results for a round-robin heuristic, (iv) an effective upper bound. Extensive computational results show the effectiveness of the heuristic and the bound on a large sample of instances.     

A branch, bound, and remember algorithm for the 1|r i |∑t i scheduling problem

This paper presents a modified Branch and Bound (B&B) algorithm called, the Branch, Bound, and Remember (BB&R) algorithm, which uses the Distributed Best First Search (DBFS) exploration strategy for solving the 1|r _i |∑t _i scheduling problem, a single machine scheduling problem where the objective is to find a schedule with the minimum total tardiness. Memory-based dominance strategies are incorporated into the BB&R algorithm. In addition, a modified memory-based dynamic programming algorithm is also introduced to efficiently compute lower bounds for the 1|r _i |∑t _i scheduling problem. Computational results are reported, which shows that the BB&R algorithm with the DBFS exploration strategy outperforms the best known algorithms reported in the literature.     

Minimizing the number of late jobs in a stochastic setting using a chance constraint

We consider the single-machine scheduling problem of minimizing the number of late jobs. We omit here one of the standard assumptions in scheduling theory, which is that the processing times are deterministic. In this scheduling environment, the completion times will be stochastic variables as well. Instead of looking at the expected number of on time jobs, we present a new model to deal with the stochastic completion times, which is based on using a chance constraint to define whether a job is on time or late: a job is on time if the probability that it is completed by the deterministic due date is at least equal to a certain given minimum success probability. We have studied this problem for four classes of stochastic processing times. The jobs in the first three classes have processing times that follow: (i) A gamma distribution with shape parameter p _j and scale parameter β, where β is common to all jobs; (ii) A negative binomial distribution with parameters p _j and r, where r is the same for each job; (iii) A normal distribution with parameters p _j and σ _j ². The jobs in the fourth class have equally disturbed processing times, that is, the processing times consist of a deterministic part and a random component that is independently, identically distributed for each job. We show that the first two cases have a common characteristic that makes it possible to solve these problems in O(nlog n) time through the algorithm by Moore and Hodgson. To analyze the third and fourth problem we need the additional assumption that the due dates and the minimum success probabilities are agreeable. We show that under this assumption the third problem is -hard in the ordinary sense, whereas the fourth problem is solvable by Moore and Hodgson’s algorithm. We further indicate how the problem of maximizing the expected number of on time jobs (with respect to the standard definition) can be tackled if we add the constraint that the on time jobs are sequenced in a given order and when we require that the probability that a job is on time amounts to at least some given lower bound. Supported by EC Contract IST-1999-14186 (Project alcom-FT).     

The Expected Competitive Ratio for Weighted Completion Time Scheduling

A set of n independent jobs is to be scheduled without preemption on m identical parallel machines. For each job j, a diffuse adversary chooses the distribution F_j of the random processing time P_j from a certain class of distributions F_j. The scheduler is given the expectation μ_j = E[P_j], but the actual duration is not known in advance. A positive weight w_j is associated with each job j and all jobs are ready for execution at time zero. The scheduler determines a list of the jobs, which is then scheduled in a non-preemptive manner. The objective is to minimise the total weighted completion time ∑_j w_j C_j. The performance of an algorithm is measured with respect to the expected competitive ratio max_{F ∈ F} E[∑_j w_j C_j/OPT], where C_j denotes the completion time of job j and OPT the offline optimum value. We show a general bound on the expected competitive ratio for list scheduling algorithms, which holds for a class of so-called new-better-than-used processing time distributions. This class includes, among others, the exponential distribution. As a special case, we consider the popular rule weighted shortest expected processing time first (WSEPT) in which jobs are processed according to the non-decreasing μ_j/w_j ratio. We show that it achieves E[WSEPT/OPT] ≤ 3 – 1/m for exponential distributed processing times.     

Unrelated parallel machine scheduling with setup times using simulated annealing

This paper presents a scheduling problem for unrelated parallel machines with sequence-dependent setup times, using simulated annealing (SA). The problem accounts for allotting work parts of L jobs into M parallel unrelated machines, where a job refers to a lot composed of N items. Some jobs may have different items while every item within each job has an identical processing time with a common due date. Each machine has its own processing times according to the characteristics of the machine as well as job types. Setup times are machine independent but job sequence dependent. SA, a meta-heuristic, is employed in this study to determine a scheduling policy so as to minimize total tardiness. The suggested SA method utilizes six job or item rearranging techniques to generate neighborhood solutions. The experimental analysis shows that the proposed SA method significantly outperforms a neighborhood search method in terms of total tardiness.     

Efficient Approximation Schemes for Scheduling Problems with Release Dates and Delivery Times

We consider the problem of scheduling n independent jobs on m identical machines that operate in parallel. Each job must be processed without interruption for a given amount of time on any one of the m machines. In addition, each job has a release date, when it becomes available for processing, and, after completing its processing, requires an additional delivery time. The objective is to minimize the time by which all jobs are delivered. In the notation of Graham et al. (1979), this problem is noted P|r _j|L_max. We develop a polynomial time approximation scheme whose running time depends only linearly on n. This linear complexity bound gives a substantial improvement of the best previously known polynomial bound (Hall and Shmoys, 1989). Finally, we discuss the special case of this problem in which there is a single machine and present an improved approximation scheme.     

On the complexity of interval scheduling with a resource constraint

We consider a scheduling problem where jobs have to be carried out by parallel identical machines. The attributes of a job j are: a fixed start time s_j, a fixed finish time f_j, and a resource requirement r_j. Every machine owns R units of a renewable resource necessary to carry out jobs. A machine can process more than one job at a time, provided the resource consumption does not exceed R. The jobs must be processed in a non-preemptive way. Within this setting, the problem is to decide whether a feasible schedule for all jobs exists or not.We discuss such a decision problem and prove that it is strongly NP-complete even when the number of resources are fixed to any value R≥2. Moreover, we suggest an implicit enumeration algorithm which has O(nlogn) time complexity in the number n of jobs when the number m of machines and the number R of resources per machine are fixed.The role of storage layout and preemption are also discussed.     

Order Scheduling in an Environment with Dedicated Resources in Parallel

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 r_j and a due date d_j. The different product types for order j can be produced at the same time. We consider the class of objectives ∑ f_j(C_j) that includes objectives such as the total weighted completion time ∑ w_j C_j and the total weighted tardiness ∑ w_j T_j of the n orders. We present structural properties of the various problems and a complexity result. In particular, we show that minimizing ∑ C_j when m ≥ 3 is strongly NP-hard. We introduce two new heuristics for the ∑ C_j objective. An empirical analysis shows that our heuristics outperform all heuristics that have been proposed for this problem in the literature.     

Approximation Algorithms for Multiprocessor Scheduling under Uncertainty

Motivated by applications in grid computing and project management, we study multiprocessor scheduling in scenarios where there is uncertainty in the successful execution of jobs when assigned to processors. We consider the problem of multiprocessor scheduling under uncertainty, in which we are given n unit-time jobs and m machines, a directed acyclic graph C giving the dependencies among the jobs, and for every job j and machine i, the probability p _ij of the successful completion of job j when scheduled on machine i in any given particular step. The goal of the problem is to find a schedule that minimizes the expected makespan, that is, the expected time at which all of the jobs are completed.     

Non-approximability of just-in-time scheduling

We consider the following single machine just-in-time scheduling problem with earliness and tardiness costs: Given n jobs with processing times, due dates and job weights, the task is to schedule these jobs without preemption on a single machine such that the total weighted discrepancy from the given due dates is minimum. NP-hardness of this problem is well established, but no approximation results are known. Using the gap-technique, we show in this paper that the weighted earliness–tardiness scheduling problem and several variants are extremely hard to approximate: If n denotes the number of jobs and b∈ℕ is any given constant, then no polynomial-time algorithm can achieve an approximation which is guaranteed to be at most a factor of O(b ⁿ ) worse than the optimal solution unless P = NP.     

Optimal interval scheduling with a resource constraint

We consider a scheduling problem where n jobs have to be carried out by m parallel identical machines. The attributes of a job j are a fixed start time s_j, a fixed finish time f_j, a resource requirement r_j, and a value v_j. Every machine owns R units of a renewable resource necessary to carry out jobs. A machine can process more than one job at a time, provided the resource consumption does not exceed R. The jobs must be processed in a non-preemptive way. Within this setting, we ask for a subset of jobs that can be feasibly scheduled with the maximum total value. For this strongly NP-hard problem, we first discuss an approximation result. Then, we propose a column generation scheme for the exact solution. Finally, we suggest some greedy heuristics and a restricted enumeration heuristic. All proposed algorithms are implemented and tested on a large set of randomly generated instances. It turns out that the column generation technique clearly outperforms the direct resolution of a natural compact formulation; the greedy algorithms produce good quality solutions in negligible time, whereas the restricted enumeration averages the performance of the greedy methods and the exact technique.