A Note on a Fully Polynomial-Time Approximation Scheme for Minimizing Makespan of Deteriorating Jobs

Abstract

In (1998), Kovalyov and Kubiak studied the problem of scheduling 𝑛 deteriorating jobs on a single machine to minimize makespan. They presented a fully polynomial-time approximation scheme which is based on a dynamic programming. Unfortunately, their dynamic programming is incorrect. So the fully polynomial-time approximation scheme is also invalid. In this paper, we construct an instance to show how their dynamic programming does not work and provide a correct dynamic programming, based on which a new fully polynomial-time approximation scheme is derived.

1. Introduction

For most scheduling problems, the job processing times are fixed parameters whenever they start. However, such restrictive assumptions do not hold in some environments of financial management, steel production, resource allocation, national defense, and so forth, where the jobs can deteriorate when they are delayed. To the best of our knowledge, Brown and Yechiali [1] and Kunnathur and Gupta [2] initiated the problems of scheduling the deteriorating jobs nonpreemptively. They mainly considered the single-machine makespan problems with job deterioration. Mosheiov [3] first concerned the job deterioration single-machine scheduling problem for which the only machine is available at any given time point. Chen [4] extended the study to the parallel-machine scheduling problem for which the objective is to minimize the total completion time of the jobs. He showed that it is ordinarily NP-hard when the number of the machines is fixed and strongly NP-hard when the number of the machines is input. Ji and Cheng [5] considered the parallel-machine scheduling problem with the objective to minimize the makespan and showed that the problem is ordinarily NP-hard when the number of the machines is fixed and strongly NP-hard when the number of the machines is input. Wu and Lee [6] first studied the deteriorating job scheduling problem under the machine availability constraint condition. For more papers about this topic, the reader is referred to Fan et al. [7], Ji et al. [8], and Li and Fan [9].

In this paper, we revisit the following single machine scheduling problem with bounded deterioration introduced in [10]. There are 𝑛 independent jobs that need to be processed on a single machine. The machine is continuously available for processing from time zero onwards, and it can process at most one job at a time. Each job 𝐽_𝑗 has a basic processing time denoted by 𝑝_𝑗,  𝑗=1,2,…,𝑛. The jobs have a given common critical date 𝑑 after which they start to deteriorate and a common maximum deterioration date 𝐷  (𝑑<𝐷<∞) after which the jobs deteriorate no further. The actual processing time 𝑎_𝑗(𝑡) of job 𝐽_𝑗 is stated as follows: 𝑎_𝑗(𝑡)=𝑝_𝑗𝑝,if𝑡≤𝑑,_𝑗+𝑤_𝑗()𝑝𝑡−𝑑,if𝑑<𝑡<𝐷,_𝑗+𝑤_𝑗(𝐷−𝑑),if𝑡≥𝐷. (1) Here 𝑤_𝑗≥0 is the deterioration rate of job 𝐽_𝑗 and 𝑡 denotes the start time of job 𝐽_𝑗. Without loss of generality, we assume that 𝑑, 𝐷, 𝑝_𝑗, 𝑤_𝑗 are integral. The problem is to schedule the jobs to minimize makespan 𝐶_max, that is, the completion time of the last job. Following the notation in Kovalyov and Kubiak [11], we denote this problem by DET for simplicity.

For problem DET, Kovalyov and Kubiak [11] presented a dynamic programming and a fully polynomial-time approximation scheme (FPTAS). Unfortunately, their dynamic programming is incorrect. So their FPTAS is also invalid.

In this paper, we construct an instance to show how their dynamic programming does not work and provide a correct dynamic programming, based on which a new FPTAS is derived.

The rest of this paper is constructed as follows. We first give some preliminary knowledge in Section 2. In Section 3, we give a counterexample and show that the dynamic programming in [11] does not work. In Section 4, we provide a correct dynamic programming based on which an FPTAS is presented.

2. Preliminaries

Let 𝜀 be a positive number. An algorithm 𝐴_𝜖 for problem DET is a (1+𝜖)-approximation algorithm if 𝐶^𝐴≤(1+𝜖)𝐶^∗ for all instances, where 𝐶^∗ is the optimal makespan and 𝐶^𝐴 is the makespan obtained by the algorithm. A family of (1+𝜖)-approximation algorithm {𝐴_𝜖} defines a fully polynomial-time approximation scheme (FPTAS for short), if for any 𝜖>0, 𝐴_𝜖 runs in time bounded by a polynomial of 𝑛, 𝐿, and 1/𝜖, where 𝐿=logmax{𝑛,𝐷,1/𝜖,𝑝_max,𝑤_max} is the number of bits in the binary encoding of the largest numerical parameter in the input with 𝑝_max=max_{1≤𝑗≤𝑛}{𝑝_𝑗} and 𝑤_max=max_{1≤𝑗≤𝑛}{𝑤_𝑗}. In the sequel, we may assume 0<𝜖≤1.

We can assume that ∑^𝑛_𝑗=1𝑝_𝑗>𝑑. Otherwise, the problem becomes trivial. Furthermore, if there is idle time on the machine in any schedule, we can eliminate the idle time and shorten the makespan of the schedule. So a schedule can be determined by a permutation of jobs. Under the two conditions, for any given schedule, there is a unique job that starts by time 𝑑 and completes after time 𝑑. We call such a job pivotal. Any job that starts before 𝑑 and completes by 𝑑 is called early, any job that starts after 𝑑 but by 𝐷 is called tardy, and any job that starts after 𝐷 is called suspended. For each job 𝐽_𝑘, we write 𝑠^𝑘_𝑉=max{𝑑+1,𝑝_𝑘} and 𝑠^𝑘_𝑈=𝑑+𝑝^𝑘. If 𝐽_𝑘 is a pivotal job with completion time 𝑠, then 𝑠^𝑘_𝑉≤𝑠≤𝑠^𝑘_𝑈. Thus, 𝑠^𝑘_𝑉 and 𝑠^𝑘_𝑈 are the lower bound and upper bound of the pivotal job 𝐽_𝑘, respectively.

For a given job 𝐽_𝑘 and an integer 𝑠 with 𝑠^𝑘_𝑉≤𝑠≤𝑠^𝑘_𝑈, let DET(𝑘,𝑠) be the restricted DET problem in which the pivotal job is 𝐽_𝑘 and the completion time of 𝐽_𝑘 is 𝑠. Notice that there must exist a pair (𝑘^∗,𝑠^∗) with 𝑘^∗∈{1,2,…,𝑛} and 𝑠^𝑘∗_𝑉≤𝑠^∗≤𝑠^𝑘∗_𝑈, such that the optimal solution of the restricted problem DET(𝑘^∗,𝑠^∗) is also optimal for problem DET. Thus problem DET can be reduced to the solving of these restricted problems DET(𝑘,𝑠) with 𝑘=1,2,…,𝑛 and 𝑠=𝑠^𝑘_𝑉,𝑠^𝑘_𝑉+1,…,𝑠^𝑘_𝑈. Notice that the number of the restricted problems is exponential in the size of problem DET.

To guarantee that each restricted problem DET(𝑘,𝑠) (1≤𝑘≤𝑛, 𝑠^𝑘_𝑉≤𝑠≤𝑠^𝑘_𝑈) has a solution, we allow the machine to be idle before the starting time of the first job in a schedule of DET(𝑘,𝑠). Then the total processing time of the early jobs is upper bounded by 𝑠−𝑝_𝑘 in every feasible schedule of problem DET(𝑘,𝑠).

For a fixed job 𝐽_𝑘, let 𝑠^∗ and 𝑠^′ be two time points such that 𝑠^𝑘_𝑉≤𝑠^∗<𝑠^′≤𝑠^𝑘_𝑈 and 𝑠^′−𝑠^∗≤𝛿(𝑠^∗−𝑑), where 0<𝛿≤1. Let 𝑥^∗ and 𝑥^′ be the optimal solutions to the restricted problems DET(𝑘,𝑠^∗) and DET(𝑘,𝑠^′), respectively. The following lemma shows that we will have only a little loss if we use 𝑥^′ instead of 𝑥^∗ as a solution of problem DET(𝑘,𝑠^∗).

Remark 1. The following two lemmas are established in Kovalyov and Kubiak [11]. We present more clarified proofs for completion.

Lemma 2. 𝐶_max(𝑥^′)≤(1+𝛿)𝐶_max(𝑥^∗).

Proof. Recall that 𝑠^𝑘_𝑉≤𝑠^∗≤𝑠^′≤𝑠^𝑘_𝑈. Then the total processing time of the early jobs in 𝑥^∗ is upper bounded by 𝑠^∗−𝑝_𝑘≤𝑠^′−𝑝_𝑘≤𝑑. Let 𝑥⁻ be the schedule obtained from 𝑥^∗ by shifting the processing of all jobs right so that 𝐽_𝑘 completes at time 𝑠^′. Then 𝐽_𝑘 is also the pivotal job in 𝑥⁻, and the starting time of the earliest tardy job (if any) in 𝑥⁻ is 𝑠^′. Since 𝑥⁻ is a feasible solution of DET(𝑘,𝑠^′), we have 𝐶_max(𝑥^′)≤𝐶_max(𝑥⁻). Note that the suspended jobs in 𝑥^∗ remain suspended in 𝑥⁻. Suppose that (𝐽₁,𝐽₂,…,𝐽_𝑙) be the order of the tardy jobs in 𝑥^∗. Let 𝑝^∗_𝑗 and 𝑝⁻_𝑗 be the actual processing time of job 𝐽_𝑗 in 𝑥^∗ and 𝑥⁻, respectively, 𝑗=1,2,…,𝑙. Then 𝑝⁻₁−𝑝^∗₁≤𝑤₁𝑡₀=𝑡₁,𝑝⁻₂−𝑝^∗₂≤𝑤₂𝑡₀+𝑡₁=𝑡₂,⋮𝑝⁻_𝑙−𝑝^∗_𝑙≤𝑤_𝑙𝑡₀+𝑡₁+⋯+𝑡_𝑙−1=𝑡_𝑙, (2) where 𝑡₀=𝑠^′−𝑠^∗. This means that each 𝐽_𝑗 is postponed at most ∑^𝑗−1_𝑖=1𝑡_𝑖 to be processed in 𝑥⁻, 𝑗=1,2,…,𝑙. Therefore, 𝐶_max𝑥^′−𝐶_max𝑥^∗≤𝐶_max(𝑥⁻)−𝐶_max𝑥^∗≤^𝑙_𝑖=0𝑡_𝑖=^𝑙_𝑖=11+𝑤_𝑖𝑠^′−𝑠^∗. (3) On the other hand, since 𝐽₁ starts at 𝑠^∗ in solution 𝑥^∗, we have 𝑝^∗₁≥𝑤₁𝑟₀=𝑟₁,𝑝^∗₂≥𝑤₂𝑟₀+𝑟₁=𝑟₂,⋮𝑝^∗_𝑙≥𝑤_𝑘𝑟₀+𝑟₁+⋯+𝑟_𝑙−1=𝑟_𝑙, (4) where 𝑟₀=𝑠^∗−𝑑. Hence, 𝐶_max𝑥^∗≥𝑟₀+^𝑘_𝑗=1𝑝^∗_𝑗≥^𝑙_𝑗=0𝑟_𝑗=^𝑙_𝑖=11+𝑤_𝑖𝑟₀. (5) Note that 𝑠^′−𝑠^∗≤𝛿(𝑠^∗−𝑑)=𝛿𝑟₀. Then we have 𝐶_max𝑥^′≤𝐶_max𝑥^∗+^𝑙_𝑖=11+𝑤_𝑖𝑠^′−𝑠^∗≤𝐶_max𝑥^∗+𝛿^𝑘_𝑖=11+𝑤_𝑖𝑟₀≤(1+𝛿)𝐶_max𝑥^∗. (6) The lemma follows.

By Lemma 2, we may first partition [𝑠^𝑘_𝑉,𝑠^𝑘_𝑈] into ℎ^𝑘 subintervals [𝑡^𝑘_𝑖,𝑡^𝑘_𝑖+1] such that 𝑡^𝑘_𝑖+1−𝑡^𝑘_𝑖≤𝛿(𝑡^𝑘_𝑖−𝑑), 𝑖=0,1,…,ℎ^𝑘−1, where ℎ^𝑘≤log_(1+𝛿)𝑝_𝑘+1. Let 𝑥 be the best solution among the optimal solutions of the restricted problems DET(𝑘,𝑠), 𝑘=1,2,…,𝑛, 𝑠=𝑡^𝑘₁,𝑡^𝑘₂,…,𝑡^𝑘_ℎ𝑘 and let 𝑥^opt be the optimal solution of DET. Then we have 𝐶_max(𝑥)≤(1+𝛿)𝐶_max(𝑥^opt). Note that the number of these subproblems is at most 𝑛+(𝑛𝐿/𝛿) which is polynomial in the size of the input and 1/𝛿. So if we have an FPTAS for each restricted problem DET(𝑘,𝑠), then we can get an FPTAS for DET. We form the conclusion in the following lemma.

Lemma 3. If one has an FPTAS for every restricted problem DET(𝑘,𝑠), then one can get an FPTAS for DET.

Proof. We apply the an FPTAS for each of the restricted problems DET(𝑘,𝑠), 𝑘=1,2,…,𝑛, 𝑠=𝑡^𝑘₁,𝑡^𝑘₂,…,𝑡^𝑘_ℎ𝑘 within a factor of 1+𝛿. Let 𝑥̈ be the best output solution. By Lemma 2, we can easily deduce 𝐶_max(𝑥̈)≤(1+𝛿)²𝐶_max𝑥^opt≤(1+𝜖)𝐶_max𝑥^opt, (7) where 𝛿=𝜖/3≤1. The lemma follows.

By Lemma 3, we only need to design an FPTAS for any given restricted problem DET(𝑘,𝑠). Given the pivotal job 𝐽_𝑘 and the completion time 𝑠 of 𝐽_𝑘, we use 𝑟=𝑝_𝑘 to denote the processing time of job 𝐽_𝑘 and reindex the remaining 𝑛−1 jobs according to Smith’s rule [12] such that 𝑤₁/𝑝₁≥𝑤₂/𝑝₂≥⋯≥𝑤_𝑛−1/𝑝_𝑛−1. By a simple exchange of pairwise consecutive jobs, we can show that the tardy jobs is sequenced by Smith’s rule in the optimal schedule. Note that the actual processing time of early jobs and suspended jobs are unchanged. So the orders of early jobs and suspended jobs do not matter. It follows that there exists an optimal schedule in which the early jobs are sequenced arbitrarily, followed by the pivotal job, followed by the tardy jobs sequenced by Smith’s rule, and followed by the suspended jobs sequenced arbitrarily.

3. Counterexample

First we demonstrate the dynamic programming adopted by [11]. The authors introduced the 0−1 variables 𝑥_𝑗,𝑗=1,2,…,𝑛−1, where 𝑥_𝑗=0 means that 𝐽_𝑗 is early and 𝑥_𝑗=1 means that 𝐽_𝑗 is tardy or suspended. Let 𝑋 be the set of all 0−1 vectors 𝑥=(𝑥₁,𝑥₂,…,𝑥_𝑛−1). Set 𝐹₀(𝑥)𝐺=𝑠,₀(𝑥)𝑃=𝑠−𝑑,₀(𝑥)𝐹=0,_𝑗(𝑥)=𝐹_𝑗−1(𝑥)+𝑥_𝑗𝑝_𝑗+𝑤_𝑗𝐺_𝑗−1(𝑥),𝐺_𝑗(𝑥)=min𝐹_𝑗(𝑥)𝑃,𝐷−𝑑,_𝑗(𝑥)=^𝑗_𝑖=1𝑝_𝑖1−𝑥_𝑖, (8) where 𝑥∈𝑋 and 𝑗=1,2,…,𝑛−1. Note that neither 𝐹_𝑗  nor   𝐺_𝑗 nor 𝑃_𝑗 depends on 𝑥_𝑗+1,…,𝑥_𝑛−1. 𝑃_𝑗(𝑥) is the total processing time of early jobs from the job set {𝐽₁,𝐽₂,…,𝐽_𝑗}. Obviously, we should have 𝑃_𝑗(𝑥)≤𝑠−𝑟. If 𝐽_𝑗 starts at 𝐹_𝑗−1(𝑥)≥𝑠, then it is tardy or suspended and its start delay is 𝐺_𝑗−1(𝑥). Consequently, 𝐽_𝑗 finished at 𝐹_𝑗(𝑥)=𝐹_𝑗−1(𝑥)+𝑝_𝑗+𝑤_𝑗𝐺_𝑗−1(𝑥). If 𝐽_𝑗 is scheduled early, then it does not change the makespan, and so, 𝐹_𝑗(𝑥)=𝐹_𝑗−1(𝑥). Thus, problem DET(𝑘,𝑠) reduces to the following programming: min𝐹_𝑛−1(𝑥)s.t.𝑃_𝑛−1(𝑥)≤𝑠−𝑟,𝑥∈𝑋. (9)

If we require that all of the tardy and suspended jobs are processed in the nonincreasing order of Smith’s ratios, programming (9) does work. Unfortunately, for problem DET(𝑘,𝑠), the requirement cannot guarantee the optimality. Then programming (9) above is invalid to solve problem DET(𝑘,𝑠).

Consider the following job instance. We have three jobs 𝐽₁, 𝐽₂, 𝐽₃ with 𝑝₁=11, 𝑝₂=13, and 𝑝₃=15 and 𝑤₁=10, 𝑤₂=11, and  𝑤₃=12, 𝑑=0 and 𝐷=20. Since 𝑑=0, there are three restricted problems DET(1,11), DET(2,13), and DET(3,15). Note that 𝑤₁/𝑝₁>𝑤₂/𝑝₂>𝑤₃/𝑝₃.

For DET(1,11), programming (9) schedules the jobs in the order 𝐽₁≺𝐽₂≺𝐽₃ consecutively on the machine with makespan 400. But if we schedule the jobs in the order 𝐽₁≺𝐽₃≺𝐽₂ on the machine, the makespan is 391<400.

For DET(2,13), programming (9) schedules the jobs in the order 𝐽₂≺𝐽₁≺𝐽₃ consecutively on the machine with makespan 409. But if we schedule the jobs in the order 𝐽₂≺𝐽₃≺𝐽₁ on the machine, the makespan is 395<409.

For DET(3,15), programming (9) schedules the jobs in the order 𝐽₃≺𝐽₁≺𝐽₂ consecutively on the machine with makespan 409. But if we schedule the jobs in the order 𝐽₃≺𝐽₂≺𝐽₁ on the machine, the makespan is 404<409.

So the solution for DET via programming (9) has makespan 400. But the optimal solution for DET has makespan 391.

4. Dynamic Programming and FPTAS

We are now ready to formulate the recursive equations for DET(𝑘,𝑠). In a feasible schedule 𝑥 for DET(𝑘,𝑠) the 𝑛−1 jobs other than 𝐽_𝑘 are partitioned into 𝐸(𝑥), 𝑇(𝑥), and 𝑆(𝑥), where 𝐸(𝑥) is the set of all early jobs, 𝑇(𝑥) is the set of all tardy jobs, and 𝑆(𝑥) is the set of all suspended jobs. Recall that 𝑟=𝑝_𝑘, and the 𝑛−1 jobs other than 𝐽_𝑘 have been reindexed according to Smith’s rule such that 𝑤₁/𝑝₁≥𝑤₂/𝑝₂≥⋯≥𝑤_𝑛−1/𝑝_𝑛−1.

We introduce the variables 𝑥_𝑗∈{−1,0,1}, 𝑗=1,2,…,𝑛−1, where 𝑥_𝑗=−1 if 𝐽_𝑗 is (assumed to be) early and put into job set 𝐸(𝑥), 𝑥_𝑗=0 if 𝐽_𝑗 is (assumed to be) tardy and put into job set 𝑇(𝑥), and 𝑥_𝑗=1 if 𝐽_𝑗 is (assumed to be) suspended and put into job set 𝑆(𝑥). Then each vector 𝑥=(𝑥₁,𝑥₂,…,𝑥_𝑛−1) represents a schedule (may be infeasible) of DET(𝑘,𝑠). Let 𝑋={−1,0,1}^𝑛−1 be the set of all vectors 𝑥=(𝑥₁,𝑥₂,…,𝑥_𝑛−1) with 𝑥_𝑗∈{−1,0,1}, 1≤𝑗≤𝑛−1. Set 𝐸₀(𝑥)𝐸=0,_𝑗(𝑥)=𝐸_𝑗−1(𝑥)+12𝑥_𝑗𝑥_𝑗−1𝑝_𝑗,𝑇₀(𝑥)𝑇=𝑠,_𝑗(𝑥)=𝑇_𝑗−1(𝑥)+1+𝑥_𝑗1−𝑥_𝑗×𝑝_𝑗+𝑤_𝑗𝑇_𝑗−1(𝑥),𝑆−𝑑₀(𝑥)𝑆=0,_𝑗(𝑥)=𝑆_𝑗−1(𝑥)+12𝑥_𝑗1+𝑥_𝑗𝑝_𝑗+𝑤_𝑗(𝐷−𝑑), (10) where 𝑥∈𝑋 and 𝑗=1,2,…,𝑛−1.

Given 𝑥∈𝑋, it can be observed that 𝐸_𝑗(𝑥), 𝑇_𝑗(𝑥), and 𝑆_𝑗(𝑥) only depend on 𝑥₁,𝑥₂,…,𝑥_𝑗. We overload the notations 𝐸_𝑗(𝑥), 𝑇_𝑗(𝑥), and 𝑆_𝑗(𝑥) so that they also represent the sets of all early jobs, all tardy jobs and all suspended jobs, respectively, among the first 𝑗 jobs 𝐽₁,…,𝐽_𝑗. Then 𝐸_𝑗(𝑥) is the total processing time of the jobs in 𝐸_𝑗(𝑥), 𝑇_𝑗(𝑥) is the last completion time of the jobs in 𝑇_𝑗(𝑥), and 𝑆_𝑗(𝑥) is the total processing time of the jobs in 𝑆_𝑗(𝑥). We say that an 𝑥∈𝑋 is a quasi-feasible schedule if 𝐸_𝑛−1(𝑥)≤𝑠−𝑟. Note that the condition 𝐸_𝑛−1(𝑥)≤𝑠−𝑟 means that we should have enough time space to schedule the early jobs before the pivotal job 𝐽_𝑘. The objective value of a quasi-feasible schedule 𝑥 is defined to be 𝐶_max(𝑥)=𝑇_𝑛−1(𝑥)+𝑆_𝑛−1(𝑥).

For a quasi-feasible schedule vector 𝑥, we can process the jobs in 𝐸_𝑛−1(𝑥) starting at time 𝑠−𝑟−𝐸_𝑛−1(𝑥), followed by the pivotal job 𝐽_𝑘, followed by the jobs in 𝑇_𝑛−1(𝑥), and then followed by the jobs in 𝑆_𝑛−1(𝑥), consecutively. The real schedule generated by this way is denoted by 𝑥. We call 𝑥 the real schedule corresponding to 𝑥. We can observe that 𝐸_𝑛−1(𝑥)=𝐸(𝑥) for every quasi-feasible schedule 𝑥. In the case that 𝑇_𝑛−1(𝑥)=𝑇(𝑥) and 𝑆_𝑛−1(𝑥)=𝑆(𝑥), we just have 𝑥=𝑥.

Generally, a quasi-feasible schedule 𝑥 may not be a feasible schedule, since 𝑇_𝑛−1(𝑥) (or 𝑆_𝑛−1(𝑥)) may not be the set of tardy jobs (or the set of suspended jobs) in 𝑥. But the following lemma enables us to focus the attention on the quasi-feasible schedules.

Lemma 4. For each quasi-feasible schedule 𝑥, one has 𝐶_max(𝑥)≥𝐶_max(𝑥), and furthermore, the equality holds if and only if 𝑥=𝑥.

Proof. Since 𝐶_max(𝑥)=𝑇_𝑛−1(𝑥)+𝑆_𝑛−1(𝑥), we only need to show that 𝐶_max(𝑥)≤𝑇_𝑛−1(𝑥)+𝑆_𝑛−1(𝑥). Note that 𝐸_𝑛−1(𝑥)=𝐸(𝑥). We distinguish the following two cases.(i)𝑇_𝑛−1(𝑥)<𝐷. Then 𝑇_𝑛−1(𝑥)⊆𝑇(𝑥) and 𝑆(𝑥)⊆𝑆_𝑛−1(𝑥). For each 𝐽_𝑗∈𝑇_𝑛−1(𝑥)∪𝑆(𝑥), the actual processing time of 𝐽_𝑗 in 𝑥 is equal to the contribution of 𝐽_𝑗 for 𝑇_𝑛−1(𝑥)+𝑆_𝑛−1(𝑥) when 𝐽_𝑗 is considered. For each 𝐽_𝑗∈𝑆_𝑛−1(𝑥)∩𝑇(𝑥), the actual processing time of 𝐽_𝑗 in 𝑥 is less than the contribution of 𝐽_𝑗 for 𝑇_𝑛−1(𝑥)+𝑆_𝑛−1(𝑥) when 𝐽_𝑗 is considered. Therefore, 𝐶_max(𝑥)≤𝑇_𝑛−1(𝑥)+𝑆_𝑛−1(𝑥) with equality holding if and only if 𝑆_𝑛−1(𝑥)=∅, that is, 𝑇_𝑛−1(𝑥)=𝑇(𝑥) and 𝑆_𝑛−1(𝑥)=𝑆(𝑥)=∅.(ii)𝑇_𝑛−1(𝑥)≥𝐷. Then 𝑆_𝑛−1(𝑥)⊆𝑆(𝑥) and 𝑇(𝑥)⊆𝑇_𝑛−1(𝑥). For each 𝐽_𝑗∈𝑆_𝑛−1(𝑥)∪𝑇(𝑥), the actual processing time of 𝐽_𝑗 in 𝑥 is equal to the contribution of 𝐽_𝑗 for 𝑇_𝑛−1(𝑥)+𝑆_𝑛−1(𝑥) when 𝐽_𝑗 is considered. For each 𝐽_𝑗∈𝑇_𝑛−1(𝑥)∩𝑆(𝑥), the actual processing time of 𝐽_𝑗 in 𝑥 is less than the contribution of 𝐽_𝑗 for 𝑇_𝑛−1(𝑥)+𝑆_𝑛−1(𝑥) when 𝐽_𝑗 is considered. Therefore, 𝐶_max(𝑥)≤𝑇_𝑛−1(𝑥)+𝑆_𝑛−1(𝑥) with equality holding if and only if 𝑇_𝑛−1(𝑥)∩𝑆(𝑥)=∅, that is, 𝑇_𝑛−1(𝑥)=𝑇(𝑥) and 𝑆_𝑛−1(𝑥)=𝑆(𝑥). The lemma follows.

The result of Lemma 4 implies that an optimal quasi-feasible schedule of problem DET(𝑘,𝑠) is also an optimal schedule of the same problem. Thus problem DET(𝑘,𝑠) can be reduced to the following programming: min𝑆_𝑛−1(𝑥)+𝑇_𝑛−1(𝑥)s.t.𝑅_𝑛−1(𝑥)≤𝑠−𝑟,𝑥∈𝑋. (11)

Theorem 5. Programming (11) solves problem 𝐷𝐸𝑇(𝑘,𝑠) correctly in 𝑂(𝑛𝑑(𝑝_max+𝑤_max(𝐷−𝑑))(𝑤_sum(𝐷−𝑑)+𝑝_sum))=𝑂(𝑛²𝑑(𝑝_max+𝑤_max(𝐷−𝑑))²) time.

Proof. The correctness of programming (11) is implied in the previous discussion.
In each iteration of programming (11), we generate the values 𝐸_𝑗(𝑥), 𝑇_𝑗(𝑥), and 𝑆_𝑗(𝑥) from 𝐸_𝑗−1(𝑥), 𝑇_𝑗−1(𝑥), and 𝑆_𝑗−1(𝑥). To save the space, we only need to consider the states so that 𝐸_𝑗(𝑥)≤𝑠−𝑟 and 𝑇_𝑗(𝑥)≤𝐷+𝑝_max+𝑤_max(𝐷−𝑑). Here, 𝐸_𝑗(𝑥)≤𝑠−𝑟 means that we only consider the quasi-feasible schedules, and 𝑇_𝑗(𝑥)≤𝐷+𝑝_max+𝑤_max(𝐷−𝑑) means that any job starting at or after time 𝐷+𝑝_max+𝑤_max(𝐷−𝑑) should be a suspended job.
Write 𝑉_𝑗=(𝐸_𝑗(𝑥),𝑇_𝑗(𝑥),𝑆_𝑗(𝑥)):  𝑥∈𝑋,  𝐸_𝑗(𝑥)≤𝑠−𝑟,  𝑇_𝑗(𝑥)≤𝐷+𝑝_max+𝑤_max(𝐷−𝑑),  𝑗=0,1,…,𝑛−1. Since 𝐸_𝑗(𝑥)≤𝑠−𝑟<𝑑,  𝑑<𝑠≤𝑇_𝑗(𝑥)≤𝐷+𝑝_max+𝑤_max(𝐷−𝑑), and 𝑆_𝑗≤𝑝_sum+𝑤_sum(𝐷−𝑑), we have |𝑉_𝑗|<𝑑(𝐷−𝑑+𝑝_max+𝑤_max(𝐷−𝑑))(𝑝_sum+𝑤_sum(𝐷−𝑑)). Then |𝑉₀|+|𝑉₁|+⋯+|𝑉_𝑛−1|<𝑛𝑑(𝐷−𝑑+𝑝_max+𝑤_max(𝐷−𝑑))(𝑝_sum+𝑤_sum(𝐷−𝑑))<2𝑛𝑑(𝑝_max+𝑤_max(𝐷−𝑑))(𝑝_sum+𝑤_sum(𝐷−𝑑)). Consequently, the time complexity of programming (11) is upper bounded by 𝑂(𝑛𝑑(𝑝_max+𝑤_max(𝐷−𝑑))(𝑝_sum+𝑤_sum(𝐷−𝑑))). The lemma follows.

To construct the FPTAS, we employ a procedure called partition(𝐴,𝐻,𝑣), where 𝐴 is a set of vectors, 𝐻 is a nonnegative function in the vectors 𝑥∈𝐴, and 0<𝑣<1 is a positive number.

Procedure 𝑝𝑎𝑟𝑡𝑖𝑡𝑖𝑜𝑛(𝐴,𝐻,𝑣)(i)Arrange vectors 𝑥∈𝐴 in order 𝑥₍₁₎,𝑥₍₂₎,…,𝑥_(|𝐴|) such that 0≤𝐻(𝑥₍₁₎)≤𝐻(𝑥₍₂₎)≤⋯≤𝐻(𝑥_(|𝐴|)).(ii)Assign vectors 𝑥₍₁₎,𝑥₍₂₎,…, one by one to set 𝐴^𝐻₁ until we meet the first index 𝑖₁ such that 𝐻(𝑥_(𝑖1))≤(1+𝑣)𝐻(𝑥₍₁₎)<𝐻(𝑥_(𝑖1+1)). If such an 𝑖₁ does not exist, then set 𝐴^𝐻₁=𝐴 and stop.(iii)Assign vectors 𝑥_(𝑖1+1),𝑥_(𝑖1+2),…, one by one to set 𝐴^𝐻₂ until we meet the first index 𝑖₂ such that 𝐻(𝑥_(𝑖2))≤(1+𝑣)𝐻(𝑥_(𝑖1+1))<𝐻(𝑥_(𝑖2+1)). If such an 𝑖₂ does not exist, then set 𝐴^𝐻₂=𝐴⧵𝐴^𝐻₁ and stop.(iv)Continue the above procedure until 𝑥_(|𝐴|) is included in 𝐴^𝐻_𝑟𝐻 for some 𝑟_𝐻.

Assume that the calculation of 𝐻(𝑥) needs a constant time for each 𝑥∈𝐴. Procedure partition(𝐴,𝐻,𝑣) requires 𝑂(|𝐴|log|𝐴|) time to arrange elements of 𝐴 in nondecreasing order of 𝐻(𝑥) and 𝑂(|𝐴|) time to produce the partition. Then the total complexity of procedure partition(𝐴,𝐻,𝑣) is 𝑂(|𝐴|log|𝐴|).

The two lemmas in the following are straightforward and can be found in [11].

Lemma 6. |𝐻(𝑥)−𝐻(𝑥^′)|≤𝑣min{𝐻(𝑥),𝐻(𝑥^′)} for any 𝑥,𝑥^′∈𝐴^𝐻_𝑙,𝑙=1,2,…,𝑟_𝐻.

Lemma 7. 𝑟_𝐻≤log_(1+v)𝐻(𝑥_(|𝐴|))+2≤(2log𝐻(𝑥_(|𝐴|))/𝑣)+2 for 0<𝑣<1 and 𝐻(𝑥_(|𝐴|))≥1.

Based on procedure partition, we will provide an FPTAS, called Algorithm 𝐴_𝛿(𝑘,𝑠) for the restricted problem DET(𝑘,𝑠). The algorithm is formally stated below.

Algorithm  𝐴_𝛿(𝑘,𝑠)(1) (Initialization) Reindex the jobs except the pivotal job by Smith’s rule such that 𝑤₁/𝑝₁≥𝑤₂/𝑝₂≥⋯≥𝑤_𝑛−1/𝑝_𝑛−1. Set 𝑌₁={(−1),(0),(1)} and 𝑗=2.(2) (Generation of 𝑌₂,𝑌₃,…,𝑌_𝑛−1) Generate set 𝑌^′_𝑗 by assigning −1,0 or 1 to the 𝑗th coordinate of vectors from 𝑌_𝑗−1, that is, 𝑌^′_𝑗={(𝑥,𝑥_𝑗)∣𝑥∈𝑌_𝑗−1,𝑥_𝑗∈{−1,0,1}}. Calculate the following for any 𝑥∈𝑌^′_𝑗: 𝐸_𝑗(𝑥)=𝐸_𝑗−1(𝑥)+(1/2)𝑥_𝑗(𝑥_𝑗−1)𝑝_𝑗, 𝑇_𝑗(𝑥)=𝑇_𝑗−1(𝑥)+(1+𝑥_𝑗)(1−𝑥_𝑗)(𝑝_𝑗+𝑤_𝑗(T_𝑗−1(𝑥)−𝑑)), and 𝑆_𝑗(𝑥)=𝑆_𝑗−1(𝑥)+(1/2)𝑥_𝑗(1+𝑥_𝑗)(𝑝_𝑗+𝑤_𝑗(𝐷−𝑑)). If 𝐸_𝑗(𝑥)>𝑠−𝑟 for some 𝑥∈𝑌^′_𝑗, then delete 𝑥 from 𝑌^′_𝑗. If 𝑗>𝑛−1, go to 3. If 𝑗≤𝑛−1, then set 𝑣=𝛿/2𝑛 and perform the following computations: call partition(𝑌^′_𝑗,𝑇_𝑗−𝑑,𝑣) to partition set 𝑌^′_𝑗 into disjoint subsets 𝑌^𝑇₁,𝑌^𝑇₂,…,𝑌^𝑇_𝑟𝑇𝑗. call partition(𝑌^′_𝑗,𝑆_𝑗,𝑣) to partition set 𝑌^′_𝑗 into disjoint subsets 𝑌^𝑆₁,𝑌^𝑆₂,…,𝑌^𝑆_𝑟𝑆𝑗. Divide set 𝑌^′_𝑗 into disjoint subsets 𝑌_𝑎𝑏=𝑌^𝑇_𝑎∩𝑌^𝑆_𝑏, 𝑎=1,2,…,𝑟_𝑇𝑗; 𝑏=1,2,…,𝑟_𝑆𝑗. In each nonempty subset 𝑌_𝑎𝑏, choose a vector 𝑥^(𝑎𝑏) such that 𝐸_𝑗(𝑥^(𝑎𝑏))=min{𝐸_𝑗(𝑥)∶𝑥∈𝑌_𝑎𝑏}. Set 𝑌_𝑗={𝑥^(𝑎𝑏)∶𝑌_𝑎𝑏≠∅, 𝑎=1,2,…,𝑟_𝑇𝑗; 𝑏=1,2,…,𝑟_𝑆𝑗}, and 𝑗=𝑗+1, go to 2.(3) (Solution) Select vector 𝑥⁰∈𝑌_𝑛−1 such that 𝑇_𝑛−1𝑥⁰+𝑆_𝑛−1𝑥⁰=min𝑇_𝑛−1(𝑥)+𝑆_𝑛−1(𝑥)∶𝑥∈𝑌_𝑛−1. (12)

We now show that the vector 𝑥⁰ returned by Algorithm 𝐴_𝛿(𝑘,𝑠) has the objective value at most 1+𝛿 multiples of the objective value of the optimal vector of programming (11). Let 𝜋⁰=𝑥⁰ be the real schedule corresponding to 𝑥⁰, and let 𝜋^∗ be the optimal schedule for DET(𝑘,𝑠). Then we have the following lemma.

Lemma 8. 𝐶_max(𝜋⁰)≤(1+𝛿)𝐶_max(𝜋^∗).

Proof. From Lemma 4, let 𝑥^∗=(𝑥^∗₁,𝑥^∗₂,…,𝑥^∗_𝑛−1) be the optimal vector of programming (11); we know 𝐶_max(𝜋⁰)≤𝑇_𝑛−1(𝑥⁰)+𝑆_𝑛−1(𝑥⁰) and 𝑇_𝑛−1(𝑥^∗)+𝑆_𝑛−1(𝑥^∗)≤𝐶_max(𝜋^∗). It is sufficient to show that 𝑇_𝑛−1(𝑥⁰)+𝑆_𝑛−1(𝑥⁰)≤(1+𝛿)𝑇_𝑛−1(𝑥^∗)+𝑆_𝑛−1(𝑥^∗).
In the following, we will show that there exists a vector 𝑥^(𝑗)∈𝑌_𝑗 which meets the following three conditions by induction for 𝑗=1,2,…,𝑛−1:(1)𝐸_𝑗(𝑥^(𝑗))≤𝐸_𝑗(𝑥^∗)≤𝑠−𝑟,(2)|𝑇_𝑗(𝑥^(𝑗))−𝑇_𝑗(𝑥^∗)|≤𝑣_𝑗(𝑇_𝑗(𝑥^∗)−𝑑)≤𝑣_𝑗𝑇_𝑗(𝑥^∗),(3)|𝑆_𝑗(𝑥^(𝑗))−𝑆_𝑗(𝑥^∗)|≤𝑣_𝑗𝑆_𝑗(𝑥^∗), where 𝑣₀=0 and 𝑣_𝑗=𝑣+(1+𝑣)𝑣_𝑗−1, 𝑗=1,2,…,𝑛−1.
When 𝑗=1, (𝑥^∗₁)∈𝑌₁. By setting 𝑥⁽¹⁾=(𝑥^∗₁), the previous three conditions hold apparently.
Inductively, suppose that 𝑗≤𝑛−1, and there exists a vector 𝑥^(𝑗−1)∈𝑌_𝑗−1 which meets the previous three conditions for index 𝑗−1. Then we have (𝑥^(𝑗−1),𝑥^∗_𝑗)∈𝑌^′_𝑗.
Let 𝑥^(𝑗)=(𝑥^(𝑗−1),𝑥^∗_𝑗) for simplicity, 𝑥^(𝑗)∈𝑌^′_𝑗. Then, 𝐸_𝑗𝑥^(𝑗)=𝐸_𝑗−1𝑥^(𝑗−1)+12𝑥^∗_𝑗𝑥^∗_𝑗−1𝑝_𝑗≤𝐸_𝑗−1𝑥^∗+12𝑥^∗_𝑗𝑥^∗_𝑗−1𝑝_𝑗=𝐸_𝑗𝑥^∗,𝑇_𝑗𝑥^(𝑗)−𝑇_𝑗𝑥^∗=𝑇_𝑗−1𝑥^(𝑗−1)−𝑇_𝑗−1𝑥^∗+1+𝑥^∗_𝑗1−𝑥^∗_𝑗×𝑤_𝑗𝑇_𝑗−1𝑥^(𝑗−1)−𝑇_𝑗−1𝑥^∗=1+1+𝑥^∗_𝑗1−𝑥^∗_𝑗𝑤_𝑗×𝑇_𝑗−1𝑥^(𝑗−1)−𝑇_𝑗−1𝑥^∗≤1+1+𝑥^∗_𝑗1−𝑥^∗_𝑗𝑤_𝑗×𝑣_𝑗−1𝑇_𝑗−1𝑥^∗−𝑑≤𝑣_𝑗−1𝑇_𝑗𝑥^∗−𝑑, (13)(14) where the last inequality follows the fact (1+(1+𝑥^∗_𝑗)(1−𝑥^∗_𝑗)𝑤_𝑗)(𝑇_𝑗−1(𝑥^∗)−𝑑)≤  (1+(1+𝑥^∗_𝑗)(1−𝑥^∗_𝑗)𝑤_𝑗)(𝑇_𝑗−1(𝑥^∗)−𝑑)+(1+𝑥^∗_𝑗)(1−𝑥^∗_𝑗)𝑝_𝑗=𝑇_𝑗(𝑥^∗)−𝑑, and 𝑆_𝑗𝑥^(𝑗)−𝑆_𝑗𝑥^∗=𝑆_𝑗−1𝑥^(𝑗−1)−𝑆_𝑗−1𝑥^∗≤𝑣_𝑗−1𝑆_𝑗−1𝑥^∗≤𝑣_𝑗−1𝑆_𝑗𝑥^∗. (15) Since 𝑥^(𝑗)∈𝑌^′_𝑗, by the algorithm and Lemma 6, there exists 𝑥^(𝑗)∈𝑌_𝑗 such that 𝐸_𝑗𝑥^(𝑗)≤𝐸_𝑗𝑥^(𝑗),𝑇_𝑗𝑥^(𝑗)−𝑇_𝑗𝑥^(𝑗)=𝑇_𝑗𝑥^(𝑗)−𝑑−𝑇_𝑗𝑥^(𝑗)𝑇−𝑑≤𝑣_𝑗𝑥^(𝑗),𝑆−𝑑_𝑗𝑥^(𝑗)−𝑆_𝑗𝑥^(𝑗)≤𝑣𝑆_𝑗𝑥^(𝑗). (16)(17)(18) From (13) and (16), we have 𝐸_𝑗(𝑥^(𝑗))≤𝐸_𝑗(𝑥^∗). From (14) and (17), we have 𝑇_𝑗𝑥^(𝑗)−𝑇_𝑗𝑥^∗≤𝑇_𝑗𝑥^(𝑗)−𝑇_𝑗𝑥^(𝑗)+𝑇_𝑗𝑥^(𝑗)−𝑇_𝑗𝑥^∗≤𝑣𝑇_𝑗𝑥^(𝑗)−𝑑+𝑣_𝑗−1𝑇_𝑗𝑥^∗−𝑑≤𝑣1+𝑣_𝑗−1𝑇_𝑗𝑥^∗−𝑑+𝑣_𝑗−1𝑇_𝑗𝑥^∗−𝑑=𝑣_𝑗𝑇_𝑗𝑥^∗−𝑑, (19) where the last inequality follows from the fact 𝑇_𝑗(𝑥^(𝑗))−𝑑≤|𝑇_𝑗(𝑥^(𝑗))−𝑇_𝑗(𝑥^∗)|+𝑇_𝑗(𝑥^∗)−𝑑≤(1+𝑣_𝑗−1)(𝑇_𝑗(𝑥^∗)−𝑑). Similarly, by (15) and (18), we get |𝑆_𝑗(𝑥^(𝑗))−𝑆_𝑗(𝑥^∗)|≤𝑣_𝑗𝑆_𝑗(𝑥^∗). Note that 𝑣_𝑛−1=(1+𝑣)^𝑛−1−1≤𝑒^{𝑣(𝑛−1)}−1<𝑒^𝛿/2−1≤𝛿 for 0<𝛿<1. So 𝑇_𝑛−1𝑥⁰+𝑆_𝑛−1𝑥⁰=𝑇_𝑛−1𝑥⁰+𝑆_𝑛−1𝑥⁰−𝑇_𝑛−1𝑥^∗+𝑆_𝑛−1𝑥^∗+𝑇_𝑛−1𝑥^∗+𝑆_𝑛−1𝑥^∗≤𝑇_𝑛−1𝑥^(𝑛−1)+𝑆_𝑛−1𝑥^(𝑛−1)−𝑇_𝑛−1𝑥^∗+𝑆_𝑛−1𝑥^∗+𝑇_𝑛−1𝑥^∗+𝑆_𝑛−1𝑥^∗≤𝑣_𝑛−1𝑇_𝑛−1𝑥^∗+𝑆_𝑛−1𝑥^∗+𝑇_𝑛−1𝑥^∗+𝑆_𝑛−1𝑥^∗≤(1+𝛿)𝑇_𝑛−1𝑥^∗+𝑆_𝑛−1𝑥^∗. (20)
This completes the proof.

Now, we consider the time complexity of Algorithm 𝐴_𝛿(𝑘,𝑠). Note that 𝑠≤𝑇_𝑗(𝑥)≤𝑠+∑^𝑛−1_𝑗=1(𝑝_𝑗+𝑤_𝑗(𝐷−𝑑)) and 0≤𝑆_𝑗(𝑥)≤∑^𝑛−1_𝑗=1(𝑝_𝑗+𝑤_𝑗(𝐷−𝑑)) for each 𝑗 and each 𝑥. Actually, we can get 𝑇_𝑗(𝑥)≤𝐷+𝑝_max+𝑤_max(𝐷−𝑑), because once 𝑇_𝑗(𝑥)≥𝐷, we may set 𝑥_𝑗+1=𝑥_𝑗+2=⋯=𝑥_𝑛=0; that is, we do not put 𝐽_𝑗+1,𝐽_𝑗+2,…,𝐽_𝑛 into 𝑇_𝑗+1(𝑥). Hence, by Lemma 7, |𝑌_𝑗|≤(2log(𝐷+𝑝_max+𝑤_max(𝐷−𝑑))+2)(2log(∑^𝑛−1_𝑗=1(𝑝_𝑗+𝑤_𝑗(𝐷−𝑑)))+2)=𝑂(𝐿²/𝛿²). Therefore, the complexity of Algorithm 𝐴_𝛿(𝑘,𝑠) is 𝑂(𝑛𝐿³/𝛿²). Note that there are at most 𝑂(𝑛𝐿/𝛿) restricted problems DET(𝑘,𝑠). Herefore, by Lemmas 4 and 8, we can get a (1+𝜖)-approximation solution in 𝑂(𝑛²𝐿⁴/𝛿³)=𝑂(𝑛²𝐿⁴/𝜖³) time.