Approximation Algorithms and an FPTAS for the Single Machine Problem with Biased Tardiness Penalty

This paper addresses a new performance measure for scheduling problems, entitled “biased tardiness penalty.” We study the approximability of minimum biased tardiness on a single machine, provided that all the due dates are equal. Two heuristic algorithms are developed for this problem, and it is shown that one of them has a worst-case ratio bound of 2. Then, we propose a dynamic programming algorithm and use it to design an FPTAS.The FPTAS is generated by cleaning up some states in the dynamic programming algorithm, and it requires O (n3/ε) time.


Introduction
In this paper, we study a single machine scheduling problem of minimizing total biased tardiness about a common due date.Every job  (1 ≤  ≤ ) has a processing time   , a weight tardiness factor   , and a base tardiness factor   .The machine is available at time zero and can process at most one job at a time.The jobs have a common due date .The biased tardiness penalty of job  is defined as where   is the completion time of job . Figure 1 shows the biased tardiness penalty of job  based on its completion time in a sequence.The resulting problem is denoted by 1 |   =  | BTP, where BTP means "biased tardiness penalty."Biased tardiness penalty is a kind of performance measures that, according to our observations, has not been studied in the literature in spite of its wide use in practical situations.One of the most common applications of biased tardiness is in designing delivery contracts.In many of delivery contracts, once an order is delivered later than its due date, a fixed penalty must be paid, and when the delivery becomes tardier, the related penalty will increase as well.
Many of the practical conditions support this assumption; for example, consider a company where just one day delay in receiving raw materials will break down its production line.In this case, the initial damage caused by late delivery is huge while if the delay increases, the additional damage is relatively small.Another application for biased tardiness penalty is in transportation systems where we must pay extra money for solo-transporting a piece of goods if it is not ready to be carried with other orders.
Problem 1 ‖ ∑     is NP-hard in the strong sense if the tardiness weights are not all equal [1,2] and is optimally solvable in pseudo-polynomial time for a fixed number of distinct due dates [3].Cheng et al. [4] have shown that the schedule that minimizes max      gives an ( − 1)approximation for this problem.Kolliopoulos and Steiner [3] design pseudo-polynomial algorithms for the case that there is only a fixed number of different due dates.They also develop an FPTAS if, in addition, the tardiness weights are bounded by a polynomial function of .Karakostas et al. [5] consider the same problem, design a pseudo-polynomial algorithm, and apply a rounding scheme to obtain the desired approximation scheme.
In a special case of problem 1 ‖ ∑    where the due date is common for all jobs, the resulting problem is

SPT Algorithm
In this heuristic algorithm, jobs are sequenced according to a nondecreasing order of processing times, and, hence, it can be implemented in ( log ) time.
Theorem 1.Let  min and  max be, respectively, the smallest and largest weight tardiness factors, and let  min and  max be the smallest and largest base tardiness factors.Then, one has where  SPT is the penalty created by SPT algorithm and  * shows the optimal penalty for problem 1 |   =  | BTP.
Proof.Consider two ordered sets {  } and {  } that include a nondecreasing order of the weight tardiness factors and base tardiness factors, respectively.Suppose that we create  dummy jobs by pairing processing times in SPT ordering and tardiness factors according to their reverse order in sets {  } and {  }.It can be easily verified that the associated total penalty, called LB * , is a lower bound on the total penalty of any sequence for real jobs.Similarly, create another set of  dummy jobs by pairing processing times in SPT ordering but tardiness factors consistent with the order of sets {  } and {  }.It can be easily tested that if we sequence these dummy jobs according to SPT ordering, the related total penalty, called UB SPT , is an upper bound on  SPT for the real jobs.Let   be the number of tardy jobs under SPT ordering.Also, let  []   and  []   denote the th job in sets {  } and {  }, respectively.Also, let  SPT [] denote the completion time of th job in SPT ordering.Thus, we have [1]   ( SPT [] − ) +  [1] From (3) and the fact that the values are nondecreasingly ordered in sets {  } and {  }, we get And if we signify the term ( SPT which completes the proof.The following example illustrates that the worst-case ratio bound obtained by SPT ordering is tight for problem1 |   =  | BTP.
Example 2. Suppose that we have two jobs with parameters given in Table 1 and a common due date  = 100.
SPT ordering generates the sequence (2-1) with total penalty equal to 1020, while the optimal sequence for this example is (1-2) with the total penalty of 204.So,

Algorithm MPR (Minimum Penalty Rate)
In this section, we present another heuristic algorithm for problem 1 |   =  | BTP and show that the worst-case ratio bound of this algorithm is 2. Let  = ( [1] ,  [2] , . . .,  [𝑛] ) denote the sequence generated by MPR algorithm, where  [] represents the th job within this sequence.This algorithm requires at most  iterations and during its th iteration the ( −  + 1)th element of ,  [−+1] , will be determined.Also, if there are some unscheduled jobs at each iteration filling the whole remaining period through due date (remaining tardiness period), we will choose the one making the minimum penalty and save the related sequence, Ĝ, beside the main sequence .Finally, the algorithm sorts tardy jobs in the main and secondary sequences according to WSPT (weighted shortest processing time) ordering and returns the sequence with smaller penalty.Let  [,] denote sum penalties related to the jobs from th position through the last job in sequence .So, the algorithm is as follows.
(  (3) For all jobs  ∈ , calculate   values by (7) and select a job  such that   = min ∈ {  }.If there is a tie, select the job with the smaller processing time; ( It can be easily seen that MPR algorithm runs in ( 2 ) time.The following example illustrates the implementation of MPR algorithm on a simple problem.
Example 3. Suppose a problem with four jobs and a common due date  = 10.Table 2 shows the jobs' parameters.
At first,  After arbitrary scheduling the remaining jobs at the beginning of sequences  and Ĝ, we get  = (1, 3, 4, 2) Proof.The proof is easily done by swapping each pair of the adjacent tardy jobs.Proof.See the appendix.
The following example illustrates that the worst-case ratio bound obtained by MPR is tight for problem 1 |   =  | BTP.
Example 7. Suppose that we have  + 1 jobs with parameters given in Table 3 and a common due date  = .

Dynamic Programming (DP) Algorithm
Without loss of generality, we consider that jobs are indexed according to the WLPT ordering.For problem 1 |   =  | BTP, an optimal schedule belongs to the class of schedules in which the early jobs are processed starting at time zero and are followed by a straddling job, called job , that starts no later than time  and is completed after time ; in turn, the straddling job is followed by the block of tardy jobs.The early jobs can be processed in any order, while, according to Theorem 5, tardy jobs that start at or after the due date must be processed according to WSPT numbering.Let us introduce the following notations.[, ] is a state in the state space, where  denotes the total processing time of early jobs and  is the total penalty of state.
is a set of states for the first  jobs, except for job .

𝑍 *
is the minimum penalty value for problem 1 |   =  | BTP with a fixed straddling job .
sum is the total processing time of all jobs.This DP algorithm schedules early jobs starting from time zero and the tardy jobs so that they become complete exactly at time  sum .According to this, the algorithm can be described as in Algorithm 1.
Let UB * be an upper bound on the optimal penalty, and since  ≤ UB * and  ≤ , we can restrict the number of states ] ()  by  × UB * .The complexity of substep 1.2 of the DP algorithm is proportional to ∑  =1 |] ()  | that leads to ( ⋅  ⋅ UB * ) time.However, this complexity can be reduced to ( ⋅ ) by selecting a state [, ] with the smallest value of  at each iteration  and for every .Similarly, we can get the complexity of substep 1.3 as (), and so, the complexity of step 1 is ( 2 ⋅ ).Step 2 requires () time, and the final complexity of DP algorithm will be calculated as ( 2 ⋅ ).
The following example illustrates the details of DP algorithm.4, and the common due date is given as  = 6 in this example.
Table 5 shows the states generated in each states space regarding the selected straddling jobs as well as subsequences coupled with these states.The optimal value is  * = min{57, 56, 58} = 56 related to sequence (3, 2, 1) which is obtained by inserting straddling job  = 2 into the subsequence (3, , 1).

FPTAS Algorithm
One of the standard approaches to generate an FPTAS is the technique of structuring the execution of an algorithm.Here, the main idea is to take the exact but slow DP algorithm described in Section 4 and to interact with it while it is working.If the algorithm generates a lot of auxiliary states during its execution, then we may remove some of these states and clean up the algorithm's memory.This method was introduced by Ibarra and Kim [17] for solving the knapsack problem, and in the recent years numerous scheduling problems have applied such an approach (see [18][19][20][21][22]).First, let us introduce the following notations.
is the error bound of FPTAS algorithm.
is a set of states generated by FPTAS for the first  jobs, except for job .
The FPTAS algorithm works on the reduced state space ] ()#  instead of ] ()  and can be described as in Algorithm 2.

Worst-Case Analysis of the FPTAS Algorithm.
The worstcase analysis is based on comparing the execution of DP and FPTAS algorithms.First, a lemma is provided that will be used to prove the worst-case ratio bound of FPTAS.Proof.The proof is done by induction on .For  = 0, obviously we have ] ()# 0 = ] () 0 .Suppose that the lemma is valid up to  − 1 and we want to show its validity for iteration .Let [, ] be a state in ] ()  generated by the DP algorithm from a feasible state [  ,   ] at iteration  − 1.Here, two cases can be distinguished.In the first case [, ] = [  +   ,   ] and in the second case [, ] = [  ,   +   +   max{0,  sum − ∑ −1 =1   +   − }] holds.We prove the statement for iteration  in these two cases.
−1 such that   # ≤   and   # ≤   + ( − 1)Δ.Therefore, the FPTAS algorithm generates the state [  # +   ,   # ] that may be eliminated when cleaning up the state subset.Let [, ] be the remaining state in ] ()#  that is in the same interval as [  # +   ,   # ].Thus, we drive that Consequently, the lemma holds for iteration  in this case.
Proof.There exists a straddling job, called  * , in the optimal sequence for problem 1 |   =  | BTP.Since the FPTAS algorithm checks all jobs as straddling, then obviously job  * will be selected in one of its iterations.By definition, the optimal sequence can be related to a state [ This will complete the proof.

Complexity of the FPTAS
According to this, substep 1.2 requires ( 2 /) time.Noting that step 1 iterates  times for every selection of  values, the complexity of this step is ( 3 /).Finally, step 2 requires () time, and the final complexity of the FPTAS algorithm is computed as ( 3 /).

Conclusion
In this paper, we presented a new performance measure for scheduling problems, called biased tardiness penalty.According to this performance measure, two kinds of penalties are assigned to each tardy job: one fixed penalty and the other that linearly increases by the increase in tardiness value.Two approximation algorithms were designed with the polynomial running times.The first approximation algorithm, SPT, gives a worst-case ratio bound linking to size of instances, while the second approximation algorithm, MPR, has a constant worst-case ratio bound of 2. Next, we developed a dynamic programming algorithm and converted it to an FPTAS using the method of structuring the execution of an algorithm.The resulting FPTAS runs in ( 3 /) time.

Appendix Proof of Theorem 6
We consider two main cases for the sequence of tardy jobs and prove the worst-case ratio bound in both cases.Recall that   and  * denote the penalties from MPR and optimal sequences, respectively.Let   indicate the sum processing times of jobs in a sequence  and let    indicate completion time of job  in a sequence .Also,   () shows the penalty of sequence  if it ends at time .
Case 1.The first tardy job in MPR sequence before the sorting phase (step 8) is also tardy in optimal sequence.
Algorithm MPR schedules jobs from the end of sequence to the beginning, while some of the selected tardy jobs are also tardy in the optimal sequence and some others are not.According to this, we can show the sequence of tardy jobs before the sorting phase (step 8) as in Figure 3.In this figure, sets   contain the jobs that only are tardy in the heuristic sequence and sets   contain the jobs that are tardy in both heuristic and optimal sequences.Without loss of generality, suppose that each set    contains a single job because sets   can be empty.Let sequence   begin with a job in    from tardy jobs in optimal sequence.Put other tardy jobs in optimal sequence into set   +1 .Here, two subcases are identified.

Subcase 1.1 (𝐵 󸀠
+1 is empty).In this case, sets   1 to    contain all tardy jobs in the optimal sequence.Figure 4 shows the sequence of tardy jobs after execution of the sorting phase (step 8).From Theorem 5, the jobs included in sets  have the same order in both sequences G and the optimal sequence.So, we have where the second term shows the decrease in penalty values of  1 to   in sequence  compared with the related penalties in optimal sequence.The second term indicates penalty related to sets  1 to   in the heuristic sequence.
Figure 5 shows the sequence of tardy jobs before and after sorting in step 8. Assume that    contains tardy jobs in optimal sequence that are not tardy in sequence   .   cannot be empty because in that condition jobs in   1 to   −1 must fill the whole tardiness period from  to  sum , and considering ∑ −1 =1     ≥  sum − , there is no need that the heuristic algorithm selects tardy jobs in    .Without loss of generality, the first job in    can be substituted by two dummy jobs, a tardy job having the same tardiness factors as the first job in    and processing time       −  and an early job having tardiness factors equal to zero and processing time ∑ ∈     −(      −).This substitution gets    to exactly fill the tardiness period while it has no effect on the heuristic penalty and will not increase the optimal penalty.

Example 8 .
Consider an instance of problem 1 |   =  | BTP with 3 jobs.The parameters of the jobs are given in Table # is the minimum penalty generated by FPTAS for problem 1 |   =  | BTP with a fixed straddling job . # is the minimum penalty generated by FPTAS for problem 1 |   =  | BTP.Consider the penalty of algorithm MPR, called   , as an upper bound for the problem.To reduce the number of states in each iteration, we split the feasible interval [0,   ] related to the second coordinate of state [, ] into  + 1 equal subintervals   = [( − 1)Δ, Δ) 1 ≤  ≤  + 1 of length Δ.For each of the resulting subintervals   , we keep at most one state with the smallest value .Given an arbitrary  > 0, define
. .,     ) on a common time interval, where the relation   / min(  ,   −) ≤   / min(  ,   − ) holds for all jobs  in  and jobs  in   .Then,   ≤    .Proof.Consider two sequences  and   with tardiness penalties shown in Figure 2. Suppose that   () and    () denote the slope of the functions related to sequences  and   , respectively; then, according to the theorem's assumption, we have   () ≤    () for all  ∈ [, ].It is obvious that for all  ∈ [, ] (especially for point ) the function related to sequence  falls under the function related to sequence   and, hence, ∑  =1    ≤ ∑   =1     .A similar conclusion can be made for the case where    <      holds.Theorem 5.In any optimal sequence for problem 1 |   =  | BTP, the tardy jobs with start time greater than or equal to  must be sequenced in WSPT ordering.This means that ∀,  ∈  * :  ≤   −   <   −   ⇒

Table 5 :
Procedure of DP algorithm in Example 8.