Single Machine Scheduling Problems: Standard Settings and Properties, Polynomially Solvable Cases, Complexity and Approximability

Abstract

Since the publication of the first scheduling paper in 1954, a huge number of works dealing with different types of single machine problems have appeared. They addressed many heuristics and enumerative procedures, complexity results or structural properties of certain problems. Regarding surveys, often particular subjects like special objective functions were discussed or more general scheduling problems were surveyed, in which a substantial part was devoted to single machine problems. In this paper, we focus on standard settings, basic structural properties of these settings, polynomial algorithms and complexity and approximation issues, which have not been reviewed so far, and suggest some future work in this area.

1. Introduction

Scheduling problems arise in many real-life applications, including in our everyday life. We commonly desire to optimize our time by arranging different activities, where the time is limited and the resources that we use are also scarce. We wish to optimize some of our personal criteria, but we also depend on the availability of the above-mentioned resources. As a simple but very common daily example, consider an apartment with a single bathroom, where a small family lives. The family members get up at some fixed time, and all of them need to spend some time in the bathroom, which is a scarce resource (or machine). Typically such a (renewable) resource may serve a single object or job, a family member in our example. Every member of the family needs to leave the apartment at some fixed time to reach their job or school without delay. This time can be different for different members of the family. Here arises a small optimization problem that requires us to schedule the time interval for each member of the family in order to meet the deadline of each member of the family.

Generally, in a scheduling problem we are given jobs or tasks, which are requests that need to be performed by some resource, such as a machine or a processor. In our small example, the bathroom requirements for each member of the family are jobs and the bathroom is a machine. We can give a vast number of examples of jobs and machines in our practical life, e.g., a job in a factory or a software application on a computer or smart phone or a lesson at school. Here machines, computers, smart phones, classrooms and teachers are resource examples. Every job requires some time units on a resource, whereas a resource is able to process at most one job at a time. Indeed, one classroom cannot be used for two different classes simultaneously, or a teacher cannot give two or more classes at the same time. There is a restriction on the whole time window during which a factory or a teacher can work. It is a scheduling task to arrange the order for processing the jobs. Often, there is some minimization or maximization criterion called an objective function. For example, a very common criterion is to minimize the maximum job or machine completion time, called the makespan $C_{max}$.

In this paper, we consider single machine scheduling problems. These problems are important for some practical multi-machine scheduling applications. Often there exists a bottleneck machine in a manufacturing environment. If one can solve the scheduling problem on the bottleneck machine optimally, this is at least a very good base for the overall schedule. An intelligent solution method for a single machine scheduling problem may also lead to important insights for the solution of more general shop and multiprocessor scheduling problems. We concentrate our attention on standard settings, basic properties for these settings, polynomial-time algorithms and complexity and approximability issues. Regarding standard settings, most single machine scheduling problems are relatively easy for simultaneously released jobs given that no weight function is associated with the jobs. With non-simultaneously released jobs, single machine scheduling problems become more challenging and essentially more complicated. Here, we deal with such settings, where the jobs, besides release times, are characterized by due dates and consider due-date-oriented objective functions. We review the most important ideas, properties and approaches related to classical standard settings at the borderline between polynomial solvability/approximability on one side and complexity issues on the other side, where a review of the extensive literature on single machine scheduling that considers mostly offline settings is still missing.

Most of the results we review were obtained after the early seminal works by Lenstra et al. [1] and Chen et al. [2], which covered a wide range of scheduling problems, including those on one machine. In general, there is a huge number of papers dealing with single machine problems. Since the publication of [1,2], surveys are mostly restricted to special subjects and/or consider more general problem settings. As an example, there exist three very detailed surveys on scheduling problems with setup times or costs, see [3,4,5]. For problems with so-called p-batching (i.e., several jobs can be processed in parallel in a batch), a survey was given by Fowler and Mönch [6]. The case of equal processing times was surveyed by Kravchenko and Werner [7]. Recently, several works have dealt with single machine problems with learning effects. The first paper on this subject was given by Briskorn [8]; for a survey on learning effects and periodic maintenance, see [9]. The paper by Koulamas and Kyparisis [10] reviews different kinds of dynamic programming algorithms for single machine scheduling problems. Other surveys on single machine problems deal with particular objective functions. As a few examples, we can mention, e.g., a survey on the total weighted tardiness problem [11] and on the weighted number of tardy jobs problem [12]; for more general problems, we mention a survey on scheduling with late work criteria [13] or more recently on early and late work scheduling [14], where a substantial part is dedicated to single machine scheduling. While mostly a minimization problem is considered, Gafarov et al. [15] reviewed algorithms and complexity issues for single machine maximization problems.

In Section 2, we study general structural properties of feasible schedules. These properties have been used for the construction of polynomial-time algorithms, and they may further be useful to build new efficient algorithms for both polynomially solvable and open versions of scheduling problems with job release and due times in general. Then in Section 3, we discuss polynomial algorithms, complexity and approximability issues, implicit enumeration algorithms and lower bounds for due-date-oriented objective functions with an emphasis on the classical maximum job lateness objective function. We also outline some subjects for future research, which includes in part more general multi-machine scheduling problems. This paper ends with concluding remarks in Section 4.

In

Table 1. Overview of exact algorithms.

Problem	Time Complexity	Reference
Section 3.1
$1\left|r_j\right|L_{max}$	Exponential in n	McMahon and Florian [16]
$1\left|r_j\right|D_{max}$	Exponential in n	Carlier [17]
$1\left|r_j\right|D_{max}$	Exponential in n	Pan and Shi [18]
$1\left|r_j\right|D_{max}$	$O(\nu !nlogn)$ (Exponential in $\nu$)	Vakhania [19]
$1|r_j=r|L_{max}$	$O(nlogn)$	Jackson [20]
$1|d_j=d|L_{max}$	$O(nlogn)$	Jackson [20]
$1|r_j,p_j=1|L_{max}$	$O(nlogn)$	Horn [21]
$1|r_j,pmtn|L_{max}$	$O(nlogn)$	Horn [21]
$1|r_j,p_j=p|L_{max}$	$O(nlogn)$	Garey et al. [22]
$1|p_j\in \{p,2p\},r_j|D_{max}$	$O(n^{2}lognlogp)$	Vakhania [23]
$1|r_j,div|D_{max}$	$O(n^{2}lognlog{p}_{max})$	Vakhania [24]
$1|p_{max}\le P\left(n\right),|r_j-r_i|<R|L_{max}$	$O(n^{k+1}lognlog{p}_{max})$	Vakhania and Werner [25]
$1|r_j,p_j=p|C_{max},L_{max}$	$O(n^{3}logn)$	Lazarev et al. [26]
$1|r_j,embedded|L_{max}$	$O(nlogn)$	Vakhania [27]
$1|r_j\in \{r_1,r_2\},d_j\in \{d_1,d_2\}|L_{max}$	$O(nlogn)+SUBSETSUM$	Reynoso and Vakhania [28]
$1|r_j,prec,pmtn|f_{max}$	$O(nlogn)$	Azharonok et al. [29]
Section 3.2.1
$1|r_j|\sum U_j$	$O(n^{3}logn)$	Vakhania [30]
$1|r_j;p_j=p|\sum U_j$	$O(n^{3}logn)$	Vakhania [30]
Section 3.2.2
$1|r_j;pmtn|\sum U_j$	$O\left(n^5\right)$	Lawler [31]
$1|r_j;pmtn|\sum U_j$	$O\left(n^4\right)$	Baptiste [32]
$1|r_j;pmtn|\sum U_j$	$O\left(n^3\right)$	Vakhania [33]
Section 3.3
$1|r_j;p_j;pmtn|\sum w_j{U}_j$	$O\left(n^{10}\right)$	Baptiste [34]
$1|r_j;p_j;pmtn|\sum w_j{U}_j$	$O\left(n^4\right)$	Baptiste et al. [35]
Section 3.5
$1|r_j,p_j=p|\sum w_j{T}_j$ Ordered weights	$O\left(n^9\right)$	Gafarov et al. [36]
$1\left|\left(nd\right)\right|\sum T_j$	$O\left(n^2\right)$	Gafarov et al. [15]
Section 3.7
$1|r_j,p_j=1,e_j|L_{max}$	$O(nlogn)$	Ramirez et al. [37]
$1|rm=1,p_j=1|L_{max}$	$O(n^{2}logn)$	Grigoriev et al. [38]

and Table 2, we summarize most of the reviewed works concerning exact and approximation algorithms for single machine scheduling problems. We refer to the particular sections where the corresponding algorithms are discussed. In the time complexity expressions, the variable n stands for the total number of jobs, while additional parameters are defined in the corresponding subsections. The criterion $D_{max}$ is defined in the following subsection.

Since for the borderline problems between polynomial solvability/approximability we outline here heuristic and meta-heuristic algorithms are usually not applied, we do not discuss the big variability of such algorithms for single machine problems. For the interested reader, we mention that for more general $NP$-hard single machine problems, the standard meta-heuristic techniques are applied. In the recent literature, one can find papers dealing with a genetic algorithm (see, e.g., [39]), both simulated annealing and tabu search (see [40]), ant colony optimization (see, e.g., [41]), variable neighborhood search (see, e.g., [42] or [43]), iterated local search (see [44]), differential evolution (see, e.g., [45]), the meerkat clan algorithm and bald eagle search (see [46]) or gray wolf optimization (see [47]). In addition, particular meta-heuristics have been developed, e.g., for stable scheduling on a single machine [48], a self-adaptive meta-heuristic for the problem with flexible and variable maintenance [49] or a data-driven heuristic combining machine learning with problem-specific characteristics [50], to name a few.

Table 2. Overview of approximation algorithms.

Problem	Time Complexity	Reference	Approximation Factor
Section 3.1
$1\left|r_j\right|D_{max}$	$O(nlogn)$	Schrage [51]	2
$1\left|r_j\right|D_{max}$	$O(n^{2}logn)$	Potts [52]	$3/2$
$1\left|r_j\right|D_{max}$	$O(nlogn)$	Nowicki and Smutnicki [53]	$3/2$
$1\left|r_j\right|D_{max}$	$O(n^{2}logn)$	Hall and Shmoys [54]	$4/3$
$1\left|r_j\right|D_{max}$	$O\left({16}^k{\left(nk\right)}^{3+4k}\right)$	Hall and Shmoys [54]	$(1+1/k)$ (PTAS)
$1\left|r_j\right|D_{max}$	$O(nlogn+n{\left(4k\right)}^{8k^2+8k+2})$	Hall and Shmoys [54]	$(1+1/k)$ (PTAS)
$P\left|r_j\right|D_{max}$	$O(n+k^{O\left(k\right)})$	Mastrolilli [55]	$(1+1/k)$ (PTAS)
$1\left|r_j\right|D_{max}$	$O(\kappa !{\kappa }_{1.1}{n}^{2}logn)$	Vakhania [19]	$(1+1/k)$ (PTAS)
Section 3.6
$1\left|r_j\right|D_{max}$$Online$$version$	$O(nlogn)$	Hoogeveen and Vestjens [56]	$(\sqrt{5}+1)/2\approx 1.61803$

Table 2. Overview of approximation algorithms.

Problem	Time Complexity	Reference	Approximation Factor
Section 3.1
$1\left|r_j\right|D_{max}$	$O(nlogn)$	Schrage [51]	2
$1\left|r_j\right|D_{max}$	$O(n^{2}logn)$	Potts [52]	$3/2$
$1\left|r_j\right|D_{max}$	$O(nlogn)$	Nowicki and Smutnicki [53]	$3/2$
$1\left|r_j\right|D_{max}$	$O(n^{2}logn)$	Hall and Shmoys [54]	$4/3$
$1\left|r_j\right|D_{max}$	$O\left({16}^k{\left(nk\right)}^{3+4k}\right)$	Hall and Shmoys [54]	$(1+1/k)$ (PTAS)
$1\left|r_j\right|D_{max}$	$O(nlogn+n{\left(4k\right)}^{8k^2+8k+2})$	Hall and Shmoys [54]	$(1+1/k)$ (PTAS)
$P\left|r_j\right|D_{max}$	$O(n+k^{O\left(k\right)})$	Mastrolilli [55]	$(1+1/k)$ (PTAS)
$1\left|r_j\right|D_{max}$	$O(\kappa !{\kappa }_{1.1}{n}^{2}logn)$	Vakhania [19]	$(1+1/k)$ (PTAS)
Section 3.6
$1\left|r_j\right|D_{max}$$Online$$version$	$O(nlogn)$	Hoogeveen and Vestjens [56]	$(\sqrt{5}+1)/2\approx 1.61803$

Basic Notation and Terminology

We shall denote the given set of n jobs by $\{1,2,\dots ,n\}$. A schedule S prescribes to each job j the starting time $s_j^S$ on the machine (creating in this way a total order on the set of jobs by sequencing the jobs on the machine). Problem restrictions on the way in which the jobs are to be performed by the machine define the set of feasible schedules. For example, a machine can process at most one job simultaneously; the precedence relations defined on the set of jobs restrict the relative order in which the jobs can be scheduled. Scheduling problems are sometimes referred to as sequencing problems since the jobs need to be scheduled in a sequential manner (as no job overlapping is permitted). The precedence relations between the jobs can be represented by directed graphs, which are often referred to as precedence (task) graphs. In such graphs, nodes represent jobs, and there is an arc $(i,j)$ if and only if job i immediately precedes job j.

Job preemptions might be allowed or not. In a preemptive scheduling problem, a job can be interrupted and later resumed on the machine. In a non-preemptive scheduling problem, job j, once scheduled on the machine, should be processed without any interruption until its full completion on that machine. The machine is called idle at some moment t if no job is processed by the machine at that moment, otherwise it is said to be busy.

Job j, once scheduled on the machine, needs the processing time $p_j$ on that machine. Thus, if this job is processed without any interruption, its completion time on the machine in the schedule S is $c_j^S=s_j^S+p_j$. Since basically all scheduling problems imply resource restrictions, in any feasible schedule S, if job j is scheduled on the machine, then $s_j^S\ge s_i^S+p_i$ for any job i scheduled earlier on the machine in the schedule S.

Besides the processing time, job j may possess additional parameters (job parameters can normally be assumed to be non-negative integral numbers). For example, the time moment when it becomes available to be processed by the machine is called its release or readiness time and is commonly denoted by $r_j$. Thus, $s_j^S\ge r_j$, for any feasible schedule S and any job j. The due date $d_j$ of job j is the “desirable” completion time of job j on the machine. It is a common situation in real-life applications that it is desirable for a job to be completed by some date, as otherwise it becomes less important.

With job due dates, the quality of a solution is measured by a due-date-oriented objective function. We can judge the urgency of a job j based on its slack $d_j-r_j-p_j$: the earliest job j can be started is at time $r_j$, and hence, the earliest it can be completed is at time $r_j+p_j$. If $r_j+p_j>d_j$, then there is no feasible schedule in which job j completes by its due date. Otherwise, the tighter $d_j$ is, equivalently, the less slack of job j is and the more urgent it is.

In some cases, we impose the condition that job j cannot be completed after its due date. Then the term deadline instead of “due date” is commonly used; in a feasible schedule, every job is to be completed by its deadline (in some applications, job deadlines are important since if a job is not completed by its deadline, then its benefit or functionality becomes negligible). Thus, if job deadlines are given, our objective is to find a feasible schedule, one in which all jobs are completed before or at their deadlines on the machine.

In a number of applications, a job, once completed by the machine, needs to be delivered to the customer. The delivery is carried out by an independent transportation unit, which is not a scarce resource in a given scenario. The delivery time of job j is commonly denoted by $q_j$. On the one hand, job delivery takes no machine time. On the other hand, $q_j$ contributes to the full completion time of job j: In a given schedule S, the full completion time of job j is $C_j^S=c_j^S+q_j$ (whereas $c_j^S$ is the completion time of job j on the machine in that schedule). Thus, the full completion time of a job depends on both, its completion time on the machine and its delivery time. Job due-dates and delivery times are alternative job parameters in the sense that they typically are not present together. With job delivery times, one wishes to minimize maximum job full completion time, whereas with job due-dates one wishes to minimize some due-date-oriented objective function (see below).

Concerning the objectives, an optimal schedule is a feasible schedule which minimizes or maximizes a given objective (goal) function. With job due dates, for example, our objective can be to minimize or maximize some due-date-oriented objective function. For example, let the lateness of a job in schedule S be $L_j\left(S\right)=c_j^S-d_j$, i.e., it is the difference between the completion time of job j on the machine and its due date. One of the common due-date-oriented objective functions is the maximal job lateness $L_{max}$ (which is to be minimized). Another such common objective function that is to be minimized is $\sum U_j$, the number of late jobs, ones completed on the machine after their due dates ($U_j$ is a 0–1 variable indicating whether job j is completed on time or not completed on time on the machine in a given schedule). We may allow the omission of some jobs in the case when the total workload is more than the machine capacity, maximizing the throughput, which is the number of jobs completed on time, i.e., before or at their due dates. We may also consider more general criteria to maximize some profits. The profit of job j can be expressed by its weight, commonly denoted by $w_j$.

If jobs have no due dates and no delivery times, then one typically wishes to minimize the maximum job completion time on the machine, the makespan $C_{max}={max}_j{c}_j$. If jobs have delivery times (then the full completion time of every job with a positive delivery time is more than its completion time on the machine), the makespan is defined as the maximum job full completion time $C_{max}={max}_j{C}_j$. With job delivery times, to avoid a possible confusion between two job completion times $c_j$ and $C_j$, recently Jan Karel Lenstra [57] suggested to use $D_j=c_j+q_j$ (instead of $C_j$) for the full completion time of job j. With this notation, one wishes to minimize $D_{max}={max}_j{D}_j$. This extends the three-field notation introduced much earlier by Graham, Lawler, Lenstra and Rinnooy Kan [58], a commonly used way to abbreviate scheduling problems. In this notation, the first, the second and the third fields define the machine environment, the job characteristics and the objective function, respectively. For example, for the single machine scheduling problems considered here, a “1” is used in the first field; the problem with job release times and due dates to minimize the maximum job lateness is abbreviated by $1\left|r_j\right|L_{max}$; and the problem with job release and delivery times to minimize the maximum job full completion time can be expressed either by $1|r_j,q_j|C_{max}$ or by using the new notation [57] it can alternatively be expressed by $1\left|r_j\right|D_{max}$. Notice that we omit the parameters $d_j$ and $q_j$ in the $1\left|r_j\right|L_{max}$ and $1\left|r_j\right|D_{max}$ notations, respectively, which are implicitly assumed to be present; the use of $L_{max}$ implies that due dates $d_j$ have been specified, and the use of $D_{max}$ implies that delivery times $q_j$ have been specified. Note that both job delivery times and due dates specify the urgency of job j: the larger $q_j$ is, the more urgent job j is (as its delivery will take a “considerable time”); in contrast, the less $d_j$ is, the more urgent job j is (as it has a “small” slack).

The mathematical equivalence of the two above settings $1\left|r_j\right|L_{max}$ and $1\left|r_j\right|D_{max}$ ($1|r_j,q_j|C_{max}$) is established by letting $q_j=-d_j$ for all j. We can avoid a slightly unnatural due-date negativity constraint considering an alternative setting, which is practically intuitive. We can still conserve non-negative job due dates by the following transformation from an instance of the problem $1|r_j,q_j|C_{max}$ ($1\left|r_j\right|D_{max}$) to an equivalent instance of the problem $1\left|r_j\right|L_{max}$. Let K be a large constant, say, no less than the maximum job delivery time, and let the due date of each job j be $d_j=K-q_j$. Vice versa, given an instance of problem $1\left|r_j\right|L_{max}$, an equivalent instance of the problem $1|r_j,q_j|C_{max}$ ($1\left|r_j\right|D_{max}$) is obtained by letting $q_j=D-d_j$ for a large constant D no less than the maximum job due date. It is easy to see that whenever the makespan for the version $1|r_j,q_j|C_{max}$ is minimized, the maximum job lateness in the problem $1\left|r_j\right|L_{max}$ is minimized, and vice versa, see an early paper by Bratley et al. [59] for the details. It should be noted that, for the approximation purposes, the setting $1\left|r_j\right|L_{max}$ is inappropriate as the maximum job lateness in a schedule can be positive, negative or even 0. However, the problem $1\left|r_j\right|L_{max}$ can be approximated via its alternative formulation $1\left|r_j\right|D_{max}$ (see Section 3.1).

2. Some Basic Concepts and Properties

In this section, we give some basic concepts and schedule properties that have been used in the study of single machine scheduling problems. Single machine scheduling problems are trivial if every job has a single parameter, its processing time. For minimizing the makespan, it suffices to schedule the jobs in any order without leaving a machine with idle time or a gap: a gap on a machine is the longest time interval during which this machine is idle, i.e., it processes no job. A block is a consecutive part in a schedule which is preceded and succeeded by a gap.

Thus, from any permutation of n jobs, an optimal makespan schedule can be constructed in linear time by assigning the jobs from that permutation without leaving any idle time interval on the machine. In particular, if all jobs are simultaneously released, any non-idle time schedule minimizes the makespan $C_{max}$. Single machine scheduling problems get less trivial if jobs are not simultaneously released, i.e., they have individual release times. Then, to minimize the makespan, we just need to keep the machine busy whenever this is possible. This goal will be achieved if we just order the jobs according to non-decreasing release times and include them in this order without leaving any avoidable gap. This procedure will take $O(nlogn)$ time due to the preprocessing step.

Minimizing maximum job lateness $L_{max}$ is a bit more complex. If only the job due dates are given (all the jobs being released at time 0), the venerable ED-heuristic (earliest due date) obtains an optimal schedule, minimizing maximum job lateness by scheduling the jobs in non-decreasing order of their due dates without any idle time intervals (we describe this optimization algorithm later in more detail). Vice versa, if only job release times are given, the earliest release time (ER) heuristic generates an optimal makespan schedule. In that algorithm, initially, the minimum job release time is assigned to the current scheduling time, and any job released at that time is assigned to the machine. Iteratively, the next scheduling time is defined as the maximum between the completion time of the latest-so-far-assigned job and the minimum release time taken among the yet unscheduled jobs. Again, any (unscheduled) job released at the current scheduling time is assigned to the machine.

Because of the job release times, a schedule created by the ER-heuristic may contain a gap. However, it may contain no gap that might be avoided. In particular, the total gap length in such a schedule is the minimal possible one. We can also use this heuristic if all the jobs have a common due date d. In other words, all jobs are equally urgent. Then, as is easy to see, an optimal schedule minimizing the maximum job lateness contains no gap that might be avoided, and it has the minimum possible total gap length. Therefore, the ER-heuristic also minimizes the maximum job lateness.

It is easy to see that the ER-heuristic will not further minimize the maximum job lateness even if only two possible job due dates are allowed. For example, consider an instance with two jobs, job 1 released at time 0 and having the due date 11 and job 2 released at time 1 with the due date 6. The ER-heuristic will assign job 1 to the time interval $[0,5)$ and job 2 to the time interval $[5,10)$, resulting in a maximum job lateness of 4 (that of job 2). Observe that this schedule contains no gap. At the same time, an optimal schedule does contain a gap $[0,1)$: it assigns job 2 to the time interval $[1,6)$ and then job 1 to the time interval $[6,11)$, completing both jobs on time with the maximum job lateness equal to 0.

If with job release times and due dates job preemptions are allowed, then we have a simple method to solve the problem optimally and even online. We usually start at the earliest job release time and initially set the current time t to that magnitude. Iteratively, among the available jobs, we schedule the next most urgent job, one with the smallest due date (or the maximum delivery time for the problem $1\left|r_j\right|D_{max}$). However, if during the execution of that job another more urgent job gets released, the former job is interrupted at the release time of the latter job. The latter job is then included at its release time. In this way, there will occur no forced delay for any urgent job by a less urgent one; the delay of job j in the schedule S is $c_j^S-r_j$ (recall that a job is more urgent than another job if the former one has a larger delivery time or a smaller due date). Note that the so-constructed schedule also minimizes the makespan, since it has no avoidable machine idle time.

Suppose now a job preemption is not allowed and that job i is processed by the machine at time $r_j$ in schedule S, where a yet unscheduled job j is such that $d_j<d_i$; more precisely, job j gets released within the execution interval of job i so that job i delays the starting of job j. Note that this delay will be less than $p_i$ if upon the completion of job i, job j is immediately scheduled. The delay of job j may, however, result in a non-optimal schedule. Indeed, this will be the case when job j is urgent “enough” that in an optimal schedule it should be included with no or with a smaller delay.

Now we give a description of the non-preemptive version of the heuristic. This popular greedy algorithm, commonly referred to as earliest due date ED-heuristic, has been widely used in the process of the solution of variants of single machine, multiprocessor and also shop scheduling problems. As in the above described preemptive version, it is online. It was initially proposed by Jackson [20] and proved to be optimal for problem $1\left|\right|L_{max}$. Later, it was extended for the setting with job release times $1\left|r_j\right|L_{max}$ by Schrage [51]. The extended algorithm is as follows. We let the current scheduling time t be the minimal release time of an unscheduled job or the time when the machine completes the last job, whichever magnitude is larger. If no job is yet scheduled, we let $t:=0$. Iteratively, among the jobs already released by time t, the heuristic schedules the most urgent job (it breaks ties by selecting the longest job). So for problem $1\left|r_j\right|L_{max}$, the most urgent job is an already released one with the smallest due date, whereas for the alternative setting $1\left|r_j\right|D_{max}$, it is an already released one with the largest delivery time. We shall refer to the extended versions of the above greedy algorithm applied to the problems $1\left|r_j\right|L_{max}$ and $1\left|r_j\right|D_{max}$ as the ED-heuristic and LDT-heuristic, respectively. Given the obvious similarity between the two versions of the heuristic and the equivalence of the two settings $1\left|r_j\right|L_{max}$ and $1\left|r_j\right|D_{max}$, we make no distinction between the heuristics, these settings and $L_{max}$ and $D_{max}$, which may be used interchangeably.

We now introduce some additional concepts. Among all jobs in the schedule S, it is useful to distinguish the ones whose lateness attains the maximum job lateness $L_{max}\left(S\right)$ in that schedule. In a given block $B\in S$, among all such jobs, the last scheduled one is said to be an overflow job o in schedule S. In general, more than one overflow job in the schedule S may exist, each one in a different block of that schedule.

Let e be a job from block B such that $d_e>d_o$ (i.e., job e is less urgent than the overflow job o). Then job e is referred to as an emerging job in the schedule S associated with job o. There may exist one or more emerging jobs for the overflow job o. The one scheduled last before job o is referred to as the delaying emerging job l associated with job o.

During the scheduling process, it is important to determine an “appropriate” position of each emerging job. Then we might be able to “adjust” the full completion time of the overflow jobs and reduce in this way the makespan. This property makes the “non-urgent” emerging jobs most important during the scheduling process.

Given an ED-schedule S (one constructed by the ED-heuristic) and a block $B\in S$ with the overflow job o, the corresponding kernel $K\in B$ consists of the set of jobs included in that block between the delaying emerging job l associated with the overflow job o and job o including the latter job. It immediately follows that the due date of any job of the kernel $K\left(S\right)$ is no less than that of job o. Note that any schedule contains the same number of kernels, the overflow jobs and the corresponding delaying emerging jobs. This number cannot be more than the total number of blocks in the schedule.

We illustrate the above concepts using the problem instance with eight jobs from

Table 3. Data of the example instance for problem $1\left|r_j\right|D_{max}$.

$r_1=0$	$p_1=6$	$q_1=17$
$r_2=2$	$p_2=7$	$q_2=21$
$r_3=6$	$p_3=10$	$q_3=16$
$r_4=21$	$p_1=5$	$q_1=33$
$r_5=19$	$p_2=7$	$q_2=28$
$r_6=30$	$p_3=7$	$q_3=23$
$r_7=42$	$p_1=9$	$q_1=1$
$r_8=45$	$p_2=7$	$q_2=2$

. The LDT-schedule for that instance is depicted in Figure 1. There are two blocks and one kernel in that schedule. The numbers in the circles indicate the objective value $C_{max}$ (full completion time) of the corresponding jobs. The kernel jobs are marked in blue, whereas the last overflow job of the kernel is marked in red. The two emerging jobs are marked in green.

We have the following known optimality condition (see [60] for a proof):

Lemma 1.

The ED-schedule S is optimal if it contains an overflow job with no associated delaying emerging job.

The ED-heuristic is quite a powerful scheduling tool and can be used to “capture” other important structural properties of the problem. For example, another sufficient optimality condition can relatively easily be derived. Suppose we apply the heuristic online. Denote by $j_t$ the job scheduled at time t and denote by $S^t$ the partial ED-schedule constructed by the scheduling time t. Suppose further that once job $j_t$ is scheduled, another job j with $d_j<d_{j_t}$ gets released within the execution interval of the former job (job $j_t$ is “pushing” a more urgent job j). Then we shall refer to the scheduling time t as a conflict scheduling time. Let $\sigma$ be the schedule generated by the ED-heuristic for the originally given problem instance.

Lemma 2.

The ED-schedule σ is optimal if no conflict scheduling time occurs while it is built. If this condition is satisfied for all t, no job released within the execution interval of job $j_t$ can start a kernel at any scheduling time t during the construction of the schedule σ.

Proof. 

The lemma follows, since by the hypothesis we can have no overflow job with an associated delaying emerging job in the schedule $\sigma$ (see Lemma 1). □

Next, we define a lower bound $LB$ on the optimum objective function value OPT. Given an LDT-schedule S (one constructed by the LDT-heuristic) with the kernel K and the corresponding delaying emerging job $l\left(K\right)$, we have a lower bound

$$LB\ge D_{max}\left(S\right)-p_{l\left(K\right)}$$

(1)

(see, e.g., [60] for a proof). Combining this lower bound with other easily seen lower bounds, an overall lower bound on OPT is

$$LB=max\{\underset{K\in S}{max}(D_{max}\left(S\right)-p_{l\left(K\right)}),P,\underset{j}{max}\{r_j+p_j+q_j\}\},$$

where P is the total processing time of all jobs.

Inequality (1) has useful implications for approximation purposes, where we consider the setting with job delivery times $1\left|r_j\right|D_{max}$. Indeed, it is obvious how the approximation can be measured for this setting, unlike the setting $1\left|r_j\right|L_{max}$, where, for example, we may have a negative lateness. By the mere observation that $LB\le$ OPT and $p_{l\left(K\right)}\le$ OPT, we obtain that

$$D_{max}\left(S\right)\le 2\mathrm{OPT},$$

(2)

i.e., the LDT-heuristic already delivers a two-approximation schedule. Furthermore, suppose we are interested in a $(1+1/k)$-approximation solution for the problem $1\left|r_j\right|D_{max}$ for a given constant k. By the next lemma, there exist certain values for k that guarantee such an approximation:

Lemma 3.

The inequality $\left|S\right|/\mathrm{OPT}<(1+1/k)$ holds if $k\le LB/p_{l\left(K\right)}$.

Proof. 

From $LB\ge L_{max}\left(S\right)-p_{l\left(K\right)}$, we obtain that $\left|S\right|/$OPT$<($OPT$+p_{l\left(K\right)})/$OPT$=1+p_{l\left(K\right)}/$OPT$\le 1+p_{l\left(K\right)}/LB\le 1+1/k.$ □

If an ED-schedule S is not optimal, then an overflow job o in it is to be restarted earlier. By increasing artificially the release time of a corresponding emerging job and applying the ED-heuristic to such a modified instance, different ED-schedules can be constructed. We intend to reduce $L_{max}\left(S\right)$ in this way by activating an emerging job e for the kernel K, i.e., rescheduling it after that kernel. The activation is carried out in two steps. In step 1, the release time of job e is increased to a magnitude no less than the largest job release time in kernel K. In step 2, the ED-heuristic is applied to the modified job in this way for this problem instance. Since now the release time of job e is no less than that of any job of kernel $K\left(S\right)$ and $d_e$ is larger than the due date of any job from kernel K, the ED-heuristic will give the priority to the jobs of kernel K and will reschedule job e after all former jobs. The ED-schedule ${\left\{S\right\}}_e$, obtained in this way, is referred to as (weakly) complementary to the S schedule.

Note that in the schedule S, some emerging jobs might have been originally included after kernel K. Then such an emerging job can be included before the jobs of kernel K in the schedule ${\left\{S\right\}}_e$ by the ED-heuristic (since no job of kernel K is released at time $s_e\left(S\right)$). As a result, kernel K may not be restarted at the earliest possible time. However, this will happen if the above emerging jobs are forced to remain after kernel K: we increase the release times of these jobs similar to how we did this for job l. The ED-schedule $S_e$, obtained by the ED-heuristic for the modified job in this way for this problem instance, is referred to as (strongly) complementary to the S schedule and is denoted by . The complementary schedule is referred to as a C-schedule.

Note that there is exactly one job less included before kernel K in a strong C-schedule $S_e$ compared to schedule S. The same condition does not hold for a weak C-schedule ${\left\{S\right\}}_e$. In fact, we may have more jobs scheduled before kernel K in schedule ${\left\{S\right\}}_e$ than in the schedule S. Then, as is easy to see, the overflow job o will be completed earlier in the schedule $S_e$ than it was completed in the schedule S.

There are polynomial-time algorithms and implicit enumeration procedures that repeatedly generate (weak or strong) C-schedules (see, e.g., [19,23,24,25,30,33]). Depending on a particular solution approach, either weak or strong C-schedules can be enumerated. The enumeration of strong C-schedules is less costly but may not guarantee optimality.

3. The Overview

In the previous section, we gave some basic properties related to single machine scheduling problems. In this section, we survey some state-of-the-art results, concentrating our attention on $L_{max}$ and $D_{max}$ criteria, complexity, polynomial solvability and approximability issues for standard settings. (As earlier noted, we do not pretend to cover all the existing literature on single machine scheduling problems, including extended settings with setup times and batch processing.)

3.1. Scheduling Jobs with Release Times with $L_{max}$ and $D_{max}$ Criteria

Exact algorithms. The general settings $1\left|r_j\right|L_{max}$ and $1\left|r_j\right|D_{max}$ are strongly NP-hard [61]. The problem is fixed-parameter tractable for the parameters $p_{max}$ and ${\delta }_{max}$, where ${\delta }_{max}$ is the maximum difference between the job due dates, see Vakhania and Werner [25]. The problem is weakly $NP$-hard with only two job release times and due dates being allowed: $1|r_j\in \{r_1,r_2\},d_j\in \{d_1,d_2\}|L_{max}$ (see Lenstra et al. [1] and Chinos and Vakhania [60]). Apparently, it is a minimal $NP$-hard special case of the problem $1\left|r_j\right|L_{max}$.

Among early branch-and-bound algorithms, we mention those by McMahon and Florian [16] and Carlier [17]. As to the more recent works on implicit enumeration methods, Pan and Shi [18] proposed branch-and-bound algorithms using the basic framework from that of Carlier [17]. In particular, to each node of the search tree, a complete LDT-schedule is associated, and for each already created LDT-schedule, two possibilities are considered: in the first generated branch of the node, the delaying emerging job is activated for the corresponding kernel, and in the second branch it is forced to be scheduled before that kernel in any further created schedule in this branch (technically, the delivery time of that job is increased so that the LDT-heuristic will always include it before all jobs of the kernel). A lower bound at each node is determined if the kernel of the corresponding LDT-schedule contains at most two jobs. The at most 3! possible feasible solutions for the jobs of the kernel and the delaying emerging job are formed, and the makespan of the best solution is set as a lower bound.

Besides this lower bound, the authors in [18] give a procedure that permits us to discard some sets of jobs in the following enumeration process. In a created LDT-schedule, let i be the last scheduled job of a block such that no job preceding job i in that schedule has a full completion time more than the current lower bound. Then note that the corresponding part of the schedule including job i can be “frozen” (left as is) in any further created LDT-schedule, and the original instance can be trimmed in this way.

Della Croce and T’kindt [62] consider the version of the problem $1\left|r_j\right|L_{max}$ with job due dates and propose a lower bound, an alternative to the standard preemptive ED-schedule. Let $1,\dots ,j,\dots ,n$ be the jobs in the preemptive ED-schedule (PED), where j is the first overflow job in that schedule. Four different cases where job j can appear in a non-preemptive optimal schedule $S_{OPT}$ are distinguished:

• Job j is in the position j in $S_{OPT}$ as in the PED schedule, being preceded by the jobs $1,\dots ,j-1$ and followed by the jobs $j+1,\dots ,n$. Then in schedule $S_{OPT}$, job j cannot be started before the completion time $c_{ED(1,\dots ,j-1)}$ of the last scheduled job in the non-preemptive ED-schedule $ED(1,\dots ,j-1)$ constructed for the jobs $1,\dots ,j-1$. Hence, $L_{1a}=max\{r_j,c_{ED(1,\dots ,j-1)}\}+p_j-d_j$ is a lower bound for the lateness of job j in this case. Likewise, since the jobs $j+1,\dots ,n$ come after job j, the release times of these jobs can correspondingly be increased. Let $PED(j+1,\dots ,n)$ be the PED-schedule constructed for an updated sub-instance. Then $L_{1b}=L_{max}\left(PED\{j+1,\dots ,n\}\right)$ is another lower bound, and $L_1=max\{L_{1a},L_{1b}\}$ is a lower bound.
• Job j is in one of the positions $1,\dots ,j-1$ in the schedule $S_{OPT}$, and the jobs $1,\dots ,j-1$ precede the jobs $j+1,\dots ,n$. Now, let $ED(1,\dots ,j-1,j)$ be the ED-schedule constructed for the first j jobs, i.e., the jobs $1,\dots ,j-1,j$, and let $c_{ED(1,\dots ,j-1,j)}$ be the completion time of the last scheduled job in $ED(1,\dots ,j-1,j)$. Then note that $c_{ED(1,\dots ,j-1,j)}-{max}_{i=1,\dots ,j}{d}_i$ is a lower bound. Again, the release times of the remaining jobs $j+1,\dots ,n$ are updated and then scheduled by the PED-heuristic. In the resultant schedule, the maximum job lateness is a lower bound, and the maximum between this and the former lower bound is another lower bound $L_2$.
• Job j has one of the positions $j+1,\dots ,n$ in the schedule $S_{OPT}$. So j is preceded by the jobs $1,\dots ,j-1$ and at least one more job k from the set $\{j+1,\dots ,n\}$. Similarly, we define the ED-schedule $ED(1,\dots ,j-1,k)$, where k is a job that minimizes the maximum job completion time $c_{ED(1,\dots ,j-1,k)}$ in such an ED-schedule. Then $L_3=c_{ED(1,\dots ,j-1,k)}+p_j-d_j$ is another lower bound.
• There exists a job $h\le j-1$ that occupies one of the positions $j+1,\dots ,n$ in the schedule $S_{OPT}$. Now we have at least one job k scheduled before job h. Similarly to case 3, we compute the ED-schedule $ED(1,\dots ,h-1,h+1,\dots ,j,k)$ for the jobs in $\{1,\dots ,h-1,h+1,\dots ,j,k\}$, where k is defined similarly as in case 3. Then $L_4=c_{ED(1,\dots ,h-1,h+1,\dots ,j,k)}-{max}_{i=1,\dots ,h-1,h+1,\dots ,j,k}{d}_i$ is a lower bound.

The authors in [62] build their last two lower bounds $L_5$ and $L_6$ as follows. Given a pair of jobs $u,v$, they use the fact that

$$L_{u,v}=min\{max\{r_u+p_u,r_v\}+p_v-d_v,max\{r_v+p_v,r_u\}+p_u-d_u\}$$

is a lower bound on $L_{max}$. Indeed, either u comes before v or vice versa. In the first case, we have the first term and in the second case, we have the second one in the above min expression. Then $L_5={max}_{i\ne j}{L}_{i,j}$ and $L_6={max}_{i\ne o}{L}_{i,o}$, where j is the first overflow job in the complete preemptive ED-schedule and o is the first overflow job in the non-preemptive ED-schedule. Thus, $LB=max\{L_5,L_6,min\{L_1,L_2,L_3,L_4\}\}$ is a lower bound.

Gharbi and Labidi [63] proposed yet another lower bound by applying the common idea that the lower the number of preemptions in a PED-schedule is, the stronger the corresponding lower bound can be. Intuitively, an optimal makespan of a schedule with a “restricted” number of preemptions would approximate better an optimal non-preemptive makespan than a preemptive schedule. Hence, they define a semi-preemptive LDT-schedule in which the preemption of some job parts is not allowed. In particular, every job is divided into two smaller jobs, the fixed and the free parts. The fixed part is considered a job that cannot be preempted, unlike the free part. After that, the decision version of the problem $1|r_j,q_j|C_{max}$ ($1\left|r_j\right|D_{max}$) with a threshold C is considered: Is there a feasible non-preemptive schedule S with $C_{max}\left(S\right)=C$? Note that in using binary search on the possible values of $C_{max}$ within an appropriate interval $[L,U]$, the optimization version can be solved using at most $log(U-L)$ solutions of the decision problem. In the binary search, semi-preemptive LDT-schedules are treated. Observe that if a preemptive schedule $S_p$ has a makespan of more than C, then there will exist no non-preemptive schedule S with a makespan of at most C, since

$$C_{max}\left(S\right)\ge C_{\mathit{opt}}\ge LB=C_{max}\left(S_p\right)>C.$$

For a threshold C in the decision problem, to each job j, a deadline $d_j^{\sim }=C-q_j$ is assigned so that in a feasible semi-preemptive schedule, all jobs are to be completed by their deadlines. The fixed part of job j cannot be preempted whenever this job is to be completed by time ${\tilde{d}}_j$.

The fixed and free parts of job j are defined as follows. Two cases are distinguished. In case 1, $r_j+p_j>{\tilde{d}}_j-p_j$, and in case 2, $r_j+p_j\le {\tilde{d}}_j-p_j$.

Case 1:

• Fixed part $j^{\prime }$: $r_{j^{\prime }}:={\tilde{d}}_j-p_j;p_{j^{\prime }}:=2p_j-{\tilde{d}}_j+r_j;{\tilde{d}}_{j^{\prime }}:=r_j+p_j$.
• Free part $j^{\prime \prime }$: $r_{j^{\prime \prime }}:=r_j;p_{j^{\prime \prime }}:={\tilde{d}}_j-r_j-p_j;{\tilde{d}}_{j^{\prime \prime }}:={\tilde{d}}_j.$

Case 2:

• Fixed part $j^{\prime }$: $r_{j^{\prime }}:=r_j+p_j-x_j;p_{j^{\prime }}:=x_j;{\tilde{d}}_{j^{\prime }}:={\tilde{d}}_j-p_j+x_j$.
• Free part $j^{\prime \prime }$: $r_{j^{\prime \prime }}:=r_j;p_{j^{\prime \prime }}:=p_j-x_j;{\tilde{d}}_{j^{\prime \prime }}:={\tilde{d}}_j$.

where the parameter $x_j\in [1,p_j-1]$. We illustrate the concept of fixed and free parts for cases 1 and 2 in Figure 2 and Figure 3.

The binary search procedure can be described as follows: Let J be the set of all jobs.

• LB $:=$ makespan of the LDT-preemptive schedule for set J.
• UB $:=$ makespan of the non-preemptive LDT-schedule for set J.
• Carry out binary search in the interval $[LB,UB]$. For each derived C, perform the following:
• Calculate ${\tilde{d}}_j$ for all $j\in J$.
• Create a new instance $J^{\prime }=\{j^{\prime },j^{″}|j\in J\}$.
• Create an LDT-preemptive schedule $S^{\prime }$ for set $J^{\prime }$.
• IF schedule $S^{\prime }$ is feasible, i.e., all jobs are completed by their deadlines THEN increase C.
• ELSE decrease C.
• RETURN C and the corresponding feasible semi-preemptive schedule.

Once the above procedure completes, the job release and delivery times are adjusted as follows. Let $S_{sp}$ be the semi-preemptive schedule returned by the above procedure for the obtained threshold $C^{\prime }$. Then for each job h:

• ${\overline{\overline{r}}}_h$ := $c_h\left(S_{sp}\right)-p_h$.
• ${\overline{\overline{d}}}_h=t_h\left(S_{sp}\right)+p_h.$

The authors in [63] rely on the following observation (without giving a formal proof): In an optimal non-preemptive schedule, job h cannot start before time ${\overline{\overline{r}}}_h$ and cannot complete before time ${\overline{\overline{d}}}_h$. Then the original instance can be modified by $r_h:={\overline{\overline{r}}}_h$ y ${\tilde{d}}_h:={\overline{\overline{d}}}_h$.

A recent implicit enumeration algorithm (IEA) by Vakhania [19] is based on a special kind of parameterized analysis, called the Variable Parameter Analysis (VPA). Applying VPA, one can express an exponential dependence in the time complexity expression of an $NP$-hard optimization problem only in terms of variable parameters, the numbers of some specific types of objects and the jobs for the scheduling problem. For scheduling problems with delivery times or due dates, the variable parameter $\nu$ can be defined as the number of emerging jobs.

In the IEA from [19], different types of jobs are distinguished. The set of emerging jobs is partitioned into two basic types, the type 1.1 and type 1.2 emerging jobs. Intuitively, a type 1.2 emerging job initially belongs to some kernel, whereas a type 1.1 emerging job comes either before or after some kernel(s). The set of the type 1.1 emerging jobs is formed in a specially constructed iterative procedure, and the set of type 1.2 emerging jobs associated with a given kernel is detected in another iterative procedure that decomposes that kernel. The set of non-emerging jobs is partitioned into two types. The non-type (1.2) kernel jobs are partitioned into type (2) and all the remaining (non-type (1–2)) jobs are of type (4).

The IEA first generates a partial schedule without type (1) emerging jobs in $O(n^{2}logn)$ time using an extension of the LDT-heuristic. To complete this partial schedule, the type (1) jobs are incorporated into that schedule. This can be performed in polynomial time if certain assumptions on the dynamic behavior of the emerging jobs hold. In the worst-case scenario, all possible ${\nu }^{!}$ permutations of emerging jobs are enumerated, resulting in an

$$O(nlogn{(n-{\nu }_{1.1})}^{2}log(n-{\nu }_{1.1}){\nu }^{!})$$

running time, where $\nu$ (${\nu }_{1.1}$) is the variable parameter equal to the total number of the type (1) (type (1.1), respectively) jobs. The author in [19] reports a preliminary computational study according to which the ratio $\nu /n$ asymptotically converged to 0.

Polynomial-time approximation algorithms. As to the polynomial-time approximation, recall that the LDT-heuristic gives a two-approximation solution by Inequality (2). Potts [52] showed that by a repeated application of the LDT-heuristic $O\left(n\right)$ times, the performance ratio can be improved to 3/2, resulting in an $O(n^{2}logn)$ time performance. Nowicki and Smutnicki [53] proposed another 3/2-approximation algorithm with time complexity $O(nlogn)$. Hall and Shmoys [54] illustrated that the application of the LDT-heuristic to the original problem and a specially defined reversed problem leads to a further improved approximation of 4/3 in $O(n^{2}logn)$ time. Lazarev et al. [64] considered an interesting “metric reduction” approach. Given an arbitrary instance A of the problem, problem instance B, which is the “closest” by a given metric, is built, which is known to belong to a polynomially solvable subclass of the problem. An optimal solution to problem B provides an absolute approximation solution to problem A.

There are polynomial-time approximation schemes (PTASs) for the problem $1\left|r_j\right|D_{max}$. These schemes provide a $(1+1/k)$-approximation for an arbitrary constant k, where the exponential-time dependence is only on the parameter k. The first two such PTASs were described by Hall and Shmoys [54]. The two schemes have different time complexities, namely,

$$O\left({16}^k{\left(nk\right)}^{3+4k}\right)$$

and

$$O(nlogn+n{\left(4k\right)}^{8k^2+8k+2}),$$

respectively. Mastrolilli [55] described another approximation scheme for a more general setting with identical processors. It has an aggregated time complexity

$$O(n{k}^{O\left(1\right)}+k^{O\left(k\right)})=O(n+k^{O\left(k\right)}).$$

These approximation schemes carry out a complete enumeration of all possible combinations for scheduling specially determined k jobs, yielding a tight exponential-time dependence $O\left(k^k\right)$. In these schemes, the set of job release times is artificially reduced to a subset with no more than k elements. As was proved in [54], such a reduction maintains the desired approximation ratio. Below, we give more details on the above three PTASs.

In the first approximation scheme presented in [54], the processing times of jobs are rounded to the nearest multiples of the total processing time P of all jobs, divided by $nk$. By scaling the remaining job parameters, respectively, the original problem instance is transformed to one in which the total number of job processing times becomes restricted by $nk$. The obtained simplified instance can then be solved by the proposed dynamic programming algorithm. This algorithm works with the sub-intervals obtained by partitioning the scheduling horizon. The algorithm considers the possible distributions of the total processing time of the jobs assigned to each sub-interval. The way the sub-intervals are constructed permits the LDT-heuristic to schedule optimally the jobs from each sub-interval. Through the construction of the sub-intervals, the dynamic programming algorithm needs to deal with no more than $P^{O\left(k\right)}$ distributions. Due to the accomplished rounding of the job processing times, the total number of possible distributions becomes

$${\left(nk\right)}^{O\left(k\right)}.$$

The other two approximation schemes (the second one from [54] and the scheme from [55]) partition the set of jobs into short and long jobs so that there are no more than $O\left(k\right)$ long jobs. In the second scheme from [54], as in the first one, $O\left(k\right)$ sub-intervals are derived and the possible ways in which long jobs can be distributed into the derived sub-intervals are considered. The short jobs with an appropriate total length together with the corresponding long ones are scheduled by the LDT-heuristic. All the jobs scheduled in a given sub-interval are released at the beginning of this sub-interval, and hence, the LDT-heuristic schedules them optimally.

In the approximation scheme from [55], there is also a constant number of small jobs and no more than $O\left(k\right)$ job release times, job processing times and job delivery times. The set of jobs is partitioned into no more than $O\left(k^2\right)$ subsets so that each subset contains the jobs with the same release times and delivery times. The jobs of each subset are compiled into longer jobs, with each of these compiled jobs having the same release time and delivery time so that each subset is left with no more than one small job. After these transformations, the cost of a complete enumeration does not depend exponentially on n. Similarly to the second scheme in [54], a constant number of starting times of the long jobs is considered. The jobs are again scheduled by the fast LDT-heuristic.

A recent approximation scheme from Vakhania [19] is based on the earlier mentioned VPA. Like the earlier approximation schemes, it partitions the set of jobs into short and long jobs. The exponential-time dependence in the time complexity expression of this PTAS is only on the number $\kappa$ of long emerging jobs. The total number of long jobs is no more than k, where k is an integer such that the PTAS guarantees the generation of a feasible solution, at most $(1+1/k)$ times an optimal one. A worst-case running time of the PTAS can be expressed as

$$O(\kappa !{\kappa }_{1.1}{n}^{2}logn),$$

where ${\kappa }_{1.1}$ is the number of long type 1.1 jobs. Note that for any fixed k, the parameter $\kappa$ is a constant smaller than k.

Polynomially solvable special cases. As we have already seen from Section 2, if all $r_j$ values are equal, then scheduling the jobs in order of non-decreasing due dates gives an optimal schedule in $O(nlogn)$ time, see Jackson [20]. Similarly, if all $d_j$ values are equal, then scheduling the jobs in order of non-decreasing release times is optimal. If all jobs are of unit length, the problem with both job release times and due dates is again solvable. As Horn [21] observed, in this case, the ED-heuristic delivers an optimal solution given that the job release times are integers. Indeed, while applying the ED-heuristic, no job can be released within the execution interval of a currently running job. As a result, no job may potentially cause a forced delay of any more urgent job. With real job release times and unit job processing times, the problem can be scaled to an equivalent one in which all three job parameters are integers and the job processing times are equal (but not unit-length ones). Then, while applying the ED-heuristic (the non-preemptive case), during the execution of a job another more urgent job may be released, which basically makes the heuristic non-optimal for the general setting $1\left|r_j\right|L_{max}$. However, if we allow it to preempt the former job and schedule the latter one at its release time, the preemptive problem $1|r_j,pmtn|L_{max}$ can be solved optimally, as was mentioned in Section 2. The problem with equal (non-unit)-length jobs $1|p_j=p,r_j|L_{max}$ can still be solved in polynomial $O(n^{2}logn)$ time. Garey et al. [22] used a very sophisticated data structure with a union and find tree with path compression and achieved an improvement of the time complexity to $O(nlogn)$.

The problem with two allowable job processing times p and $2p$ for an arbitrary integer p, denoted as $1|p_j\in \{p,2p\},r_j|L_{max}$, remains polynomially solvable, see Vakhania [23]. The algorithm from the latter reference is optimal when the processing times of only some emerging jobs (which become known during the execution of the algorithm) are restricted to p or $2p$. The algorithm is obtained as a consequence of two implicit enumeration algorithms for the problem $1\left|r_j\right|D_{max}$. The first algorithm is exponential. The second algorithm is a restriction of the first one and runs in $O(n^{2}logn)$ time under certain conditions, which are to be held during its execution. Otherwise, another auxiliary procedure has to be applied to guarantee the optimality. An $O(n^{2}lognlogp)$ implementation of that procedure for the two allowed job processing times yields an algorithm with the same time complexity for this setting.

Relatively recently, it was shown that an essentially more general setting, where every job processing time divides every larger job processing time (for example, the job processing times are powers of 2), $1|div,r_j|D_{max}$, can be solved optimally in $O(n^{2}lognlog{p}_{max})$ time, see Vakhania [24] (here $p_{max}$ is the maximum job processing time). Note that this is a maximal polynomially solvable special case of the problem with restricted job processing times (as we mentioned earlier, the problem remains strongly $NP$-hard if the job processing times are from the set $\{p,2p,3p,\dots \}$ for any integer p). If the maximum job processing time $p_{max}$ is bounded by a polynomial function in n, $P\left(n\right)=O\left(n^k\right)$, and the maximum difference between the job release times is bounded by a constant R, then the corresponding parameterized problem $1|p_{max}\le P\left(n\right),|r_j-r_i|<R|L_{max}$ can still be solved in polynomial time $O(n^{k+1}lognlog{p}_{max})$, see Vakhania & Werner [25]. Note that in this setting, the general problem is parameterized by $p_{max}$ and the maximum difference between two job release times.

For the problem $1|p_j=p,r_j|L_{max}$, Lazarev et al. [26] presented two polynomial algorithms. The first procedure is based on a trisection search and determines an optimal solution in $O(Qnlogn)$ time, where ${10}^{-Q}$ represents the accuracy of the parameters of the problem. The second approach uses an auxiliary problem, where the maximum completion time is minimized under the constraint that $L_{max}$ is bounded by a particular value. Using this approach, the authors determine a solution for the bi-criteria problem with the two criteria $C_{max}$ and $L_{max}$ and the Pareto set of optimal solutions in $O(n^{3}logn)$ time.

There are other known conditions that allow a polynomial-time solution of the problem. For example, if the job release times, processing times and due dates are restricted in a specific manner so that each $r_j$ lies within a certain time interval defined by $p_j$ and $d_j$, then the problem can be solved in $O(nlogn)$ time, see Hoogoveen [65]. If the job parameters are embedded in another special manner, such that for any pair of jobs $j,i$ with $r_i>r_j$ and $d_i<d_j$,

$$d_j-r_j-p_j\le d_i-r_i-p_i$$

holds, and with

$$r_i+p_i\ge r_j+p_j,$$

$d_i\ge d_j$ holds, then the resultant problem $1|r_j,embedded|L_{max}$ is solvable in $O(nlogn)$ time, see Vakhania [27]. As was recently observed in Vakhania and Werner [66], allowing the compression of job processing times may lead to an efficient solution of the general problem under some reasonable restrictions (in practice, job compression is accomplished at the cost of using some extra resources). There is an upper limit on the total allowable compression cost, and one looks for a schedule that minimizes the maximum job lateness. The authors propose an $O(n^{2}logn)$ algorithm that determines an amount of additional resources required to solve the problem optimally. If this yields a violation of the restriction on the allowable maximum cost, i.e., the solution is infeasible, it is transformed into a “tight minimal” feasible one in the sense that by increasing the processing time of any compressed job by some amount of time, the maximum job lateness in the resultant solution will increase by the same amount. As is shown, it suffices to compress only some emerging jobs.

As already mentioned, the problem with only two allowable job release times and due dates $1|r_j\in \{r_1,r_2\},d_j\in \{d_1,d_2\}|L_{max}$ is weakly $NP$-hard. Reynoso and Vakhania [28] considered this setting. They established structural properties of feasible schedules that have led to a number of optimality conditions, under which the problem was solved in $O(nlogn)$ time. For bottleneck instances, where none of these conditions apply, the problem is reduced to the SUBSET SUM problem. The authors presented the results of computational experiments accomplished for 50 million randomly generated problem instances, reporting that almost all these instances were solved optimally by one of the established optimality conditions. Remarkably, the heuristic algorithms that incorporate the above optimality conditions also succeeded in solving the SUBSET SUM problem optimally for almost all 50 million instances. A more recent work considered a natural generalization of the latter problem with any fixed number of release times (see Escalona [67]). For this setting, the optimality conditions were derived, and again it was shown how the problem can be reduced to the SUBSET SUM problem. It is a challenging question regarding to what extent the above obtained results can be generalized for any fixed number of release and delivery times, a setting with still wider practical applications.

In Azharonok et al. [29], a general objective function $f_{max}$ defined as the maximum of non-decreasing cost functions $f_j$ was considered for the preemptive problem $1|r_j,prec,pmtn|f_{max}$. It is assumed that for any pair $i,j$ of jobs, the cost functions fulfill either the order relation $f_i\left(t\right)\le f_j\left(t\right)$ for any time t or $f_j\left(t\right)\le f_i\left(t\right)$ for any time t of the scheduling interval. In the case of tree-like precedence constraints, the derived algorithm has a time complexity of $O(nlogn)$, which improves the complexity of $O\left(n^2\right)$ of a known algorithm for the general case [68]. In addition, a parallel algorithm is given with a time complexity of $O\left({log}^{2}n\right)$ when using $O(n^{2}logn)$ processors.

Some applications. The problem $1\left|r_j\right|L_{max}$ is important on its own and also because of its possible applications for the solution of other more complex scheduling problems and other optimization problems. For example, Carlier and Pinson [69] used the problem as an auxiliary one to obtain a lower bound for the version of the problem with identical processors. Adams, Balas and Zawack [70] used the problem for the solution of the job shop scheduling problem.

The problem can also be used for the solution of Vehicle Routing Problems (VRPs) with k vehicles (salespeople), each starting and ending at a special point 0 called the depot. Each salesperson has to visit a number of clients and return to the depot. The objective is to minimize the total cost of all k tours (see, for example, [71]). In the setting with time windows, each client has to be visited within a specified time window (interval). In this setting, there may exist no feasible solution. Hence, it is crucial to determine whether there exists a feasible solution for a given k. More generally, one may be interested in calculating the minimum k for which there exists a feasible solution. Let us consider a simplified version of the problem with $k=1$, i.e., the Traveling Salesman Problem (TSP) with time windows, TSP-TW. For a given instance of TSP-TW with $n+1$ clients, we create an instance of the problem $1|p_j=0,r_j|L_{max}$ with n jobs, associating job j with client j for each $i=1,\dots ,n$ and letting the processing time of each job be 0. Note that this is a simplified version of the generic problem $1\left|r_j\right|L_{max}$. In this version, the release and due times of each job are determined according to the time window of the corresponding client. In the feasibility version of the problem, one looks for a schedule in which no job has a positive lateness. One can immediately see that if there is no feasible solution to the scheduling problem, there is also no feasible solution for the corresponding instance of TSP-TW. If we let u be an upper bound on the total number of salesmen, we can carry out binary search within the interval $[1,u]$, solving at each iteration an instance of the corresponding scheduling problem $Pk|p_j=0,r_j|L_{max}$ with k parallel identical machines and with trial $k\in [1,u]$. In this way, we can find the minimum k for which there exists a feasible solution to the problem (if it exists).

In the capacitated VRP, each vehicle has some capacity and each client has some request. In a feasible vehicle tour, the total demand of all clients in that tour cannot exceed the capacity of that vehicle. A feasible solution consists of k feasible tours. With equal capacity C of all vehicles, one can verify the feasibility by solving the feasibility version of the multiprocessor version of our genetic problem without job release and due times with k identical processors, where the objective is to minimize the makespan (the maximum job or machine completion time), $Pk\left|\right|C_{max}$. Here we associate jobs with clients, where the processing time of each job is the demand of the corresponding client, and we wish to know if there exists a feasible solution to the scheduling problem with a makespan at most C. This is an essentially simpler problem than a VRP. Alternatively, strong lower bounds calculated in polynomial time are known for scheduling problems, which, in particular, can be useful to establish that there exists no feasible solution to an instance of a VRP (whenever this is the case).

3.2. Minimizing the Number of Late Jobs

Another common objective function with given due dates is the number of late jobs: a job in a schedule is called late if it is completed after its due date in that schedule, otherwise it is called on time. In the problem of this subsection, we deal with n jobs with release times and due dates which have to be scheduled on the machine to maximize the number of on-time jobs, or equivalently, to minimize the number of late jobs. We consider both preemptive and non-preemptive cases and also cases when the jobs have an additional parameter called weight.

3.2.1. Non-Preemptive Scheduling to Minimize the Number of Late Jobs: $1|r_j;p_j=p|\sum U_j$

In this subsection, we deal with the non-preemptive version of the problem $1\left|r_j\right|\sum U_j$. This problem was studied in Vakhania [30], where two polynomial-time algorithms were proposed. The first one with the time complexity $O(n^{3}logn)$ optimally solves the problem if during its execution no job with some specially defined property occurs. The second algorithm is an adaptation of the first one for the special case of the problem when all jobs have the same length $1|r_j;p_j=p|\sum U_j$. The time complexity of this algorithm is $O(n^{3}logn)$ (it improved an earlier known fastest algorithm with the time complexity of $O\left(n^5\right)$ by Chrobak et al. [72]).

3.2.2. Preemptive Scheduling to Maximize the Number of On-Time Jobs: $1|r_j;pmtn|\sum U_j$

In the problem of this subsection, n jobs with release times and due dates have to be scheduled preemptively on a single machine to minimize the number of late jobs, i.e., problem $1|r_j;pmtn|\sum U_j$. We call a job late (on time, respectively) if it is completed after (at or before, respectively) its due date. We will say that job j is feasibly scheduled if it starts no earlier than at time $r_j$ and overlaps with no other job on the machine. A feasible schedule is one which feasibly schedules all jobs. The objective is to find a feasible schedule with a minimal number of late jobs or, equivalently, with the maximal number of on-time jobs.

This problem is known to be polynomially solvable. The first polynomial dynamic programming algorithm with a time complexity of $O\left(n^5\right)$ and a space complexity of $O\left(n^3\right)$ was developed by Lawler [31]. The result was improved by Baptiste [32], who suggested another dynamic programming algorithm with a time complexity of $O\left(n^4\right)$ and a space complexity of $O\left(n^2\right)$. The latter result was further improved by Vakhania [33], where an algorithm with the time and space complexities of $O\left(n^3\right)$ and $O\left(n\right)$, respectively, was proposed. Unlike the earlier algorithms, the latter algorithm is not based on dynamic programming. It uses the ED-heuristic for scheduling the jobs. The main task is to construct a schedule in which all jobs are scheduled on time, with the number of such jobs being maximal. As any late job can be scheduled arbitrarily late without affecting the objective function, jobs not included in the former schedule can be later added at the end of it in an arbitrary order. During the construction of the schedule, some jobs are disregarded, whereas other jobs are omitted with the possibility to be included in a later created schedule.

3.3. Preemptive Scheduling to Minimize the Weighted Number of Late Jobs with Equal Length: $1|r_j;p_j=p;pmtn|\sum w_j{U}_j$

In this section, we consider the weighted version of the problem of the previous section in which preemptions are allowed and all jobs have an equal length. Moreover, $w_j$ is the non-negative integer weight of job j. We minimize the weighted throughput, which is the total weight of the completed jobs. Equivalently, we minimize the weighted number of late jobs. The problem can be abbreviated as $1|r_j;p_j=p;pmtn|\sum w_j{U}_j$.

The first polynomial dynamic programming algorithm of complexity $O\left(n^{10}\right)$ for the problem was suggested by Baptiste [34]. Baptiste et al. [35] improved the above time complexity and proposed another dynamic programming algorithm, which runs in $O\left(n^4\right)$ time.

Next, we briefly discuss some directions for further research. First, we note that for the multiprocessor case, the weighted version is $NP$-complete [73]. At the same time, the non-weighted version still remains open. In particular, it is not known whether the problem $P|r_j;p_j=p;pmtn|\sum U_j$ can be solved in polynomial time. (Even for two processors, one cannot restrict the search to solely earliest deadline schedules. As an example, consider an instance with three jobs with feasible intervals $(0,3)$, $(0,4)$, and $(0,5)$ and the processing time $p=3$. There exists a feasible schedule that completes all three jobs, whereas the earliest-deadline schedule completes only jobs 1 and 2.) For the multiprocessor case, it is also interesting to study the preemptive version, where jobs are not allowed to migrate between processors.

3.4. Scheduling to Minimize the Weighted Number of Late Jobs with Deadlines and Release/Due-Date Intervals

In [74], Gordon et al. dealt with the problem where in addition to release and due dates, deadlines are also given. This means that certain jobs have to be completed on time. The authors considered the two cases of similarly ordered release and dues dates (i.e., $r_1\le r_2\le \dots \le r_n$ and $d_1\le d_2\le \dots \le d_n$) as well as nested release and due-date intervals (i.e., none of two such intervals overlap; thus they have at most a joint point or one covers the other one). For these problems, a reduced problem is constructed where the deadlines are eliminated, and it is shown that the optimal solution of the reduced problem can be used to find an optimal solution of the initial problem.

In a later paper, Gordon et al. [75] considered the preemptive version of the above problem with nested release and due-date intervals. They derived necessary and sufficient conditions for the existence of a schedule in which all jobs are completed by their due dates. For the case of oppositely ordered processing times and job weights, a polynomial algorithm of the complexity $O(nlogn)$ was presented.

3.5. Scheduling with Tardiness-Based Objectives

The single machine problem $1\left|\right|\sum T_i$ is known to be NP-hard in the ordinary sense (see [76]). In [77], Swarcz and Mukhopadhyay developed a decomposition rule which is used in a very powerful branch-and-bound algorithm. It turned out that the algorithm can solve problems with 100 jobs even without using any lower bounds, and the authors were able to solve problems until $n=150$ jobs. This was possible by eliminating dynamic programming and replacing it with the newly developed decomposition rule, which significantly outperformed the earlier rules by Emmons [78].

The single machine problem of minimizing total tardiness has received a lot of attention. An early review on exact and approximation algorithms was given by Koulamas [79] in 1994. Sixteen years later, Koulamas [80] discussed the most important developments for the total tardiness problem up to 2010. The latter survey discusses some theoretical developments, exact algorithms, fully polynomial-time approximation schemes, approximation algorithms, some special cases and also a generalization of the problem as well as the total tardiness problem with assignable due dates. Recall that for the total weighted tardiness scheduling problem, an early review of algorithms was given by Abdul-Razaq et al. [11] in 1990.

Our main focus in this sub-section is on new results in the last 15 years which have not been included in reviews so far. While the problem $1\left|\right|\sum T_j$ is known to be NP-hard, Gafarov et al. [36] considered the special case of equal processing times, i.e., problem $1|r_j,p_j=p|\sum w_j{T}_j$. After deriving some properties, they gave polynomial algorithms for two special cases of the problem. If the difference between the maximum due date and the minimum due date is not greater than the processing time p, the problem can be solved by a modification of the algorithm by Baptiste [81] in $O\left(n^{10}\right)$ time. The special case with ordered weights and processing times according to $w_1\le w_2\le \dots \le w_n$ and $d_1\le d_2\le \dots \le d_n$ can be solved in $O\left(n^9\right)$ time by a similar modification from [81].

In [82], Lazarev and Werner presented a new general graphical algorithm which often improves the complexity or at least the running time of dynamic programming algorithms, and it can be used for efficient approximation algorithms. Compared to standard dynamic programming algorithms, the number of states can often substantially be reduced.

In a standard dynamic programming algorithm for permutation problems, the functions $F_l\left(t\right)$ and the corresponding partial sequences have to be stored for any stage $l=1,2,\dots ,n$ and any time $t=0,1,\dots ,UB$. Here, $UB$ is an upper bound for the scheduling interval, e.g., the sum of all processing times (or the maximal due date). The values $F_1\left(t\right)$ typically represent the best function value when considering the first l jobs and allowing at most t time units for the processing of the scheduled (e.g., early) jobs. This results in a pseudo-polynomial algorithm of the complexity $O(n\sum p_j)$.

The graphical algorithm combines different states, where the best partial solution does not change and the corresponding objective function $F_l\left(t\right)$ can be described by the same linear function. As a result, at each stage l, there are certain intervals separated by the so-called breakpoints $t_1^l<t_2^l<\dots t_{h_l}^l$, where the structure of the linear function belonging to the best partial solution changes. In addition, for the graphical algorithm, the times t do not need to be integers.

In [83], Gafarov et al. described the application of this graphical algorithm to the approximate solution of various single machine problems. In particular, the graphical algorithm is applied to five total tardiness problems, where a pseudo-polynomial algorithm exists, and the graphical algorithm yields fully polynomial-time approximation schemes, yielding the best known running time.

In [15], Gafarov et al. considered the maximization of total tardiness, and by applying the graphical algorithm, they transformed a pseudo-polynomial algorithm into a polynomial one. More precisely, the complexity of $O(n\sum p_j)$ can be reduced to $O\left(n^2\right)$, which settled the open complexity status of the problem $max1\left|\left(nd\right)\right|\sum T_j$), where $nd$ means that no inserted idle times occur. The authors present a detailed numerical example and also give a practical application of such maximization problems, where wind turbines have to be mounted in several regions of a country.

While for more general settings such a graphical algorithm often improves the running time in comparison with existing algorithms, the complexity remains pseudo-polynomial. For instance, in [84], Lazarev et al. presented graphical algorithms with a complexity of $O(n\sum p_j)$ for a special case of a generalized tardiness problem corresponding to the minimization of late work as well as for the minimization of the weighted number of late jobs.

In [85], Lazarev and Werner considered various special cases of the (unweighted) total tardiness problem $1\left|\right|\sum T_j$. After proving that the special case of oppositely ordered processing times and due dates, i.e., $p_1\ge p_2\ge \dots \ge p_n$ and $d_1\le d_2\le \dots \le d_n$, is already $NP$-hard in the ordinary sense, they gave several pseudo-polynomial and polynomial algorithms for special cases of this problem. In particular, $O\left(n^2\right)$ algorithms were given for the cases $d_j-d_{j-1}>p_j,j=2,3,\dots ,n$, as well as for the case when the difference between the maximal and the minimal due date is not greater than 1. In both cases, the processing times do not need to be integers.

In further research, the graphical algorithm can be applied to more general problems, where a pseudo-polynomial algorithm exists and Boolean variables are used for making yes/no decisions.

3.6. Some Online Settings

First, we consider preemptive scheduling models to maximize overall profit. Jobs with release and processing times, deadlines and weights are to be scheduled on a single machine. Job weight reflects its profit. Any job can be preempted during the execution, and the objective is to maximize the overall profit, respecting job deadlines. Notice that in a feasible schedule, all jobs must complete by their deadlines. In particular, there may exist no feasible schedule in which all jobs are included. Hence, we wish to create a feasible schedule in which the overall profit is maximized. Two possible models and the definition of the profit gained by the execution of task j have been studied. In the standard model, a completed task j gives the profit $w_j{p}_j$, whereas a non-completed task gives no profit. In a more flexible metered model, a task j executed for $t\le p_j$ time units gives the profit $w_{jt}$ (this task may not be completed). We just mention here the work by Chrobak et al. [86], who considered both the offline and online metered profit models. For the offline setting, they used a reduction to bipartite matchings and maximal flows to develop a polynomial-time algorithm with a better running time than the solution of a direct linear programming model would yield. For the online metered case, they presented an algorithm with competitive ratio $e/(e-1)\approx 1.5820$ and proved a lower bound of $\sqrt{5}-1\approx 1.236$ on the competitive ratio of the algorithms for this problem.

In an online setting with job release times, the jobs arrive over time. The delivery time of a job becomes known at its arrival (release) time. The objective is to minimize the maximum full job completion time, the makespan. In Section 3.1, we considered the corresponding offline problem, which is strongly NP-hard. We also mentioned that the preemptive version can be solved in polynomial time by the preemptive LDT-heuristic, whereas for the non-preemptive case, the LDT-heuristic has a performance guarantee of two. This is the best possible performance ratio unless we allow the machine to be idle when there is an unprocessed job available. Hoogeveen and Vestjens [56] developed an online algorithm with the best possible worst-case ratio

$$(\sqrt{5}+1)/2\approx 1.61803$$

in which a waiting strategy is incorporated. Van den Akker et al. [87] considered an extension of the standard model by allowing job restarts: If an urgent job comes while the machine is busy, then the currently running job can be interrupted in favor of the urgent job. In this model, unlike traditional preemptive models, the already processed part of the interrupted job is wasted and this job is to be started all over again. The algorithm proposed in [87] has the best possible worst-case ratio of $1.5$ (which is better than the above-mentioned bound for the case without restarts).

As is easy to see, in the offline setting, a mere modification of the LDT-heuristic that removes and postpones each currently running job in favor of a just released more urgent job can deliver a worst-possible non-preemptive schedule. In this sense, restarts do not make much sense in the offline case.

In the online setting, in cases where a job cannot be split, allowing job restarts can be a reasonable compromise. However, note that an almost completed job will be “lost” if a more urgent job arrives just before its completion on the machine. This scenario can be softened if an already completed part of an abandoned job can give some benefit and this job can be restarted from the moment when it was interrupted. Note that a direct compromise would lead us to the standard preemptive case. But other alternative reasonable compromises are possible. For example, the preemptive part may yield some penalty and the total penalty can be minimized. Furthermore, as in the above-mentioned metered model, a partially completed job may still give some benefit. Hence, one may well consider models where an already processed part of an interrupted job counts in one way or another. It is interesting to consider whether there exist better worst-case performance bounds for such models.

3.7. Scheduling with Non-Renewable Resources

Unlike a traditional renewable resource which is constantly available and not consumed by a job, a non-renewable resource is consumed by a job so that its availability is not permanent and constant. A machine or a processor is a renewable resource, whereas energy, money and fuel, for example, are non-renewable resources that can be created in different ways. Nowadays, different kinds of sustainable energy sources including solar and wind energies are widely available.

Gafarov et al. [88] considered single machine problems with a non-renewable resource (abbreviated $NR$). This means that at any time $t_i,i=0,1,\dots ,UB$, with $t_0=0$ and $UB$ as an upper bound on the scheduling interval, one gets an amount $G\left(t_i\right)\ge 0$ of the resource, while any job j has a consumption of $g_j$ at the starting time $s_j$ of the job. Hence, the equality

$$\sum _{j=1}^n{g}_j=\sum _{i=0}^{UB}G\left(t_i\right)$$

holds. One looks for an optimal permutation $(j_1,j_2,\dots ,j_n)$ for a particular objective function with the starting times $s_{j_1},s_{j_2},\dots ,s_{j_n}$ of the jobs such that the resource constraints are satisfied, i.e., the inequality

$$\sum _{l=1}^i{g}_{j_l}\le \sum \{G\left(t_v\right)\mid t_v\le s_{j_i} \mathrm{for} \mathrm{all} vs.\le s_{j_i}\}$$

holds for any $i=1,2,\dots ,n$. Such problems play a role, e.g., for government-financed organizations when a project can only be started after receiving the required funds.

The authors focused on complexity results and proved that the problems $1\left|NR\right|f$ with $f\in \{C_{max},\sum C_j,\sum U_j\}$ are strongly $NP$-hard. When minimizing total tardiness $\sum T_j$, the case of equal due dates ($d_j=d$) is already strongly $NP$-hard. The following special cases with minimizing total tardiness were proven to be weakly $NP$-hard:

(1)

Equal processing times ($p_j=p$);

(2)

Equal due dates $(d_j=d)$ and equal consumptions ($g_j=g$).

On the other hand, the special case of equal processing times ($p_j=p$) and ordered consumptions and due dates according to $g_1\le g_2\le \dots \le g_n$ and $d_1\le d_2\le \dots \le d_n$ is polynomially solvable.

This paper considered also the budget scheduling problem with the objective to minimize the makespan. Instead of a resource consumption $g_j$ for each job, two values $g_j^{-}$ and $g_j^{+}$ are given, where $g_j^{-}$ has the same meaning as $g_j$ before. The value $g_j^{+}$ describes the additional earnings at the completion time of job j. The authors showed that the problem $1|NR,g_j^{-},g_j^{+}|C_{max}$ belongs to the class $APX$ of problems, allowing a constant-factor approximation algorithm.

Recently, Ramirez et al. [37] considered a different non-renewable setting on a single machine. In that setting, every job has a release time, processing time and due date, where the execution of job j, besides the machine time, requires $e_j$ amount of the non-renewable resource (it consumes energy $e_j$). Here, a schedule is a mapping that assigns to each job a starting time on the machine and the required amount of the non-renewable resource. The objective is to minimize the maximum job lateness. The problem is abbreviated as $1|r_j,e_j|L_{max}$. The authors proposed an $O(nlogn)$-time algorithm for the case, where all jobs have a unit processing time. Earlier, an $O(n^{2}logn)$ time algorithm was suggested for a similar scenario but without job release times by Grigoriev et al. [38]. Note that job release times essentially complicate the problem, even without energy requirements, since the setting without them is polynomially solvable. The algorithm in [37] iteratively takes the next unscheduled job with the minimum due date and schedules it at the earliest time moment where enough energy for that job becomes available. This is an offline algorithm, as the jobs are not scheduled according to their arrival (release) times.

For future work, due to the $NP$-hardness of the majority of problems, it would be interesting to derive elimination rules and structural properties of optimal solutions which can be used in enumerative algorithms.

4. Concluding Remarks

In this paper, we reviewed some theoretical results on classical single machine scheduling problems. Since there exists a huge number of heuristic/meta-heuristic and enumerative algorithms, our focus was on polynomial algorithms as well as complexity and approximability issues. The summarized polynomial special cases are also of interest when the conditions are not exactly satisfied and the resulting solution can be taken as a good heuristic one. We hope that the reviewed results will stimulate further investigation in related research fields.

For single machine scheduling problems, efficient solution methods can often be found more easily than for the corresponding multiprocessor or shop scheduling problems. However, such methods may give a better insight into the latter, more complex problems and may well serve as a basis for the development of solution methods for these problems. At the same time, optimal solutions to single machine scheduling problems can directly be used to solve the corresponding multiprocessor or shop scheduling problems. For example, for such $NP$-hard problems, strong lower bounds can be obtained based on the solutions of the corresponding single machine problems. Non-strict lower bounds, which are easier and faster to obtain, can be used in any search-tree-based approximation algorithm, such as beam search, for example. Similarly, using strict lower bounds, we obtain exact branch-and-bound algorithms. Once implemented and tested, the above algorithms can be used as an algorithmic engine for the construction of decision support systems. Finally, we note that a number of algorithms for basic single machine problems can relatively easily be adopted using additional graph-completion mechanisms to solve the corresponding extended versions with precedence relations, transportation and setup times and other real-life job scheduling problems.