Approximation Schemes for Minimizing the Maximum Lateness on a Single Machine with Release Times under Non-Availability or Deadline Constraints

In this paper, we consider four single-machine scheduling problems with release times, with the aim of minimizing the maximum lateness. In the first problem we have a common deadline for all the jobs. The second problem looks for the Pareto frontier with respect to the two objective functions maximum lateness and makespan. The third problem is associated with a non-availability constraint. In the fourth one, the non-availibility interval is related to the operator who is organizing the execution of jobs on the machine (no job can start, and neither can complete during the operator non-availability period). For each of the four problems, we establish the existence of a polynomial time approximation scheme (PTAS).


Introduction
The problem we consider is the one-machine scheduling problem with release dates and delivery times. The objective is to minimize the maximum lateness. Formally, the problem is defined in the following way. We have to schedule a set J = {1, 2, . . . , n} of n jobs on a single machine. Each job j ∈ J has a processing time p j , a release time (or head) r j and a delivery time (or tail) q j . The machine can only perform one job at a given time. Preemption is not allowed. The problem is to find a sequence of jobs, with the objective of minimizing the maximum lateness L max = max 1≤j≤n {C j + q j } where C j is the completion time of job j. We also define s j as the starting time of job j, i.e., C j = s j + p j , then P = n j=1 p j as the total processing time and p(H) = j∈H p j as the total processing time for a subset of jobs H ⊂ J. Four scenarios are considered: • Scenario 1: every job should be completed before a deadline d, i.e., C max = max 1≤j≤n {C j } ≤ d.
This scenario is denoted as 1|r j , C max ≤ d|L max . For a simpler notation, this variant is also abbreviated as Π 1 .
• Scenario 2: we are given the one-machine bicriteria scheduling problem with the two objectives L max and C max , denoted by 1|r j |L max , C max . We will speak shortly of problem Π 2 .
• Scenario 3: the machine is not available during a given time interval ]T 1 , T 2 [. This scenario is denoted by 1, h 1 |r j |L max . We will speak shortly of problem Π 3 .
• Scenario 4: in this case, the non-availibility interval ]T 1 , T 2 [ is related to the operator who is organizing the execution of jobs on the machine. An operator non-availability (ONA) period is an open time interval in which no job can start, and neither can complete. Using an extended notation as in [10], this scenario is denoted by 1, ON A|r j |L max . We will speak shortly of proble Π 4 .
Note that the main difference between machine non-availability and operator non-availability consists in the fact that a job can be processed but can neither start nor finish during the ONA period. However, the MNA interval is a completely forbidden period.
All four presented scenarios are generalizations of the well-known problem 1|r j , q j |L max which has been widely studied in the literature. For the sake of simplicity, this problem will be denoted by Π 0 . According to Lenstra et al [15] problem 1|r j , q j |L max is NP-hard in the strong sense. Therefore, we are interested in the design of efficient approximation algorithms for our problems.
For self-consistency, we recall some necessary definitions related to the approximation area. A ρapproximation algorithm for a problem of minimizing an objective function ϕ is an algorithm such that for every instance π of the problem it gives a solution S π verifying ϕ (S π ) /ϕ (OP T π ) ≤ ρ where OP T π is an optimal solution of π. The value ρ is also called the worst-case bound of the above algorithm.
A class of (1 + ε)-approximation algorithms is called a PTAS (Polynomial Time Approximation Scheme), if its running time is polynomial with respect to the length of the problem input for every ε > 0. A class of (1 + ε)-approximation algorithms is called an FPTAS (Fully Polynomial Time Approximation Scheme), if its running time is polynomial with respect to both the length of the problem input and 1/ε for every ε > 0.
Given the aim of this paper, we summarize briefly related results on scheduling problems with nonavailability constraints but no release times. A huge number of papers is devoted to such problems in the literature. This has been motivated by practical and real industrial problems, like maintenance problems or the occurrence of breakdown periods. For a survey we refer to the article by [14]. However, to the best of our knowledge, there is only a limited number of references related to the design of approximation algorithms in the case of maximum lateness minimization. Yuan et al [23] developed a PTAS for the problem without release dates. The paper by Kacem et al [10] contains an FPTAS for 1, h 1 ||L max and 1, ON A||L max . Kacem and Kellerer [8] consider different close semionline variants (1, h 1 ||C max , 1, h 1 |r j |C max and 1, h 1 ||L max ) and propose approximation algorithms with effective competitive ratios.
Numerous works address problems with release times but without unavailability constraints. Most of the exact algorithms are based on enumeration techniques. See for instance the papers by Dessouky and Margenthaler [3], Carlier et al [2], Larson et al [13] and Grabowski et al [5].
Various approximation algorithms were also proposed. Most of these algorithms are based on variations of the extended Jackson's rule, also called Schrage's algorithm. Schrage's algorithm consists in scheduling ready jobs on the machine by giving priority to the one having the greatest tail. It is well-known that the Schrage sequence yields a worst-case performance ratio of 2. This was first observed by Kise et al [12]. Potts [20] improves this result by running Schrage's algorithm at most n times to slightly varied instances. The algorithm of Potts has a worst-case performance ratio of 3 2 and it runs in O(n 2 log n) time. Hall and Shmoys [6] showed that a modification of the algorithm of Potts has the same worst-case performance ratio under precedence constraints. Nowicki and Smutnicki [18] proposed a faster 3 2 -approximation algorithm with O(n log n) running time. By performing the algorithm of Potts for the original and the inverse problem and taking the best solution Hall and Shmoys [6] established the existence of a 4 3 -approximation. They also proposed two polynomial time approximation schemes. A more effective PTAS has been proposed by Mastrolilli [17] for the single-machine and parallel-machine cases. For more details the reader is invited to consult the survey by Kellerer in [11].
There are only a few papers which treat the problem with both release times and non-availability intervals. Leon and Wu [16] present a branch-and-bound algorithm for the the problem with release times and several machine non-availability intervals. A 2-approximation has been established by Kacem and Haouari [7] for 1, h 1 |r j |L max .
Rapine et al. [21] have described some applications of operator non-availability problems in the planning of a chemical experiments. Brauner et al. [1] have studied single-machine problems under the operator non-availability constraint. Finally, we refer to the book by T'kindt and Billaut [22] for an introduction into multicriteria scheduling.
For each of the four problems Π 1 , Π 2 , Π 3 and Π 4 we will present a polynomial time approximation scheme. Notice, that the PTAS's in [6] and [17] for 1|r j , q j |L max use modified instances with only a constant number of release dates. This is not possible in the presence of deadlines or non-availability periods since the feasibility of a solution would not be guaranteed.
The paper is organized as follows. Section 2 repeats some notations and results for Schrage's sequence. Section 3 contains the PTAS for problem Π 1 , Section 4 is devoted to the bicriteria scheduling problem Π 2 , Sections 5 and 6 deal with problems Π 3 and Π 4 , respectively. Finally, Section 7 concludes the paper.

Schrage's Algorithm
For self-consistency we repeat in this section some notations and results for the Schrage's sequence, initially designed for problem Π 0 and later exploited for other extensions (see for instance Kacem and Kellerer [9]). Recall that Schrage's algorithm schedules the job with the greatest tail from the available jobs at each step. At the completion of such a job, the subset of the available jobs is updated and a new job is selected. The procedure is repeated until all jobs are scheduled. For a given instance I the sequence obtained by Schrage shall be denoted by σ Sc (I). Assume that jobs are indexed such that σ Sc (I) = (1, 2, ..., n). The job c which attains the maximum lateness in Schrage's schedule, is called the critical job. Then the maximum lateness of σ Sc (I) can be given as follows: where job a is the first job so that there is no idle time between the processing of jobs a and c, i.e., either there is idle time before a or a is the first job to be scheduled. The sequence of jobs a, a + 1, . . . , c is called the critical path in the Schrage schedule (or the critical bloc Λ). It is obvious that all jobs j in the critical path have release dates r j ≥ r a .
Let L * max (I) denote the optimal maximum lateness for a given instance I. We will write briefly L * max if it is clear from the context. For every subset of jobs F ⊂ J the following useful lower bound is valid.
If c has the smallest tail in Λ = {a, a + 1, . . . , c}, sequence σ Sc (I) is optimal by inequality (1). Otherwise, there exists an interference job b ∈ Λ such that Let Λ b := {b + 1, b + 2, . . . , c} be the jobs in Λ processed after the interference job b. Clearly, q j ≥ q c > q b and r j > s b hold for all j ∈ Λ b , where s b denotes the starting time of the interference job b. Inequality (1) applied to Λ b gives with (2) the lower bound where p(Λ b ) is the sum of processing times of jobs in Λ b .
Since there is no idle time during the execution of the jobs of the critical sequence, the maximum lateness of Schrage's schedule is L max (σ Sc (I)) = s b + p b + p(Λ b ) + q c . Subtracting this equation from (3) we get the following upper bound for the absolute error in terms of the processing time Notice that using L * max ≥ p b and applying inequality (4) shows that Schrage yields a relative performance guarantee of 2.
It is well-known that Schrage's sequence is optimal with respect to the makespan, i.e., 3 PTAS for the first scenario: 1|r j , C j ≤ d|L max In this section, we consider problem Π 1 with a common deadline d for the jobs. By (5) the Schrage sequence shows whether a feasible solution for Π 1 exists or not. If C max (σ Sc (I)) > d, then the problem has no feasible solution. Hence, we will assume in the following that Let ε > 0. A job j is called large if p j ≥ εL max (σ Sc (I))/2, otherwise it is called small. Let L be the subset of large jobs. Since L max (σ Sc (I)) ≤ 2L * max (see [12]), it can be observed that |L| ≤ 2/ε. Let k = |L|. We assume that jobs are indexed such that L = {1, 2, . . . , k}.
Our PTAS is based on the construction of a set of modified instances starting from the original instance I. Set R = {r 1 , . . . , r n } and Q = {q 1 , . . . , q n }. Let us define the following sets of heads and tails: Now, we define the set of all the combinations of couples (r, q) ∈ R (i) × Q(i) for every i = 1, 2, . . . , k: Clearly, the cardinality of W is bounded as follows: |W | ≤ n 2k = O(n 4/ε ). Let w ∈ W with w = ( r 1 , q 1 , r 2 , q 2 , . . . , r k , q k ). Instance I w is a slight modification of instance I and is defined as follows. I w consists of large and small jobs. The k large jobs have modified release times r 1 , r 2 , . . . , r k and delivery times q 1 , q 2 , . . . , q k . All processing times and the n − k small jobs remain unchanged. Let I be the set of all possible instances I w , i.e., I = {I w |w ∈ W }. It is clear that |I| is in O(n 4/ε ). By the modification, the processing times of instances in I are not changed and release times and delivery times are not decreased.
Let I ⊆ I. An instance I ′ ∈ I is called maximal if there is no other instance I ′′ ∈ I such that for every i = 1, 2, . . . , k, we have r ′ i ≤ r ′′ i , q ′ i ≤ q ′′ i and at least one inequality is strict. Here, r ′ i , q ′ i denote the heads and tails in I ′ and r ′′ i , q ′′ i the heads and tails in I ′′ , respectively. Now, we can introduce our procedure PTAS1 which depends on the instance I, the deadline d and the accuracy ε.

Algorithm P T AS1(I, d, ε)
Input: An instance I of n jobs, a deadline d and an accuracy ε.
1. Run Schrage's algorithm for all instances in I.
2. Select the best feasible solution, i.e., the best solution with C max ≤ d. Apply the corresponding sequence to the original instance I.
Let σ * (I) be a sequence for instance I which is optimal for L max under the constraint C max (σ * (I)) ≤ d. Let I ∈ I be an instance which is compatible with σ * (I), i.e., r j ≤ s j (σ * (I)) for j = 1, 2, . . . , k, The set of all instances I ∈ I which are compatible with σ * is denoted as I σ * . By (6) instance I fulfills the conditions (7) to (9). Thus, I σ * is nonempty.
Proof. Let I max be a maximal instance in I σ * . Applying Schrage's algorithm to I max gives the sequence σ Sc (I max ). We show and From (5) and (7) we conclude that C max (σ Sc (I max )) ≤ C max (σ * (I max )) ≤ d and (10) follows.
-Case 2: σ Sc (I max ) is not optimal. Thus, there is an interference job b. Recall that Λ b = {b, b + 1, . . . , c} is the set of jobs processed after the interference job until the critical job c. By (4) L max (σ Sc (I max )) − L max (σ * (I max )) < p b . If b is not large, then (11) follows immediately with (4). Otherwise, two subcases occur.
Subcase 2.a: σ Sc (I max ) is not optimal and at least one job of Λ b is processed before b in the optimal solution. Thus, b cannot start before r min = min i∈Λ b {r i } > s b . Consequently, r b can be increased to r min and the new instance fulfills the conditions (7) to (9), which contradicts the maximality of I max .
is not optimal and all the jobs of Λ b are processed after b in the optimal solution. Thus, q b can be increased to q c and the new instance fulfills the conditions (7) to (9), which again contradicts the maximality of I max .
Thus, we have found a sequence which is a (1+ε)-approximation for Π 1 . Since I has at most O(n 4/ε ) elements, algorithm PTAS1 runs in polynomial time.
4 PTAS for the second scenario: 1|r j |L max , C max Computing a set of solutions which covers all possible trade-offs between different objectives can be understood in different ways. We will define this (as most commonly done) as searching for "efficient" solutions. Given an instance I a sequence σ(I) dominates another sequence σ ′ (I) if L max (σ(I)) ≤ L max (σ ′ (I)) and C max (σ(I)) ≤ C max (σ ′ (I)) (12) and at least one of the inequalities (12) is strict. The sequence σ(I) is called efficient or Pareto optimal if there is no other sequence which dominates σ(I). The set P of efficient sequence for I is called Pareto frontier.
We have also to define what we mean by an approximation algorithm with relative performance guarantee for our bicriteria scheduling problem. A sequence σ(I) is called a (1 + ε)-approximation algorithm of a sequence σ ′ (I) if and hold.
A set F ε of schedules for I is called a (1 + ε)-approximation of the Pareto frontier if, for every sequence σ ′ (I) ∈ P, the set F ε contains at least one sequence σ(I) that is a (1 + ε)-approximation of σ ′ (I).
A PTAS for the Pareto frontier is an algorithm which outputs for every ε > 0, a (1+ε)-approximation of the Pareto frontier and runs in polynomial time in the size of the input.
The Pareto frontier of an instance of a multiobjective optimization problem may contain an arbitrarily large number of solutions. On the contrary, for every ε > 0 there exists a (1 + ε)-approximation of the Pareto frontier that consists of a number of solutions that is polynomial in the size of the instance and in 1 ε (under reasonable assumptions). An explicit proof for this observation was given by Papadimitriou and Yannakakis [19]. Consequently, a PTAS for a multiobjective optimization problem does not only have the advantage of computing a provably good approximation in polynomial time, but also has a good chance of presenting a reasonably small set of solutions.
Our PTAS for the Pareto frontier of problem Π 2 has even the stronger property that for every sequence σ ′ (I) ∈ P, the set F ε contains a sequence such that (13) holds and (14) is replaced by the inequality C max (σ(I)) ≤ C max (σ ′ (I)).
Algorithm P T AS2(I, ε) Input: An instance I of n jobs and an accuracy ε.
Output: A PTAS for the Pareto frontier of problem Π 2 .
1. Run Schrage's algorithm for all instances in I and store the solutions in set F ε .
2. Remove all sequences from F ε which are dominated by other sequences in F ε .
Theorem 2 Algorithm PTAS2 yields a PTAS for problem Π 2 such that for every sequence σ ′ (I) ∈ P, the set F ε contains a sequence σ(I) such that (13) and (15) hold. PTAS2 has polynomial running time for fixed ε.
Proof. The running time of PTAS2 is polynomial because the set I contains only a polynomial number of instances. Let σ ′ (I) be a Pareto optimal sequence for problem Π 2 with C max (σ ′ (I)) = d.
Algorithm P T AS1(I, d, ε) of Section 3 outputs a sequence σ(I) which fulfills both (13) and (15). Since sequence σ(I) is also found in Step 1 of Algorithm PTAS2, the theorem follows.
5 PTAS for the third scenario: 1, h 1 |r j |L max The third scenario 1, h 1 |r j |L max , denoted as Π 3 , is studied in this section. The proposed PTAS for this scenario is related to the first one and it is based on several steps. In the remainder of this section, I denotes a given instance of Π 3 and ε is the desired accuracy. Since a 2-approximation for 1, h 1 |r j |L max has been established in [7], we consider only ε < 1. Without loss of generality, in any instance I of problem Π 3 , we assume that r j / ∈ [T 1 , T 2 [ for j ∈ J and that if r j < T 1 , then the inequality r j + p j ≤ T 1 should hold. Otherwise, in both cases, r j would be set equal to T 2 . Thus, jobs in J can be partitioned in two disjoint subsets X and Y where X = {j ∈ J|r j + p j ≤ T 1 } and Y = {j ∈ J|r j ≥ T 2 }.
Finally, we assume that 1/ε is integer (1/ε = f ) and that every instance I of problem Π 3 respects the conditions expressed in the following proposition. Proof. We simplify the instance I as follows. Split the interval [0, max j∈J {q j }] into 1/ε equal length intervals and round up every tail q j to the next multiple of εq. Clearly, every tail will not be increased by more than εq ≤ εL * max (I). Then, we obtain that the modified instance has an optimal solution of a maximum lateness less than or equal to (1 + ε) L * max (I). Since all the jobs of Y should be scheduled after T 2 in any feasible solution of I, our PTAS will focus on subset X. More precisely, this PTAS will be based on guessing the disjoint subsets X 1 and X 2 (X 1 ⊂ X, X 2 ⊂ X and X 1 ∪ X 2 = X) such that X 1 (respectively X 2 ) contains the jobs to be scheduled before T 1 (respectively after T 2 ). In the optimal solution, we will denote the jobs of X to be scheduled before T 1 (respectively after T 2 ) by X * 1 (respectively by X * 2 ). It is clear that if we are able to guess correctly X * 1 in polynomial time, then it is possible to construct a PTAS for Π 3 . Indeed, we can associate the scheduling of the jobs in X * 1 before T 1 with a special instance I * 1 of Π 1 where the jobs to be scheduled are those in subset X * 1 and the deadline is equal to T 1 . On the other hand, the scheduling of the other jobs in X * 2 ∪ Y after T 2 can be seen as a special instance I * 2 of problem Π 0 , with all release times greater or equal to T 2 . Consequently, Clearly, the optimal sequence σ * 1 of I * 1 should satisfy the feasibility condition As a consequence, by applying PTAS1 with d = T 1 or another existing PTAS for Π 0 (for example PTAS1 with d set to ∞ or the PTAS by Hall and Shmoys [6]), we would get a PTAS for problem Π 3 . Unfortunately, it is not possible to guess the exact subset X * 1 in a polynomial time, since the potential number of the candidate subsets X 1 is exponential. Nevertheless, we will show later that we can guess in a polynomial time another close/approximate subset X # 1 for which the associated instance I # 1 of Π 1 and its optimal solution σ # 1 verify the following relations: As the core of our problem of designing a PTAS for Π 3 is to schedule correctly the jobs of X, our guessing approach will be based on a specific structure on X. In the next paragraph, we will describe such a structure. Then, we present our PTAS and its proof.

Defining a structure for the jobs in X
In this subsection, we will focus on the jobs of X and partition them into subsets. Recall that P = n j=1 p j . Set δ = ε 2 P 4 . A job j ∈ X is called a big job if p j > δ. Let B ⊂ X denote the set of big jobs. Obviously, |B| < 4/ε 2 . The set S = X\B represents the subset of small jobs. We partition S into f subsets S(k), 1 ≤ k ≤ f , where jobs in S(k) have identical tails of length kεq.

Description of the PTAS for Π 3
As we mentioned before, our proposed PTAS for problem Π 3 is based on guessing the subset of jobs X 1 ⊂ X to be scheduled before T 1 (X 2 = X\X 1 will be scheduled after T 2 ). For every guessed subset X 1 ⊂ X in our PTAS, we associate an instance I 1 of Π 1 with d = T 1 . To the complementary subset X 2 ∪ Y we associate an instance I 2 of Π 0 after setting all the release times in X 2 to T 2 . In order to solve the generated instances I 2 , we use PTAS1 with d = ∞. (Alternatively, we could also use the existing PTAS by Hall and Shmoys for Π 0 . More details on this PTAS are available in [6].) We will abbreviate P T AS1(I, ∞, ε) by P T AS0(I, ε). For instances I 1 we apply P T AS1(I 1 , T 1 , 3ε/5) and for instances I 2 , we apply P T AS0(I 2 , ε/3). The guessing of X 1 and the details of our PTAS are described in procedure PTAS3.
Algorithm P T AS3(I, T 1 , T 2 , ε) Input: An instance I of n jobs, integers T 1 , T 2 with T 1 ≤ T 2 and an accuracy ε.
Output: A sequence σ(I) with L max (σ(I)) ≤ (1+ε)L * max (I) respecting the non-availability interval ]T 1 , T 2 [. 1. The big jobs B 1 to be included in X 1 are guessed from B by complete enumeration. For every guess of B 1 , the jobs B\B 1 will be a part of X 2 .
2. The small jobs to be included in X 1 are guessed for each subset S(k), 1 ≤ k ≤ f , by choosing one of the m(k) + 1 possible subsets S k,z , 0 ≤ z ≤ m(k). Thus, . Set all the release times of jobs in X 2 to T 2 .
3. With every guessed subset X 1 in Step 2, we associate an instance I 1 of Π 1 with d = T 1 . With the complementary subset X 2 ∪Y we associate an instance I 2 of Π 0 . Apply P T AS1(I 1 , T 1 , 3ε/5) for solving instance I 1 of Π 1 and P T AS0(I 2 , ε/3) for solving instance I 2 of Π 0 . Let σ 1 and σ 2 be the obtained schedules from P T AS1(I 1 , T 1 , 3ε/5) and P T AS0(I 2 , ε/3), respectively. If they are feasible, then merge σ 1 and σ 2 to get σ, which represents a feasible solution for instance I of Π 3 .

4.
Return σ(I), the best feasible schedule from all the complete merged schedules for I in Step 3.

Proof of the PTAS for Π 3
Denote the jobs from S(k) which are scheduled before T 1 in the optimal solution by S k, * . If 0 ≤ p (S k, * ) < p(S k ) = p S k,m(k) ,then there is an integer z k ∈ {0, 1, . . . , m(k) − 1} such that We will see in the following lemma that we can get a sufficient approximation by taking the jobs of S k,z k , z k = 0, 1, . . . , m(k), instead of those in S k, * . In particular, we will see that it is possible to schedule heuristically before T 1 the jobs in S k,z k instead of those in S k, * without altering the optimal performance too much. By selecting jobs with minimal release times we maintain the feasibility of inserting these jobs before T 1 instead of S k, * . Inequalities (21) and (22) imply that there is an integer z k ∈ {0, 1, . . . , m(k) − 1} such that holds for 0 ≤ p (S k, * ) < p (S k ).
Note that if S k, * = S(k) holds, the guessing procedure ensures that for z k = m(k) we get S k,m(k) = S(k).
Recall that X * 1 (respectively X * 2 ∪Y ) is the subset of jobs to be scheduled before T 1 (respectively after T 2 ) in the optimal schedule σ * (I) of a given instance I of Π 3 . Let I * 1 , I * 2 denote the corresponding instances of problems Π 1 and Π 0 , and σ * 1 (I * 1 ), σ * 2 (I * 2 ) the associated optimal schedules, respectively. Then, we get.
Lemma 4 There is a subset X # 1 ⊂ X, generated in Step 2 of PTAS3, for which we can construct two feasible schedules σ # 1 (I # 1 ) and σ # 2 (I # 2 ) such that: where I # 1 is an instance of Π 1 where we have to schedule the jobs of X # 1 before T 1 and I # 2 is an instance of Π 0 where we have to schedule the jobs of (X\X # 1 ) ∪ Y after T 2 .
Theorem 5 Algorithm PTAS3 is a PTAS for problem Π 3 .
6 PTAS for the fourth scenario: 1, ON A|r j |L max The studied scenario Π 4 can be formulated as follows. An operator has to schedule a set J of n jobs on a single machine, where every job j has a processing time p j , a release date r j and a tail q j . The machine can process at most one job at a time if the operator must be available at the starting time and the completion time of such a job. The operator is unavailable during ]T 1 , T 2 [. Preemption of jobs is not allowed (jobs have to be performed under the non-resumable scenario). As in the previous scenarios, we aim to minimize the maximum lateness.
If for every j ∈ J we have p j < T 2 − T 1 or r j T 2 , it can be easily checked that Π 4 is equivalent to an instance of Π 3 for which we can apply the PTAS described in the previous section. Hence, in the remainder we assume that there are some jobs which have processing times greater than T 2 − T 1 and can complete before T 1 . Let K denote the subset of these jobs. Similarly to the transformation proposed in [10], the following theorem on the existence of the PTAS for Scenario Π 4 can be proved.

Theorem 6 Scenario Π 4 admits a PTAS.
Proof. We distinguish two subcases: • Subcase 1: there exists a job s ∈ K, called straddling job, such that in the optimal solution it starts not later than T 1 and completes not before T 2 .
• Subcase 2: there is no straddling job in the optimal solution.
It is obvious that Subcase 2 is equivalent to an instance of Π 3 for which we have established the existence of a PTAS. Thus, the last step necessary to prove the existence of a PTAS for an instance of Π 4 is to construct a special scheme for Subcase 1. Without loss of generality, we assume that Subcase 1 holds and that the straddling job s is known (indeed, it can be guessed in O(n) time among the jobs of K). Moreover, the time-window of the starting time t * s of this job s in the optimal solution fulfills t * s ∈ [T 2 − p s , T 1 ].
If T 2 −p s = T 1 , i.e., the interval [T 2 −p s , T 1 ] consists of a single point T 1 , we can apply P T AS3(I, T 1 , T 1 , ε). Otherwise, set We consider a set of ⌈1/ε⌉ + 1 instances {I 0 , I 1 , . . . , I ⌈1/ε⌉ } of Π 4 where in I h the straddling job s starts at time t h s . Each such instance is equivalent to an instance of Π 3 with a set of jobs J − {s} and a machine non-availability interval ∆ h with For every instance from {I 0 , I 1 , . . . , I ⌈1/ε⌉ }, we apply PTAS3 and select the best solution among all the ⌈1/ε⌉ + 1 instances.
If t * s = T 2 − p s , PTAS3 applied to I 0 is the right choice. In all other cases, there is an h ∈ {0, 1, . . . , ⌈1/ε⌉} with t * s ∈]t h s , t h+1 s ]. Delaying s and the next jobs in the optimal schedule of I h+1 , h = 0, 1, . . . , ⌈1/ε⌉ − 1, will not cost more than Thus, the solution Ω h obtained by PTAS3 for I h , h = 1, 2, . . . , ⌈1/ε⌉) is sufficiently close to an optimal schedule for Subcase 1 if s is the straddling job and t * s ∈]t h s , t h+1 s ]. As a conclusion, Subcase 1 has a PTAS.

Conclusions
In this paper, we considered important single-machine scheduling problems under release times and tails assumptions, with the aim of minimizing the maximum lateness. Four variants have been studied under different scenarios. In the first scenario, all the jobs are constrained by a common deadline. The second scenario consists in finding the Pareto front where the considered criteria are the makespan and the maximum lateness. In the third scenario, a non-availability interval constraint is considered (breakdown period, fixed job or a planned maintenance duration). In the fourth scenario, the non-availibility interval is related to the operator who is organizing the execution of jobs on the machine, which implies that no job can start, and neither can complete during the operator non-availability period. For each of these four open problems, we establish the existence of a PTAS.
As a perspective, the study of min-sum scheduling problems in a similar context seems to be a challenging subject.
Otherwise, in case S k, * = ∅, we set G k = ∅. Finally, define In addition, we recall that S k,z k = {(k, 1), (k, 2), ..., (k, e(z k ))}. In our feasible schedule σ # 1 (I # 1 ), we will schedule the jobs of this subset S k,z k according to the following heuristic procedure Schedule # . It assigns the jobs to the intervals G u,k but throughout the procedure starting and finish times of these intervals may be changed (e.g. when there is some overload of jobs) or they are simply shifted to the right. 3. For u = 1 to u = γ k do: 3.1 Process remaining jobs from S k,z k (in non-decreasing order of release dates) starting at time a * u,k + α u−1 until the first job finishes at time t ≥ b * u,k or all jobs from S k,z k are assigned. Let job (k, l) be the last scheduled job from this set with completion time C (k,l) .
3.2 If l = e(z k ) set G u,k = [a * u,k + α u−1 , b * u,k ] and Stop: All items from S k,z k are assigned. 3.3 Else set α u = C (k,l) − b * u,k and G u,k = [a * u,k + α u−1 , b * u,k + α u ] = [a * u,k + α u−1 , C (k,l) ]. 3.4 Shift intervals from G which are located between b * u,k and a * u+1,k without any modification of their lengths by α u+1 to the right.

End For
Notice that the value α u represents the "overload" of the u-th interval G u,k in a given set G k . The following interval G u+1,k is then shortened by the same amount α u . Consequently, only the intervals between G u,k and G u+1,k are shifted to the right, but no others. Moreover, the total processing time assigned until b * u+1,k in the k-th iteration of Schedule # is not greater than the original total length of the intervals G 1,k , G 2,k , . . . , G u+1,k . Since for every family k the jobs in S k,z k have the smallest release times and since by (20) these jobs are sorted in non-decreasing order of release times, no idle time is created during Step 3. Together with the first inequality of (23) this guarantees that the all jobs of family k are processed without changing the right endpoint of the last interval G γ k ,k , i.e., creating no overload in this interval. That ensures the feasibility of the schedule yielded by Schedule # and that G γ k ,k = [a * γ k ,k + α γ k −1 , b * γ k ,k ].
In each iteration of the procedure the jobs will be delayed by at most max u≤γ k {α u } ≤ δ. Since this possible delay may occur for every family k, k = 1, 2, ..., f , the possible overall delay for every job, after the f applications of procedure Schedule # is therefore bounded by f δ. Hence, (24) follows.
The finishing time of the last interval among the intervals G γ k ,k , k = 1, . . . , f , generated by Schedule # determines the makespan of instance I # 1 . But this interval is never shifted to the right and we obtain (25).
Recall that if S k, * = S(k), we get with z k = m(k) that S k,m(k) = S(k). Hence, in the case that no jobs of family k are scheduled after T 2 in σ * 2 (I * 2 ), also σ # 2 (I # 2 ) contains no jobs of family f . Hence, assume in the following that S(k)\S k, * = ∅ and let [c be the intervals in which the jobs of S(k)\S k, * are scheduled in the optimal schedule σ * 2 (I * 2 ). The schedule σ # 2 (I # 2 ) will be created similarly to procedure Schedule # . As a consequence of performing possibly less amount of jobs from every S(k) before T 1 in the feasible schedule σ # 1 (I # 1 ), an additional small quantity of processing time must be scheduled after T 2 compared to the optimal solution. This amount is bounded by 2δ by the second inequality of (23). Therefore, in each iteration k we start by enlarging the last interval by 2δ, i.e., [c * λ k ,k , d * λ k ,k + 2δ] instead of [c * λ k ,k , d * λ k ,k ], and shifting those jobs starting after d * λ k ,k in σ * 2 (I * 2 ) by the same distance 2δ to the right. Then, all what we have to do in order to continue the construction of our feasible schedule σ # 2 (I # 2 ) is to insert the remaining jobs from every S(k)\S k,z k in the corresponding intervals [c * 1,k , d * 1,k ], [c * 2,k , d * 2,k ], . . . , [c * λ k ,k , d * λ k ,k + 2δ] like in iteration k of procedure Schedule # . Analogously to Schedule # intervals between d * u,k and c * u+1,k are shifted to the right by some distance bounded by δ. Thus, in a certain iteration k jobs are shifted to the right by not more than max{2δ, δ} = 2δ. Since the possible delay may occur for every job family k, the possible overall delay for every job scheduled in σ # 2 (I # 2 ) is bounded by 2f δ. This shows that inequality (26) is valid.
APPENDIX 2: Proof of Theorem 5 Proof. The big jobs B 1 to be included in X 1 are completely guessed from B in O(2 4/ε 2 ). The small jobs to be included in X 1 are guessed from every subset S(k) by considering only the m(k) + 1 possible subsets S k,z . This can be done for every guessed B 1 in O((m(k) + 1) f ) = O( 4/ε 2 1/ε ) time. In overall, the guessing of all the subsets X 1 will be done in O(2 4/ε 2 . 4/ε 2 1/ε ). Hence, from the computational analysis of the different steps of PTAS3, it is clear that this algorithm runs polynomially in the size of instance I of Π 3 for a fixed accuracy ε > 0.
This finishes the proof of Theorem 5.