Best Possible Approximation Algorithms for Single Machine Scheduling with Increasing Linear Maintenance Durations

We consider a single machine scheduling problem with multiple maintenance activities, where the maintenance duration function is of the linear form f(t) = a+bt with a ≥ 0 and b > 1. We propose an approximation algorithm named FFD-LS2I with a worst-case bound of 2 for problem. We also show that there is no polynomial time approximation algorithm with a worst-case bound less than 2 for the problem with b ≥ 0 unless P = NP, which implies that the FFD-LS2I algorithm is the best possible algorithm for the case b > 1 and that the FFD-LS algorithm, which is proposed in the literature, is the best possible algorithm for the case b ≤ 1 both from the worst-case bound point of view.

In a recent paper, Xu et al. [14] study a single machine scheduling problem with multiple maintenance activities which can be formally described as follows. There are independent jobs 1 , 2 , . . . , to be processed on a single machine. The processing time of job is . All jobs are nonpreemptive and are available at time zero. The machine can process at most one job at a time. Assume that the machine has just finished a dummy maintenance activity at time zero. The length of the time interval between any two consecutive maintenance activities is and prefixed. The amount of time needed to perform one maintenance activity is an increasing linear function ( ) = + of the total processing time of the jobs that are processed after its latest previous maintenance activity, where and are prefixed nonnegative real numbers with ≤ 1. The objective is to schedule all the jobs to the machine such that the makespan, that is, the completion time of the last finished job, is minimized. Extending the well-known three-field | | classification scheme suggested by Graham et al. [15], the problem is denoted by 1, [ , ], ( ) = + , ≤ 1 ‖ max in Xu et al. [14]. For simplicity, in what follows, we denote this problem by ( ≤1) and its counterpart where > 1 by ( >1) . Additionally, the problem is denoted by ( >0) if > 0.
Xu et al. [14] first propose an approximation algorithm named FFD-LS for the problem ( ≤1) and then show that its worst-case bound is 2. The underlying idea of their FFD-LS algorithm is straightforward. Viewing the jobs as items, it first packs these items into some bins with the same capacity of by the classical bin-packing algorithm FFD. Let the "jobs" in each used bin plus a maintenance activity whose duration is computed according to the maintenance function ( ) be viewed as a hybrid job. Assign all the hybrid jobs except the last one (i.e., the one with the largest index) to the machine by the classical LS algorithm. Assign the last hybrid jobs to the machine.
For the sake of convenience and completeness, the binpacking problem, the FFD algorithm, the LS algorithm, and the FFD-LS algorithm are presented as follows.
Algorithm FFD (see, e.g., Coffman et al. [16]). Sort all the items such that ( 1 ) ≥ ( 2 ) ≥ ⋅ ⋅ ⋅ ≥ ( ); for = 1, 2, . . . , , item is packed in the first (lowest-indexed) bin into which it will fit; that is, if there is any partially filled bin with level( ) ≤ − ( ) where level( ) is the sum of the sizes of the items that have been packed into bin , we place in the lowest-indexed bin having this property. Otherwise, we start a new bin with as its first item.
Algorithm LS (see, e.g., Pinedo [17]). Put all the jobs on a list in arbitrary order; then process the jobs consecutively as early as possible.
Algorithm FFD-LS (see Xu et al. [14]) Step 1. Construct a bin-packing instance as follows. There are items 1 , 2 , . . . , ; the size of item is , and the capacity of each bin is . Using the FFD algorithm, assume that we obtain used bins 1 , 2 , . . . , . Let bin be denoted as where is the number of items in and ( ) is the th item assigned to .
Step 3. Let J be viewed as a single job with the processing time of + + level( ) . Assign J 1 , J 2 , . . . , J −1 to the machine by the LS algorithm. Assign J to the machine. Although the FFD-LS algorithm is originally proposed for ( ≤1) , it can also be applied to ( >1) without any modification. However, as can be seen in the next section, there exists an example showing that the worst-case bound of the FFD-LS algorithm can be arbitrarily large for ( >1) . As a result, we then focus our attention on studying its worstcase bound for ( >1) in detail. Specifically, we think of each interval between two consecutive maintenance activities as a batch with a capacity and show that its worst-case bound is 2 for ( >1) if the number of nonempty batches in the FFD-LS schedule is not 2. In order to avoid the arbitrarily large worstcase bound, in Section 3, we modify the FFD-LS algorithm and get a new approximation algorithm named FFD-LS2I algorithm with a worst-case bound of 2 for ( >1) by adding a step to the FFD-LS algorithm. In Section 4, we study the nonapproximability of the problem and show that there is no polynomial time approximation algorithm with a worstcase bound less than 2 for the problem ( >0) , which implies that the FFD-LS2I algorithm is the best possible algorithm for ( >1) and that the FFD-LS is the best possible algorithm for ( ≤1) both from the worst-case bound point of view. Finally, in Section 5, we give an answer to another open problem proposed in Xu et al. [14].

Worst-Case Bound of the FFD-LS
Algorithm for ( >1) Example 1. Consider the scheduling problem ( >1) with the following instance: = 2, = , 1 = , and 2 = 1. It is easy to see that the FFD-LS algorithm assigns job 1 to the first batch and 2 to the second batch and that the corresponding makespan is FFD-LS max = + + 2 + 1 = 2 + + + 1. Note that the optimal schedule assigns job 2 to the first batch and 1 to the second batch and that the optimal makespan is * max = 3 + . Clearly, FFD-LS max / * max → ∞ as → ∞. In other words, the worst-case bound of the FFD-LS algorithm can be arbitrarily large. Now, let Λ = ∑ =1 . Let * be an optimal schedule with * nonempty batches B * 1 , . . . , B * * which are indexed according to the processing order. Recall that we assume that there are totally bins being used by the FFD algorithm in the first step of the FFD-LS algorithm. So, for consistency, we may assume that there are totally nonempty batches in the FFD-LS schedule. For convenience, in what follows, these batches are denoted by B 1 , . . . , B which are also indexed according to the processing order. Let the total processing times of the jobs in batch B * and batch B be denoted by * and , respectively. It is easy to see that the makespan of the optimal schedule is * and that the makespan of the FFD-LS schedule is In what follows, we shall study the worst-case bound of the FFD-LS algorithm for ( >1) in detail, which can help us develop a more sophisticated approximation algorithm. Before the study of the worst-case bound, we first present some lemmas.

Lemma 2.
For the problem ( >1) , the total processing time of the jobs in any two nonempty batches is strictly larger than in * .

Proof (by contradiction). It suffices to show that
If there exist two batches, say B * and B * , such that * + * ≤ , where 1 ≤ < ≤ * , consider the following two cases.
Case 1 (1 ≤ < < * ). Note that * + * ≤ . Now, reschedule all the jobs of B * into B * and delete B * with the corresponding maintenance activity. Let the new schedule be denoted by . It is easy to see that is a feasible schedule with a makespan of Comparing (1) with (3), we have max < * max , which contradicts the optimality of * .
Case 2 (1 ≤ < * and = * ). Similar to Case 1, reschedule all the jobs of B * into B * and delete B * with The Scientific World Journal 3 its corresponding maintenance. Let the new schedule be denoted by . It is easy to see that is a feasible schedule with a makespan of Recall that > 1. Comparing (1) with (4), we have max < * max , which again contradicts the optimality of * . This completes the proof.

Lemma 3.
For problem ( >1) , let be a feasible schedule with two nonempty batches and let be a feasible schedule with three nonempty batches. Let the total processing times of the jobs in the first batch of and in the second batch of be denoted by 1 and 2 , respectively. Let the total processing times of the jobs in the first batch of , in the second batch of , and in the third batch of be denoted by 1 , 2 and 3 , respectively. If 1 + 2 > and + > for 1 ≤ < ≤ 3, then one has max < max , where max and max are the makespans of and , respectively.
Proof. It is easy to see that Combining (5) with (6), we have Recall that 1 + 2 > . So we have Note that 1 ≤ and 2 ≤ . So we have This completes the proof.
Proof. View each interval between two consecutive maintenance activities as a bin with capacity and the jobs as items with a size of . Let be the minimum number of nonempty bins that is needed to pack all the items. It is well known that ≤ 3 /2 (see Simchi-Levi [18]). Note that ≤ * . So we have ≤ 3 * /2. This completes the proof.
Proof. By < Λ, it is easy to see that 2 ≤ * and 2 ≤ since that one batch is clearly not sufficient in any feasible schedule. On the other hand, by Lemma 2, we have * ≤ 3 for otherwise we have Λ > 2 , a contradiction. Note that the total processing time of the jobs in any two batches in the FFD-LS schedule is strictly larger than . We thus have ≤ 3. To sum up, we have 2 ≤ * ≤ 3 and 2 ≤ ≤ 3. This completes the proof. Now, we are ready to evaluate the worst-case bound of the FFD-LS algorithm in detail.

Theorem 6.
For the problem ( >1) , the worst-case bound of the FFD-LS algorithm is not greater than 2 if Λ > 2 .
Case 2 (2 < Λ < 3 ). In this case, it is easy to see that * ≥ 3 because two batches are obviously not sufficient in any optimal solution. Note that the total processing time of the jobs in any two nonempty batches is strictly larger than in the FFD-LS schedule. We thus have ≤ 5 for otherwise the total processing times of the jobs will be strictly larger than 3 , which violates the assumption of this case.
Case 1 ( = 1). It is trivially obvious that in this case we have FFD-LS max = * max , and we are done.
Case 2 ( = 3). Clearly, in this case, we have Λ > . Now, if < Λ ≤ 2 , then, by Theorem 7, we know that the worstcase bound of the FFD-LS algorithm is not greater than 2, and we are done. If 2 < Λ, then by Theorem 6, we know that the worst-case bound of the FFD-LS algorithm is not greater than 2 either, and we are also done. This complete the proof of Case 2.
Case 3 ( ≥ 4). Clearly, in this case, we have Λ > 2 . Again, by Theorem 6, we know that the worst-case bound of the FFD-LS algorithm is not greater than 2, and we are done. This completes the proof.

A Modified Approximation Algorithm and Its Worst-Case Bound for ( >1)
We know from Example 1 and Theorem 8 that the worst-case bound of the FFD-LS algorithm can be arbitrarily large if = 2 and is 2 otherwise. Following the notation in Xu et al. [14], J is the hybrid job which consists of the th nonempty bin obtained by the FFD algorithm and the corresponding maintenance activity. Note that J 1 is scheduled before J 2 in the FFD-LS schedule. So we have 1 = level( 1 ) and Step 4. If = 2 and level( 2 ) < level( 1 ), interchange J 1 with J 2 .
Let us call this modified algorithm FFD-LS2I, which applies algorithm FFD-LS first and then applies Step 4. Clearly, the computational complexity of the FFD-LS2I is ( 2 ). Let the FFD-LS2I schedule be denoted by ⋆ and let the total processing times of the jobs in the th batch ⋆ of ⋆ be denoted by ⋆ . It is easy to see that the number of the nonempty batches in ⋆ is also because the fourth step of the FFD-LS2I algorithm does not change the number of batches.
In order to show that the worst-case bound of the FFD-LS2I algorithm is 2, by the structure of the FFD-LS2I algorithm and Theorem 8, we only need to consider the case = 2. Proof. Clearly, = 2 implies < Λ ≤ 2 . Hence, by Lemma 4, we have 2 ≤ * ≤ 3. Note that the FFD-LS2I schedule has two nonempty batches and that Lemma 3 indicates that the makespan of a feasible schedule with two batches is always less than that of a feasible schedule with three batches. So we have * = 2.
Similar to (2), the makespan of the FFD-LS2I schedule is Combining these two equations, we have Note that * 1 + * 2 = Λ > . We claim that * 2 > /2 for otherwise we have * 1 > /2 and thus we can get a schedule with a smaller makespan by interchanging all the jobs in the first batch of * with those in the second batch of * , which clearly violates the optimality of * . Combining this with ⋆ 2 ≤ , we have which implies that FFD-LS2I max < 2 * max .
Case 2 ( < Λ < 4 /3). Consider the schedule ⬦ which schedules the hybrid job J 2 first and then the hybrid job J 1 . Let the total processing time of the jobs in the first batch of ⬦ and in the second batch of ⬦ be denoted by ⬦ 1 and ⬦ 2 , respectively. Clearly, ⬦ 1 + ⬦ 2 = Λ. Note that Step 4 schedules the hybrid job with the highest level last. So we have ⬦ 2 ≤ ⋆ 2 . Let the makespan of the schedule ⬦ be denoted by ⬦ max . It is easy to see that Recall that ⬦ 2 ≤ ⋆ 2 and > 1. Comparing (29) with (34), we have Now, consider two subcases.

Subcase 2.1.
There is only one job, say job , in the first batch of the schedule ⬦ . Without loss of generality, we assume that the jobs in J 1 are ordered in nondecreasing order of their processing times; that is, (1) Now, consider the position of job in the optimal schedule * . If is in the first batch of * , then we have * 2 ≤ Λ− . Combine this with (37), we have ⬦ 2 ≥ * 2 . If is in the second batch of * , then at least one job, say (1) V with 1 ≤ V ≤ , must be assigned to the first batch of * . To see this is the case, suppose all the jobs (1) 1 , . . . , (1) are assigned to the second batch of * . We thus have * 2 ≥ ∑ =1 (1) + . Combining this with (36), we have * 2 > , which implies that * is infeasible, clearly, a contradiction. Now, suppose (1) V is in the first batch of * , where 1 ≤ V ≤ . Note that (1) Combining (28) with (34), we have By (38), we know that Recall that Λ − ⬦ 2 = ⬦ 1 and that ⬦ 1 ≥ 2 . So we have By a similar reasoning as in the arguments of deducing (31), we have Substituting (41) and (42) into (39), we have which implies that ⬦ max ≤ 2 * max . Combining this with (35), we have FFD-LS2I max ≤ 2 * max . This completes the proof. Now, we are ready to present the worst-case bound of the FFD-LS2I algorithm.
Theorem 10. For the problem ( >1) , the worst-case bound of the FFD-LS2I algorithm is 2 and the bound is tight.
Proof. If ̸ = 2, it is clear that the FFD-LS2I algorithm is reduced to the FFD-LS algorithm, and thus, by Theorem 8, we know that the worst-case bound of the FFD-LS2I algorithm 6 The Scientific World Journal is not greater than 2. If = 2, then, by Theorem 9, we know that the worst-case bound of the FFD-LS2I algorithm is not greater than 2 either. Hence, we have completed the proof that the worst-case bound of the FFD-LS2I algorithm is not greater than 2.
This completes the proof.

Nonapproximability
In this section, we shall show that it is impossible to have a polynomial time approximation algorithm with a worst-case bound of less than 2 for the scheduling problem ( ≥0) unless = NP, which implies that the proposed algorithm FFD-LS2I is the best possible approximation algorithm for ( >1) from the worst-case bound point of view and that the FFD-LS algorithm proposed by Xu et al. [14] is the best possible approximation algorithm for ( ≤1) from the same point of view.
Note that the case = 0 has been considered in Ji et al. [3] (see the following lemma, that is, Lemma 11), so we only need to consider the case > 0, that is, the problem ( >0) . (Ji et al. [3]). There is no polynomial time approximation algorithm with a worst-case bound less than 2 for the scheduling problem ( =0) unless = NP.

Lemma 11
The underlying idea of our approach for problem ( >0) is by contradiction. Specifically, we shall show that if there exists an approximation algorithm with a worst-case bound of 2 − with 0 < < 1 for ( >0) then it can be used to establish a polynomial time algorithm for the well-known NP-complete problem Partition. This clearly leads to a contradiction if ̸ = NP. Hence, such an approximation algorithm for the scheduling problem ( >0) cannot exist unless = NP.
For any fixed positive number < 1 and an instance I of the Partition problem, we construct an instance II of the scheduling problem ( >0) as follows. There are jobs 1 , 2 , . . . , and the processing time of job is = ℎ . Let = and = (2 + )(1 − )/ + 1. It is clear that this construction can be performed in polynomial time. Proof. Given any instance I of the Partition problem, we construct the corresponding instance II of the scheduling problem ( >0) in polynomial time as stated above. Let max and * max be the makespan of the schedule produced by the approximation algorithm and the makespan of an optimal schedule * for the instance II of ( >0) , respectively. We shall show that the instance I of the Partition problem can be answered by merely comparing the values of max and 2( + ) + . To see that this is the case, let us apply algorithm to instance II. We claim that if max ≤ 2( + ) + then there exists a solution to instance I of the Partition problem and, otherwise, there does not exist a solution to instance I. In what follows, we shall show that this claim is correct.
If there exists a solution, namely, set , to the instance I of the Partition problem, let the jobs whose indices belong to the set be scheduled into the first batch and the remaining jobs the second batch; we then obtain a schedule with a makespan of 2 + + , which clearly contradicts (46). Hence, there does not exist a solution to the instance I of the Partition problem.
This completes the proof.
By Theorem 10 and the fact that no NP-complete problem can be solved by a polynomial time algorithm unless = NP, we have the following result.
The Scientific World Journal 7 Theorem 13. There is no polynomial time approximation algorithm with a worst-case bound less than 2 for the scheduling problem ( >0) unless = .
Combining Lemma 11 and Theorem 13, we have the following result.

Theorem 14.
There is no polynomial time approximation algorithm with a worst-case bound less than 2 for the scheduling problem ( ≥0) unless = .
Recall that we have showed in Theorem 10 that the worstcase bound of the FFD-LS2I algorithm is 2 for ( >1) . Combining this with Theorem 14, we have the following result. Recall that Xu et al. [14] have showed that the worst-case bound of the FFD-LS algorithm is 2 for ( ≤1) . Combining this with Theorem 14, we have the following result.

An Answer to Another Open Problem
Viewing each batch as a bin, in Remark 3 of Section 4 of the paper of Xu et al. [14], Xu et al. claim that "it seems that it is not necessary for an optimal schedule of 1, [ , ], ( ) = + , > 2 + / ‖ max to have the minimum number of bins. Whether this is true may be an interesting problem for further study. " The following example gives an answer to this open problem.
Example 17. Consider the following instance for the scheduling problem under consideration: = 20, = 1, = 12, = 8, 1 = 2 = 3 = 4 = 13, and 5 = 6 = 7 = 8 = 5. It is easy to see that the minimum number of bins for this instance is 4; see, for example, that job and job +4 are packed into bin for = 1, . . . , 4. The corresponding makespan is 729. However, if we assign job to the th bin for = 1, . . . , 4 and assign the remaining jobs to the fifth bin, we get an optimal schedule with a makespan of 728. Clearly, this implies that it is not necessary for an optimal schedule of the considered scheduling problem to have the minimum number of bins.

Conclusion
In this paper, we revisited the single machine scheduling problem considered in Xu et al. [14]; we provided an approximation named FFD-LS2I with a worst-case bound of 2 for the case > 1. We showed that the FFD-LS2I algorithm is the best possible algorithm for the case > 1 and that the FFD-LS algorithm is the best possible algorithm for the case ≤ 1 both from the worst-case bound point of view. We also give an answer to another open problem proposed in Xu et al. [14].
Future research may focus on the design of approximation algorithms with a lower time complexity while maintaining the worst-case bound of 2. The other maintenance duration functions such as convex function and concave function are also worth considering.