algorithms for maximizing the number of tardy jobs or ...werner/preprints/p09-38.pdf · algorithms...
TRANSCRIPT
Algorithms for Maximizing the Number of TardyJobs or Total Tardiness on a Single Machine
Evgeny R. Gafarov a, Alexander A. Lazarev b
Institute of Control Sciences of the Russian Academy of Sciences,Profsoyuznaya st. 65, 117997 Moscow, Russia,
email: [email protected], [email protected]
Frank Werner
Fakultat fur Mathematik, Otto-von-Guericke-Universitat Magdeburg,PSF 4120, 39016 Magdeburg, Germany,
email: [email protected]
November 20, 2009
Abstract
In this paper, we consider two scheduling problems on a singlemachine, where a specific objective function has to be maximized incontrast to usual minimization problems. We propose exact algo-rithms for the single machine problem of maximizing total tardiness1||max
∑Tj and for the problem of maximizing the number of tardy
jobs 1||max∑
Uj. In both cases, it is assumed that the processing ofthe first job starts at time zero and there is no idle time between thejobs. We show that problem 1||max
∑Uj is polynomially solvable. For
several special cases of problem 1||max∑
Tj , we present exact poly-nomial algorithms. Moreover, we give an exact pseudo-polynomialalgorithm for the general case of the latter problem and an alternativeexact algorithm.
Keywords: Scheduling, single machine problems, maximization problems,total tardiness, number of tardy jobs
MSC: 90 B 35
1
Introduction
Typically, in scheduling theory problems are considered where a specific ob-jective function has to be minimized. For instance, the minimization ofmakespan is a very popular optimization criterion. When a sum functionis considered, often total completion time, total tardiness or the number oftardy jobs have to be minimized.
In this paper, we consider a single machine problem with two ‘opposite’criteria, namely we consider the maximization of total tardiness and themaximization of the number of tardy jobs. On one side, investigations ofsuch problems with the ‘opposite’ optimization criterion itself are an impor-tant theoretical task. For instance, they can be used for proposing algorithmsand deriving properties of an optimal schedule of this opposite problem whichmight be taken to compute upper bounds for the original problems. Algo-rithms for such problems with opposite optimization criterion can be used tocompute parts of optimal schedules for the original problems, or to cut badsub-problems in the branching tree of branch-and-bound algorithms. For ex-ample, the algorithm for problem 1||max
∑Uj can be used to compute the
maximal number of tardy jobs, and later we can use this number to reducethe search for an optimal solution of problem 1||max
∑Tj (see Section 2 of
this paper). In addition, it is interesting from a theoretical point whetherpolynomially solvable cases for the minimization problem are also easy forthe maximization case, or vice versa. Moreover, there are often relationshipsbetween the minimization and maximization variants, e.g. between prob-lem 1||max
∑Uj and the problem of minimizing the number of early jobs
1||min∑
Ej when idle times are not allowed.On the other side, such problems separately have practical interpretations
and applications. For instance, a company may additionally earn money forthe case of latest completion times of the individual orders. Another situationarises when the company is considered as a customer, and one wants to knowthe worst variant of a schedule, which is computed in a ‘black box’ (e.g. aplant). Finally, we mention the problem of a ‘saboteur’. That is, a saboteurwants to construct the worst schedule in a competitive (‘enemy’) plant.
It is well-known that problem 1|rj |Lmax is NP -hard in the strong sensewhile it has been shown in [1] that the ‘opposite’ maximization problem1|rj |max fmin can be polynomially solved for any non-decreasing functionsfj(t) for all j ∈ N in O(n2) time.
The problems under consideration can be formulated as follows. We aregiven a set N = {1, 2, . . . , n} of n independent jobs that must be processedon a single machine. Preemptions of a job are not allowed. The machine
2
can handle only one job at a time. All the jobs are assumed to be availablefor processing at time 0. For each job j, j ∈ N , a processing time pj > 0and a due date dj are given. A schedule π = (j1, j2, . . . , jn) is uniquelydetermined by a permutation of the jobs of set N . We assume that idletimes are not allowed. Let Cjk
(π) =∑k
l=1 pjlbe the completion time of job
jk in schedule π. If Cj(π) > dj, then job j is tardy and we have Uj = 1,otherwise Uj = 0. If Cj(π) ≤ dj , then job j is on-time. The objective is tofind an optimal schedule π∗ that maximizes the number of tardy jobs, i.e.,F (π) =
∑nj=1 Uj(π). We will denote this problem by 1||max
∑Uj. It is
well-known that problem 1||min∑
Uj is polynomially solvable in O(n log n)time by Moore’s algorithm [2].
If Cj(π) < dj , then job j is early (in fact, it is completed before the duedate) and we set Ej = 1, otherwise Ej = 0. We will denote by 1||min
∑Ej
the problem of minimizing the number of early jobs, where idle times betweenthe processing of the jobs are not allowed. There is a relationship betweenproblems 1||max
∑Uj and 1||min
∑Ej . Let dj , pj ∈ Z for all j ∈ N
and δ be a real number with 0 < δ < 1. If we set d′j = dj + δ, thenproblems 1|dj |max
∑Uj and 1|d′j |min
∑Ej are identical. If one job is tardy
for problem 1|dj |max∑
Uj in schedule π, then Cj(π) > dj and Cj(π) >dj + δ = d′j , i.e. job j is not early.
Moreover, let Tj(π) = max{0, Cj(π) − dj} be the tardiness of job j inschedule π. We will denote the problem of maximizing total tardiness with-out idle times between the processing of jobs by 1||max
∑Tj. In this paper,
notation {π} denotes the set of jobs contained in sequence π. Notation i ∈ πmeans i ∈ {π}. Notation j → i means, that the processing of job j pre-cedes the processing of job i, and notation (j → i)π means that this holdsin schedule π.
The rest of the paper is organized as follows. In Section 1, we present apolynomial algorithm for problem 1||max
∑Uj. In Section 2, we consider the
problem of maximizing total tardiness on a single machine. In particular, wepresent polynomial algorithms for several special cases of this problem. First,we adapt in Section 2.1 the elimination rules by Emmons to the maximizationproblem. In Section 2.2, we present an overview on polynomially solvableand NP-hard cases for minimizing total tardiness and we give an overviewon the results we present in Section 2 for the maximization case. In Section2.3, we propose several properties of optimal solutions. In Sections 2.4 -2.7, we develop algorithms for polynomially solvable cases of the problem ofmaximizing total tardiness. For the general case, an exact pseudo-polynomialalgorithm is given in Section 2.8, and an alternative exact algorithm is givenin Section 2.9.
3
1 A polynomial algorithm for problem 1||max∑
Uj
without idle times
In this section, we first discuss a relationship between problem 1|rj |Cmax
and the problem of maximizing the number of tardy jobs. Then we presentan algorithm for constructing a schedule with all jobs tardy provided thatsuch a schedule does exist. Finally, we present in Section 1.3 properties ofan optimal schedule and present Algorithm A3 for solving this problem.
1.1 A relationship with problem 1|rj|Cmax.
Let us set rj = dj − pj + δ for all j ∈ N . We consider problem 1|rj |Cmax.There exists an exact Algorithm A1 for this problem with time complexityO(n log n). However, we note that in an optimal schedule, there are idletimes in general. To determine an optimal schedule, the following algorithmcomputes the starting time Sj of each job j ∈ N .
Algorithm A1:
1. Renumber the jobs according to non-decreasing release dates, i.e., r1 ≤r2 ≤ . . . ≤ rn;2. t := 0;3. For j = 1, . . . , n do:
Sj := max(rj , t);t := Sj + pj;
4. Cmax = Sn + pn.
If Cmax >∑n
j=1 pj, then there is at least one tardy job in each schedulewithout idle times.
1.2 An algorithm for constructing a schedule with all jobstardy
Next, we present an algorithm that constructs a schedule having only tardyjobs if it exists. The algorithm is as follows.
Algorithm A2:
1. t := 0, N ′ := N ;2. For i = 1, . . . , n do:
4
2.1. Select a job j ∈ N ′ such that t + pj > dj (i.e., this job can be tardy).If there are several such jobs, select the job with maximal processingtime;
2.2. If there is no such job, then a schedule, where all jobs are tardy, doesnot exist. Stop.
2.3. t := t + pj, N ′ := N ′ \ {j};
Lemma 1 Assume that there exists a schedule, where all jobs are tardy.Then Algorithm A2 constructs such a schedule.
Proof. We prove the lemma indirectly. Assume that Algorithm A2 hasconstructed a subsequence π = (j1, j2, . . . , jk), k < n, as the first part ofthe schedule, where all jobs are tardy. Moreover, let there exist a scheduleπ0 = (πa, j1, πb, j2, . . .), πa = (ja
1 , ja2 , . . .), where all n jobs are tardy. Then,
in schedule π1 = (j1, πa, πb, j2, . . .), all jobs are also tardy since pj1 > dj1 .Similarly, in schedule π2 = (j1, j2, πa, πb, . . .), all jobs are also tardy, andso on. However, in schedule πk = (j1, j2, . . . , jk, ja
1 , . . .) job ja1 is not tardy.
This yields a contradiction. �
1.3 Properties of an optimal schedule for problem1||max
∑Uj
In this section, we present some properties of an optimal schedule and analgorithm for solving this problem.
Lemma 2 There exists an optimal schedule of the form π = (S,F ), whereall jobs j ∈ F are tardy and all jobs j ∈ S are not tardy.
Proof. Assume that there exists an optimal schedule π =(j1, j2, j3, . . . , jk−1, jk, . . . , jn), where job jk−1 is tardy and job jk is nottardy. Then π′ = (j1, j2, j3, . . . , jk, jk−1, . . . , jn) is also an optimal sched-ule. Performing such adjacent pairwise interchanges of two jobs repeatedly,we get the schedule π = (S,F ). �
Lemma 3 There exists an optimal schedule π = (S,F ), which has no jobsj ∈ F and i ∈ S with pj > pi and dj ≥ di.
Proof. Assume that there exists an optimal schedule π =(j1, j2, j3, . . . , jk, jk+1, . . . , jl−1, jl, . . . , jn), where pjl
> pjk, djl
≥ djk,
Cjl(π) > djl
and Cjk(π) ≤ djk
. Then schedule π′ =
5
(j1, j2, j3, . . . , jl, jk+1 . . . , , jl−1, jk, . . . , jn) is also optimal since Ck(π′) =Cjl
(π) > djl≥ djk
and for all ji = jk+1, . . . , jl−1, inequality Cji(π′) > Cji(π)
holds since pjl> pjk
. �Now we set rj = dj − pj + δ for all jobs j ∈ N .
Lemma 4 There exists an optimal schedule π = (S,F ), where all tardyjobs jk+1, jk+2, . . . , jn are processed according to non-decreasing release dates,i.e., rji ≤ rji+1, i = k + 1, . . . , n − 1.
Proof. Assume that there exists an optimal schedule π = (π1, i, j, π2),where jobs i and j are tardy, but rj < ri. It is well-known that, ifjob i is tardy, then Ci(π) − pi ≥ ri > rj . Let us consider scheduleπ′ = (π1, j, i, π2). We have Cj(π′) − pj = Ci(π) − pi ≥ ri > rj andCi(π′) = Ci(π) + pj > di + pj > di. Thus, π′ is an optimal schedule, whereboth jobs i and j are also tardy. �
Algorithm A3.
Step 1. S := ∅;F := N ;
Step 2. We construct a schedule of the form π =(js
1, js2 , . . . , j
sk, j
fk+1, j
fk+2, . . . , j
fn). All jobs from set S = {js
1 , js2 , . . . , j
sk}
are processed at the beginning of the schedule. All jobs from setF = {jf
k+1, jfk+2, . . . , j
fn} are processed according to non-decreasing
release dates: rjfk+1
≤ rjfk+2
≤ . . . ≤ rjfn;
Step 3. We find the last on-time job jfl ∈ F . If there is no such job, then
GOTO Step 6;
Step 4. We select the job j∗ ∈ {jfl , jf
l+1, . . . , jfn} with the largest processing
time: pj∗ ≥ pi for all i ∈ {jfl , jf
l+1, . . . , jfn};
Step 5. S := S ∪ {j∗}, F := F \ {j∗}, GOTO Step 2;
Step 6. An optimal schedule π = (js1, j
s2 , . . . , j
sk, j
fk+1, j
fk+2, . . . , j
fn) has been
obtained. STOP.
Lemma 5 Let in schedule π = (j1, . . . , jl, jl+1, . . . , jn), rj1 ≤ rj2 ≤ . . . ≤rjn , job jl be the last on-time job. Then there exists an optimal schedule,where job j∗ ∈ {jl, jl+1, . . . , jn}, pj∗ ≥ pi, for all i ∈ {jl, jl+1, . . . , jn} ison-time.
6
Proof. Let there be an optimal schedule π = (π1, i, π2, j∗, π3, π4) , where job
j∗ is tardy. It is obvious that in any schedule, not all jobs jl, jl+1, . . . , jn aretardy (see Lemma 4). Then there is an on-time job i ∈ {jl, jl+1, . . . , jn}, i �=j∗. According to Lemma 4, we assume that all jobs from set {j∗, π3, π4}are processed according to non-decreasing release dates. If rj∗ ≥ ri, thenrj∗ + pj∗ ≥ ri + pi, i.e., dj∗ ≥ di, and schedule π′ = (π1, j
∗, π2, i, π3, π4) isalso optimal. In schedule π′, job j∗ is not tardy and job i is tardy.
Now, let rj∗ < ri. Assume that we have for all j ∈ {π4}, rj ≥ ri and forall j ∈ {π3}, rj < ri. Let us consider schedule π′′ = (π1, j
∗, π2, π3, i, π4). Forall j ∈ {π2}, we have Cj(π′′) ≥ Cj(π) since pj∗ ≥ pi. In schedule π′′, all jobsfrom {π3}
⋃{i}⋃{π4} are tardy since in schedule π′′′ = (π1, π2, j∗, π3, i, π4),
only job j∗ can be on-time according to the conditions of the lemma. There-fore, schedule π′′ is optimal. �
Lemma 6 Algorithm A3 constructs an optimal schedule for problem1||max
∑Uj
Proof. We prove the lemma by induction. The algorithm is correct forn = 1.
Assume now that the algorithm is correct for n − 1 jobs. We consideran instance with n jobs. Assume that Algorithm A3 has constructed theschedule π = (S,F ), but there is an optimal schedule π′ = (S′, F ′) with|F ′| ≥ |F |. If we use the algorithm for the n−1 jobs 1, 2, . . . , j−1, j+1, . . . , nwith j = j∗, then we have an optimal schedule (S \ {j∗}, F ). Schedule(S′ \ {j∗}, F ′) is appropriate for the corresponding instance with n− 1 jobs.Thus, we get |F ′| ≤ |F | and |F ′| = |F |. �
Such an algorithm for problem 1||min∑
Ej has been presented for thefirst time in [3] (unfortunately, no proof was given there).
2 Algorithms for problem 1||max∑
Tj without idletimes
In this section, we wish to construct an optimal schedule π∗ which maximizesthe total tardiness value F (π) =
∑nj=1 max{0, Cj(π) − dj}, where Cj(π) is
the completion time of job j in schedule π. Again, idle times between theprocessing of jobs are not allowed and the first job starts at time 0.
Problem 1 | | min∑
Tj is NP-hard in the ordinary sense [4, 5]. A pseudo-polynomial dynamic programming algorithm of time complexity O(n4
∑pj)
7
has been proposed by Lawler [6]. The state-of-the-art algorithms by Szwarcet al. [7] can solve special instances [8] of this problem for n ≤ 500 jobs.
In the next subsection, we present some rules for eliminating specificsolutions from the search for an optimal solution when maximizing totaltardiness.
2.1 Elimination rules by Emmons
In this subsection, we adapt the elimination rules given by Emmons for theminimization problem to the maximization problem under consideration.We define Bj as the set of predecessors of job j in all optimal schedules,and Aj denotes the set of successors of job j in all optimal schedules, i.e.,Bj = {i ∈ N : i → j in all optimal schedules} and Aj = {i ∈ N : j → i inall optimal schedules}. Moreover, we define cj =
∑nk=1 pk − ∑
i∈Ajpi and
sj =∑
i∈Bjpi. Then, we have sj + pj ≤ Cj ≤ cj for all optimal schedules.
Lemma 7 If pj ≥ pi and dj ≥ di, or pj ≥ pi, dj < di and dj ≥ cj , orpj ≥ pi, dj < di and di ≤ si + pj, then there exists an optimal schedule π,for which we have (j → i)π.
Proof. We consider the following three cases.
a) Let pj ≥ pi and dj ≥ di. Assume that there is an optimal sched-ule π = (π1, i, π2, j, π3). For schedule π′ = (π1, j, π2, i, π3), we haveF (π′) − F (π) ≥ (Tj(π′) − Tj(π)) + (Ti(π′) − Ti(π)). If Cj(π′) > dj , thenF (π′) − F (π) ≥ −(pi +
∑k∈π2
pk}) + (pi +∑
k∈π2pk}) ≥ 0. Otherwise, if
Cj(π′) ≤ dj, then F (π′) − F (π) ≥ −max{0, Cj(π) − dj} + max{0, Cj(π) −di} ≥ 0.
b) Let pj ≥ pi, dj < di and dj ≥ cj . Assume that there is an opti-mal schedule π = (π1, i, π2, j, π3). For schedule π′ = (π1, j, i, π2, π3), wehave F (π′)−F (π) ≥ (Tj(π′)−Tj(π))+(Ti(π′)−Ti(π)) = (0−0)+(0−0) ≥ 0.
c) Let pj ≥ pi, dj < di and di ≤ si + pj. Assume that there is an op-timal schedule π = (π1, i, π2, j, π3). For schedule π′ = (π1, j, π2, i, π3),we have F (π′) − F (π) ≥ (Tj(π′) − Tj(π)) + (Ti(π′) − Ti(π)) ≥(−pi −
∑k∈π2
pk) + (∑
k∈π2pk + pi) = 0.
In all cases schedule π′ is also optimal. �
8
Lemma 8 If pj ≥ pi and di > ci − pi and dj ≤ sj + pj , then there exists anoptimal schedule π, for which we have (i → j)π.
Proof. Assume that there exists an optimal schedule π = (π1, j, π2, i, π3).For schedule π′ = (π1, i, j, π2, π3), we have F (π′)−F (π) ≥ (Tj(π′)−Tj(π))+(Ti(π′) − Ti(π)) = (pi) − (max{ci − di, 0}) > 0. �
The following Table 1 compares the elimination rules for the minimizationand maximization problems.
Table 1: Elimination rulespj ≥ pi 1||min
∑Tj pj ≥ pi 1||max
∑Tj
(i → j) di ≤ dj or (j → i) di ≤ dj
di ≤ sj + pj or (di > dj and dj > cj)or (di > dj and di < si + pi)or (di > dj and di < si + pj)
(j → i) di + pi ≥ cj and (i → j) di > ci − pi and(di > dj or dj ≤ sj + pj
di > sj + pj)
2.2 Special cases
Some polynomially solvable special cases for the problem of minimizing to-tal tardiness are summarized e.g. by Lazarev and Werner [9]. In this sub-section, we give an overview on the results obtained in this paper for themaximization problem, and we compare the results with those available forthe minimization of total tardiness in Table 2.
2.3 Properties of an optimal schedule for problem1||max
∑Tj
In this subsection, we present some properties of an optimal schedule for theproblem under consideration.
Lemma 9 There exists an optimal schedule π = (S,F ) = (SPT,LPT ),where all jobs j ∈ F are tardy and all jobs i ∈ S are on-time. All jobs fromthe set S are processed in SPT (shortest processing time) order and all jobsfrom the set F are processed in LPT (longest processing time) order.
9
Table 2: Polynomially solvable and NP-hard special cases
Special case 1||min∑
Tj 1||max∑
Tj
P/NP Algorithm P/NP Algorithmdj = d P SPT P LPT
see Lemma 7pj = p P EDD P πopt = (1, 2, . . . , n),
d1 ≥ d2 ≥ . . . ≥ dn
Lemma 7d1 ≤ d2 ≤ . . . ≤ dn P SPT P LPTp1 ≤ p2 ≤ . . . ≤ pn Lemma 7
dmax − dmin ≤ 1, pj ∈ Z P O(n2) [9, 10] P O(n2)Lemma 19
d1 ≤ d2 ≤ . . . ≤ dn P O(n2) [9, 10] open -di − di−1 > pi, i = 2, . . . , n
Canonical LG [5] NP [5] O(npmin) [9, 10] P O(n5)d1 ≤ d2 ≤ . . . ≤ dn Lemma 21p1 ≥ p2 ≥ . . . ≥ pn
dn − d1 ≤ pn
. . .
Canonical DL [4] NP [4] O(n∑
pj) [9, 10] P O(n5)Lemma 22
d1 + p1 ≤ d2 + p2 ≤ . . . ≤ dn + pn P O(n3) P O(n2)p1 < p2 < . . . < pn Lemma 23
Proof.
1) Assume that there exists an optimal schedule π = (π1, j, π2, i, π3), wherejob j is tardy and job i is on-time. For schedule π′ = (π1, i, j, π2, π3), we have:F (π′)−F (π) ≥ (Tj(π′)−Tj(π))+(Ti(π′)−Ti(π)) = (pi)+(0) > 0. Therefore,we have a contradiction, since the schedule π′ is better, and π is not optimal.
2) We consider an optimal schedule π = (S,F ), where all jobs j ∈ Fare tardy and all jobs i ∈ S are on-time. Now we prove that all jobsj ∈ F are processed according to an LPT order. Assume that there existsan optimal schedule π = (π1, j1, j2, π2), where j1 and j2 are tardy andpj1 < pj2 . For schedule π′ = (π1, j2, j1, π2), we have F (π′) − F (π) =(Tj1(π
′) − Tj1(π)) + (Tj2(π′) − Tj2(π)) ≥ (pj2) − (min{pj1 , Tj2(π)}) > 0.
Therefore, we have a contradiction and π = (π1, j1, j2, π2) is not optimal.
10
3) We consider an optimal schedule π = (S,F ), where all jobs j ∈ F aretardy and all jobs i ∈ S are on-time. Now, we prove that all jobs i ∈ Scan be processed in an SPT order in an optimal schedule. For all jobsi ∈ S, we have di ≥ ∑
k∈S pk, otherwise, if di <∑
k∈S pk, then scheduleπ′ = (S \ {i}, i, F ) is better (i.e., it has a larger value of total tardiness),and we have a contradiction. Therefore, jobs i ∈ S can be processed in anyorder. �
Define Umax as the maximal number of tardy jobs for the instance of theproblem. Then n − Umax is the minimal number of on-time jobs. We cancompute the value Umax by means of Algorithm A3 in O(n log n) time.
Let N1 be the set of n − Umax − 1 jobs with minimal processing times,and N2 be the set of n − Umax jobs with minimal processing times. DefineNi as the set N1
⋃{i}, if i /∈ N1, otherwise Ni = N2.
Lemma 10 If di <∑
k∈Nipk, then there is no optimal schedule, where job
i is on-time.
Proof. We prove the lemma indirectly. Assume that there exists an optimalschedule π = (S,F ), where jobs j ∈ F are tardy and jobs i ∈ S are on-time. Let there be a job i ∈ S with di <
∑k∈Ni
pk. Then di <∑
k∈Nipk ≤∑
k∈S pk, and schedule π′ = (S \{i}, i, F ) is better, i.e., F (π′) > F (π). �
Lemma 11 If job j is tardy in an optimal schedule, then all jobs i ∈ N, pi <pj , di ≤ dj and all jobs i ∈ N, pi = pj, di < dj are tardy in this schedule.
Proof. We can prove this lemma in a similar way as Lemma 7, i.e., if jobi ∈ N, pi < pj, di ≤ dj is on-time, then we can interchange jobs j and i.�
Lemma 12 If for job j, we have⎛⎝ n∑
i=1
pi −∑
k∈{i∈N, pi<pj, di≤dj}⋃{i∈N, pi=pj , di<dj}
pk
⎞⎠ ≤ dj,
then there is no optimal schedule, where job j is tardy.
Proof. From Lemma 9 we know that all tardy jobs are processed in an LPTorder. Then, by Lemma 11, Lemma 12 holds. �
Lemma 13 Let j be the first tardy job in an optimal schedule π = (S, j, F ).Then for each on-time job i ∈ S, we have di ≥ max{Cj(π) − pj , dj}.
11
Proof. If for a job i ∈ S we have di < Cj(π) − pj, then job i is tardy inschedule π′ = (S \ {i}, i, j, F ), and we have F (π′) > F (π). If di < dj , thenfor schedule π′ = (S \ {i}, j, i, F ), we have F (π′) > F (π). �
Lemma 14 Let j be a tardy job in an optimal schedule π = (π1, π2, j, π3),where all jobs from π2 are tardy and |{π2}| = k > 0. Then Tj(π) ≥ k · pj.
Proof. If Tj(π) < k · pj, then for schedule π = (j, π1, π2, π3), we haveF (π′) > F (π). �
Renumber the jobs according to the rule: d1 ≤ d2 ≤ . . . ≤ dn, if di =di+1, then pi ≤ pi+1. Let j be the job with maximal processing time j :=argmax{di : pi = maxk∈N pk}.
Lemma 15 There is an optimal schedule, where the first tardy jobs is fromthe set {1, 2, . . . , j}. If dj < dj+1, then in all optimal schedules the first tardyjobs is from the set {1, 2, . . . , j}.
Proof. We prove this lemma indirectly. Let there be an optimal scheduleπ = (π1, i, π2), where i > j and job i is the first tardy job. Then job j ison-time in this optimal schedule, since all tardy jobs are processed in an LPTorder in an optimal schedule. Now assume π = (j, π1, i, π2). For scheduleπ′ = (π1, i, j, π2), we have F (π′) = F (π) if dj = di, and F (π′) > F (π) ifdj < di. �
Denote Mj = {i ∈ N, pi > pj} and Oj = {i ∈ N, i > j}.
Lemma 16 If a job j is the first tardy job in an optimal schedule π, thenfor each job i ∈ Mj we have
∑k∈Mj
pk ≤ di.
The proof is obvious since all tardy jobs are processed in an LPT orderin an optimal schedule, i.e. all jobs i ∈ Mj are not tardy.
Lemma 17 If a job j is the first tardy job in an optimal schedule π, then∑k∈Oj
pk + pj > dj .
We can use Lemmas 10 – 17 to compute an optimal schedule faster.
12
2.4 An exact algorithm for the special case dmax − dmin ≤ 1
Define z = dmax. The following Algorithm T1 constructs an optimalsolution for the special case under consideration.
Algorithm T1.
Step 1. S := N, F := ∅, Pf := 0;
Step 2. If there is a job j ∈ S with∑n
i=1 pi −Pf − pj ≥ z + 1, then GOTOStep 3, otherwise GOTO Step 5;
Step 3. We select a job j∗(S) ∈ S with minimal processing time pj. Ifthere are several such jobs, then among these jobs, we select one withminimal due date dj :
j∗(S) = arg minj∈S
{dj : pj = mini∈S
pi}
Step 4. S := S \ {j∗(S)}, F := F⋃{j∗(S)}, Pf := Pf + pj∗(S), GOTO
Step 2;
Step 5. Now we can choose only two tardy jobs. For each pair of twojobs j1, j2 ∈ S, we consider two schedules π′ = (π1, j1, j2, π2) andπ′′ = (π1, j2, j1, π2), where {π1} = S \ {j1, j2}, {π2} = F, and all jobsin F are processed in an LPT order. Then we select the best scheduleamong 2 |S|·(|S|−1)
2 schedules considered.
Lemma 18 If∑n
i=1 pi − pj∗(N) ≥ z + 1, then there is an optimal schedule,where job j∗(N) is the last tardy job.
Proof. Let j∗ = j∗(N). Moreover, assume that there exists an optimalschedule π = (π1, j
∗, π2, α, i). If pj∗ = pi, dj∗ ≤ di, then schedule π′ =(π1, i, π2, α, j∗) is also optimal.
If pj∗ < pi, then job j∗ is not tardy in schedule π. We consider scheduleπ′ = (π1, i, π2, α, j∗). We have:
a) If Ci(π′) ≤ di, then Ti(π′)−Ti(π) = −∑nk=1 pk +di, Tj∗(π′)−Tj∗(π) =∑n
k=1 pk−dj∗ , Tα(π′)−Tα(π) ≥ 1 since pi ≥ pj∗ +1 (pj ∈ Z for all j ∈N).
Then F (π′)−F (π) ≥ (Tj∗(π′)−Tj∗(π)) + (Ti(π′)−Ti(π)) + (Tα(π′)−Tα(π)) ≥ 0 since dmax − dmin ≤ 1.
13
b) If Ci(π′) > di, then Ti(π′) − Ti(π) = −∑k∈π2
⋃{α,j∗} pk, Tj∗(π′) −Tj∗(π) ≥ ∑
k∈π2⋃{α,j∗} pk − 1 since dmax − dmin ≤ 1.
Moreover, Tα(π′)−Tα(π) ≥ 1 since pi ≥ pj∗ +1 (pj ∈ Z for all j ∈ N).Then F (π′) − F (π) ≥ 0.
�
Lemma 19 Algorithm T1 constructs an optimal schedule in O(n2) time.
Proof. The optimality of Steps 3-4 results from Lemma 18. The timecomplexity of Step 5 is O(n2). �
2.5 An exact algorithm for the special case ‘Canonical LG’[5]
We consider the following special case (see [5]):⎧⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎩
p1 > p2 > . . . > p2n+1,d1 < d2 < . . . < d2n+1,d2n+1 − d1 < p2n+1,p2n+1 = M = n3b,p2n = p2n+1 + b,p2i = p2i+2 + b, i = n − 1, . . . , 1,p2i−1 = p2i + δi, i = n, . . . , 1,d2n+1 =
∑ni=1 p2i + p2n+1 + 1
2δ,d2n = d2n+1 − δ,d2i = d2i+2 − (n − i)b + δ, i = n − 1, . . . , 1,d2i−1 = d2i − (n − i)δi − εδi, i = n, . . . , 1,
(LG)
where δ1, δ2, . . . , δn ∈ Z, δ =∑n
i=1 δi, b = n2δ, 0 < ε < mini δimaxi δi
.We define
N = {1, 2, . . . , 2n, 2n+1} = {V1, V2, V3, V4, . . . , V2i−1, V2i, . . . , V2n−1, V2n, V2n+1}.
Lemma 20 [5] For case LG, there are either n or n + 1 tardy jobs in eachschedule.
Lemma 21 For case LG, we can construct an optimal schedule with O(n5)operations.
14
Proof.Without loss of generality, we consider only the case when n ≥ 2. The
proof is as follows. First, we can show that in all optimal schedules, jobV2n+1 is processed in the last position (see Step 0). Next, one can show thatin the last positions of all optimal schedules, there are processed (n
2 − 1)tardy jobs with minimal processing times (Steps 1 and 2). Then we canprove that the first n− (n
2 + 2) tardy jobs in all optimal schedules are thejobs with maximal processing times (and minimal due dates)(see Step 3).For this reason, we know at least n − 3 tardy jobs in an optimal schedule.Therefore, we must choose at most 4 further tardy jobs since for this specialcase, there are either n or n + 1 tardy jobs in all schedules. Then we arguethat O(n4) schedules have to be considered and O(n5) time is required (seeStep 4).
0. First, we show that there is an optimal schedule, where job V2n+1 isprocessed in the last position of the schedule. We prove this indirectly.Assume that there is an optimal schedule π, where another job is pro-cessed in the last position.
0.1. Assume that there is an optimal schedule of the form π =(SPT,LPT ) = (π1, V2n+1, π2, V2j). Consider schedule π =(π1, V2j , π2, V2n+1). We have p2j − p2n+1 = p2j − p2n + b = (n− j + 1)band
d2n+1 − d2j = δ + d2n − d2j = δ + (n − (n − 1))b + (n − (n − 2))b +. . . + (n − j)b − (n − j)δ = b + 2b + . . . + (n − j)b − (n − j − 1)δ =(n−j)(n−j+1)
2 b − (n − j − 1)δ.
Then F (π′) − F (π) ≥ (n − 1)(p2j − p2n+1) − (d2n+1 − d2j) = (n −1)(n − j + 1)b − (n−j)(n−j+1)
2 b + (n − j − 1)δ. We have n − 1 − n−j2 =
2n−2−n+j2 = n−2+j
2 ≥ 12 for n > 1 and j ≥ 1. Thus, F (π′) − F (π) > 0.
We have a contradiction and schedule π is not optimal.
0.2. Assume that there is an optimal schedule of the form π =(SPT,LPT ) = (π1, V2n+1, π2, V2j−1). Consider schedule π =(π1, V2j−1, π2, V2n+1). We have p2j−1 − p2n+1 = p2j − p2n + b + δj >(n − j + 1)b and
d2n+1 − d2j−1 = δ + d2n − d2j + (n− j)δj + εδj = (n−j)(n−j+1)2 b− (n−
j − 1)δ + (n − j)δj + εδj .
We have F (π′)−F (π) > 0 for n > 1 and j ≥ 1. We have a contradictionand schedule π is not optimal.
15
1. Next, we show that in the last positions of all optimal schedules,there are processed the jobs with minimal processing times. Weprove this indirectly. Let we have an optimal schedule, where thisrule does not hold. We go from the end of the schedule to the be-ginning. In the schedule, let position k be the first position ‘fromthe end’, where job V2i (or V2i−1) must be processed, but this po-sition is occupied by job V2j (or V2j−1). Assume that n > 1 andj < i, i.e., there is a schedule π = (π1, V2i, π2, V2j , π3, V2n+1), π3 =(V2(i+1)−1), V2(i+1), . . . , V2n−1, V2n), where job V2i is on-time. It isknown that in an optimal schedule, all jobs are processed accordingto an LPT order (see Lemma 9).
First, we consider the case when k is an even number. Then i =n− k−2
2 = n− k2 + 1. In schedule π, there are at least n− k tardy jobs
before job V2j . Therefore, we have j > n−k2 .
We have to consider the following cases for the two V -jobs.
1.1. Case of jobs V2i and V2j. Assume that we have π =(π1, V2i, π2, V2j , π3, V2n+1), π3 = (V2(i+1)−1), V2(i+1), . . . , V2n−1, V2n),where job V2i is on-time. Let us consider schedule π′ =(π1, V2j , π2, V2i, π3, V2n+1).
We have p2j − p2i = (i − j)b, d2i − d2j = (n − (i − 1))b + (n − (i −2))b + . . . + (n − j)b − (i − j)δ = (n − i)(i − j)b +
∑i−ji=1 b − (i− j)δ =
(n−i)(i−j)b+ (i−j)(i−j+1)2 b−(i−j)δ = (n−i+ i−j+1
2 )(i−j)b−(i−j)δ.We compute the value k for which we get F (π′) > F (π). We must have:(n−k)(i−j)b ≥ (n−i+ i−j+1
2 )(i−j)b ⇒ 2n−2k ≥ 2n−2i+i−j+1 ⇒2k ≤ i + j − 1 < n − k
2 + 1 + n−k2 − 1 ⇒ 2k < 3
2n − k ⇒ k < n2 .
1.2. Case of jobs V2i and V2j−1. Assume that we have π =(π1, V2i, π2, V2j−1, π3, V2n+1), where job V2i is on-time. Let us considerschedule π′ = (π1, V2j−1, π2, V2i, π3, V2n+1).
We have p2j−1−p2i = (i−j)b+δj , d2i−d2j−1 = (n−(i−1))b+(n−(i−2))b+. . .+(n−j)b−(i−j)δ+(n−j)δj +εδj = (n−i)(i−j)b+
∑i−ji=1 b−
(i− j)δ + (n − j)δj + εδj = (n − i)(i − j)b + (i−j)(i−j+1)2 b − (i− j)δ =
(n − i + i−j+12 )(i − j)b − (i − j)δ + (n − j)δj + εδj . Analogously, we
compute the value k for which we have F (π′) > F (π). We must have:(n − k)(i − j)b > (n − i + i−j+1
2 )(i − j)b. Thus, we have k < n2 .
1.3. We try to put only job V2i (not V2i−1) at this position, since V2i staysat this position, if V2i is tardy, i.e., if job V2i is tardy in schedule π,
16
then this job occupies position k ‘from the end’.
2. Now, let us consider the case when k is an odd number. Then i =n− k−3
2 . We try to put job V2i−1 (or V2i) at this position. We have toconsider the following cases for the two V -jobs.
2.1. Case of jobs V2i−1 and V2j . We have π = (π1, V2i−1, π2, V2j , π3, V2n+1)with π3 = (V2i, V2(i+1)−1), V2(i+1), . . . , V2n−1, V2n), where job V2i−1 ison-time. Let us consider schedule π′ = (π1, V2j , π2, V2i−1, π3, V2n+1).
We have p2j − p2i−1 = (i − j)b − δi, d2i−1 − d2j = (n − i + i−j+12 )(i −
j)b−(i−j)δ−(n− i)δi −εδi. We compute the value k for which we getF (π′) > F (π). We must have: (n−k)(i−j)b > (n−i+ i−j+1
2 )(i−j)b ⇒2n−2k > 2n−2j + i− j +1 ⇒ 2k < i+ j−1 < n− k
2 + 32 + n−k
2 −1 ⇒3k < 3
2n + 12 ⇒ k < n
2 + 16 .
2.2. Case of jobs V2i−1 and V2j−1. We have π =(π1, V2i−1, π2, V2j−1, π3, V2n+1), where job V2i−1 is on-time. Letus consider schedule π′ = (π1, V2j−1, π2, V2i−1, π3, V2n+1).
We have p2j−1 − p2i−1 = (i − j)b − δi + δj , d2i−1 − d2j−1 = (n − i +i−j+1
2 )(i− j)b− (i− j)δ − (n− i)δi − εδi +(n− j)δj + εδj . We considerthis case in an analogous way. We get k < n
2 + 16 .
2.3. The cases (V2i and V2j) and (V2i and V2j−1) can betreated in an analogous way. For example, we havethe schedule π = (π1, V2i, π2, V2j , π3, V2n+1) with π3 =(V2i−1, V2(i+1)−1), V2(i+1), . . . , V2n−1, V2n), and we consider theschedule π′ = (π1, V2j , π2, V2i−1, π3, V2n+1).
3 We show that the first tardy jobs in all optimal schedules are the jobswith maximal processing times (and minimal due dates). We provethis indirectly in an analogous way. Now we go from the middle of theschedule and consider the last n positions in the schedule. Let posi-tion k in the schedule be the first position ‘from the middle’ (but thenumbering is ‘from the end’), where job V2j (or V2j−1) must be pro-cessed, but there stands job V2i (or V2i−1). Assume n > 1 and j < i,i.e., there is a schedule π = (π1, V2j , π2.1, π2.2, V2i, π3, V2n+1), π2.2 =(V1, V2, . . . , V2(j−1)−1, V2(j−1)), where job V2j is on-time. It is knownthat in an optimal schedule, all jobs are processed according to anLPT order (see Lemma 9). Assume that n − k is an odd num-ber (the case when n − k is even can be analogously considered).Moreover, assume that j = n−k−1
2 + 1 = n−k2 + 1
2 . We want to
17
compute the value k for which we get F (π′) > F (π), where π =(π1, V2i, π2.1, π2.2, V2j , π3, V2n+1).
3.1. Case of jobs V2i and V2j . We have the sched-ule π = (π1, V2j , π2.1, π2.2, V2i, π3, V2n+1) with π2.2 =(V1, V2, . . . , V2(j−1)−1, V2(j−1)), where job V2j is on-time. Let usconsider the schedule π′ = (π1, V2i, π2.1, π2.2, V2j , π3, V2n+1). It isobvious that i ≤ n − k−2
2 , while all jobs in π are processed in anLPT order. We want to get (n − k + 1)(p2j − p2i) < (d2i − d2j).Then (n − k + 1) < 2n−i−j+1
2 ⇒ 2k − 1 > i + j ⇒ 2k − 1 >n−k
2 + 12 + n − k
2 + 1 ⇒ 3k > 32n + 5
2 ⇒ k > n2 + 5
6 .
3.2. Case of jobs V2i−1 and V2j . We have the schedule π =(π1, V2j , π2.1, π2.2, V2i−1, π3, V2n+1), where job V2j is on-time. Let usconsider the schedule π′ = (π1, V2i−1, π2.1, π2.2, V2j , π3, V2n+1). It isobvious that i ≤ n− k−3
2 , while all jobs in π are processed in an LPT
order. We want to get 2k− 1 > n−k2 + 1
2 +n− k2 + 3
2 ⇒ 3k > 32n+3 ⇒
k > n2 + 1.
3.3. Case of jobs V2i and V2j−1. We have the schedule π =(π1, V2j−1, π2.1, π2.2, V2i, π3, V2n+1), where job V2j−1 is on-time. Letus consider the schedule π′ = (π1, V2i, π2.1, π2.2, V2j−1, π3, V2n+1). Weassume j = n−k
2 + 12 . We have i ≤ n− k−2
2 , since all jobs in π are pro-cessed in an LPT order. We want to get 2k−1 > n−k
2 + 12 +n− k
2 +1 ⇒3k > 3
2n + 52 ⇒ k > n
2 + 56 .
3.4. Case of jobs V2i−1 and V2j−1. We have the schedule π =(π1, V2j−1, π2.1, π2.2, V2i−1, π3, V2n+1), where job V2j−1 is on-time. Letus consider the schedule π′ = (π1, V2i−1, π2.1, π2.2, V2j−1, π3, V2n+1).We assume j = n−k
2 + 12 . We have i ≤ n− k−3
2 , since all jobs in π are pro-cessed in an LPT order. We want to get 2k−1 > n−k
2 + 12 +n− k
2 + 32 ⇒
3k > 32n + 3 ⇒ k > n
2 + 1.
4. Now, we know that in all optimal schedules, n−(n2 +2) tardy jobs are
the jobs with maximal processing times and there are (n2 − 1) tardy
jobs with minimal processing times. For this reason, we know at leastn − 3 tardy jobs. Therefore, we must choose at most 4 further tardyjobs, since for this special case, there are either n or n + 1 tardy jobsin all schedules. Thus, we have to consider at most O(n4) schedules.The time complexity of this part is O(n5).
�
18
2.6 An exact algorithm for the special case ‘Canonical DL’[4]
For this special case we have 3n + 1 jobs:
N = {V1, V2, . . . , V2i−1, V2i, . . . , V2n−1, V2n,W1,W2, . . . ,Wn+1},
where b1 ≥ b2 ≥ . . . ≥ b2n, bi ∈ Z, i = 1, 2, . . . , 2n, δ = 12
∑ni=1(b2i−1 − b2i),
and b = (4n + 1)δ.Moreover,
a1 = b1 + (9n2 + 3n)δ + 5n(b1 − b2n),
a2 = b2 + (9n2 + 3n)δ + 5n(b1 − b2n),
. . . ,
a2i−1 = b2i−1 + (9n2 + 3n − i + 1)δ + 5n(b1 − b2n),
a2i = b2i + (9n2 + 3n − i + 1)δ + 5n(b1 − b2n),
. . . ,
a2n−1 = b2n−1 + (9n2 + 2n + 1)δ + 5n(b1 − b2n),
a2n = b2n + (9n2 + 2n + 1)δ + 5n(b1 − b2n).
pVi = ai, 1 ≤ i ≤ 2n;pWi = b, 1 ≤ i ≤ n + 1;
dVi ={
(j − 1)b + δ + (a2 + a4 + . . . + a2j) if i = 2j − 1dV2j−1 + 2(n − j + 1)(a2j−1 − a2j) if i = 2j
dWi ={
ib + (a2 + a4 + . . . + a2i) 1 ≤ i ≤ ndWn + δ + b i = n + 1
Lemma 22 For the special case ‘Canonical DL’, we can construct an opti-mal schedule in O(n5) time.
Proof.Without loss of generality, we consider only the case when n ≥ 3.The proof can be sketched as follows. We consider properties of ‘stable’
schedules (see Step 1). A schedule π = (S,F ) is stable, if for each on-time job j ∈ S in schedule π, we have dj ≥ ∑
i∈S pi, where S denotesthe set of on-time jobs. It is obvious that all optimal schedules are stable.First, we investigate the maximal number k of on-time jobs from set V =
19
{V1, V2, . . . , V2i−1, V2i, . . . , V2n−1, V2n} in a stable schedule. Then we considerthe following property of an optimal schedule: Let i be the last tardy jobfrom set V in an optimal schedule π∗ = (π1, i, π2). Assume that in scheduleπ∗, there are k on-time jobs. Then, before job i, there are 2n − k − 1tardy jobs from set V in an optimal schedule. Thus, i ≥ 2n − k sinceall tardy jobs are processed according to an LPT order. We must haveF (π∗) > F (π = (i, π1, π2)) since π∗ is optimal. Summarizing, for each stable(and optimal) schedule, we must have k = �2
3 n or 23 n.
Additionally, we prove that all jobs Wj, j = 1, . . . , n + 1, are processedat the end of the schedule (see Step 2).
Thus, we must select k on-time jobs from the set V and process themat the beginning of the schedule. We investigate the minimal number i of ajob Vi, which can be on-time in a stable schedule (di ≥
∑l∈S pl, |S| = k).
At the end, we consider each situation (k = �23 n or 2
3 n, i is even or odd)separately and get similar results, namely that we have to consider O(n4)schedules to find an optimal one (see Step 3).
0. It is obvious that in each schedule, at least n jobs from set{V1, V2, . . . , V2i−1, V2i, . . . , V2n−1, V2n} are tardy since (pVn+1 + pVn+2 + . . . +pV2n) + pVi > dmax = dW2n+1 for all i = 1, 2, . . . , n. In the proof, we consideronly schedules of the form π = (SPT,LPT ). Otherwise, we can re-order thejobs accordingly without loss of optimality.
1. Now we consider the properties of ‘stable’ schedules. A schedule π =(S,F ) is stable, if for each on-time job j ∈ S in schedule π, we have dj ≥∑
i∈S pi, where S denotes the set of on-time jobs. It is obvious that alloptimal schedules are stable.
Now we investigate the maximal number of on-time jobs from set V ={V1, V2, . . . , V2i−1, V2i, . . . , V2n−1, V2n}. The largest set S (with a maxi-mal number of elements) consists of jobs Vj , Vj+1, . . . , V2n. Then PS =∑2n
i=j pVi > (2n − j + 1)a2n.
a) Let j be even, dmin(i ∈ S) = dj = a2 + a4 + . . . + aj + b (j−2)2 + δ + 2(n−
j2 + 1)(aj − aj−1) < ( j
2 + 1)a2n. Then for a stable schedule, we must havePS ≤ dj . Then we get j
2 +1 > 2n−j+1 ⇒ j+2 > 4n−2j+2 ⇒ j > 4n3 . Let
k = |S|, i.e., k is the maximal number of on-time jobs in a stable (optimal,too) schedule. Then k ≤ 2n − j + 1 < 2n − (4n
3 ) + 1 ⇒ 3k < 6n − 4n + 3 ⇒k < 2
3 n + 1.
b) Let j be odd, dmin(i ∈ S) = dj = a2 +a4 + . . .+aj−1+aj+1+b (j−1)2 +δ <
20
( j+12 + 1)a2n. Then for a stable schedule, we must have PS ≤ dj . Then we
get j+12 +1 > 2n− j +1,⇒ j +3 > 4n−2j +2 ⇒ j > 4n−1
3 . Let k = |S|, i.e.,k is the maximal number of on-time jobs in a stable (optimal, too) schedule.Then k ≤ 2n−j+1 < 2n−(4n−1
3 )+1 ⇒ 3k < 6n−4n+1+3 ⇒ k < 23 n+ 4
3 .
Thus, we have k < 23 n + 1, i.e., k ≤ �2
3 n .2. Now, we show that in all optimal schedules, all jobs Wj , j = 1, . . . , n + 1are processed at the end of the schedule. We prove this indirectly. As-sume that there is an optimal schedule of the form π = (SPT,LPT ) =(Wj , π1, Vi, π2), where job Wj is on-time and Vi is the last tardy job fromset V . Then, before job Vi, there are at least 2n − �2
3 n − 1 tardy jobsfrom set V and i ≥ 2n − �2
3 n since all tardy jobs are processed ac-cording to an LPT order. Let us consider schedule π′ = (Vi, π1,Wj , π2).We have F (π′) − F (π) ≥ (2n − �2
3 n − 1)(pVi − pWj) − (dWj − dVi) anddWj − dVi ≤ dWn+1 − dVi .
a) Let i be even. Then dVi = (a2 + a4 + . . . + ai) + 2(n− i2 + 1)(ai−1 − ai) +
δ+( i2 −1)b, dWn+1 −dVi < (n+1)b+(ai+2 + . . .+a2n) < (n+1)b+ 2n−i
2 ai ≤(n + 1)b + 2n−2n+� 2
3n�
2 ai = (n + 1)b + 12�2
3 n ai.We have F (π′)−F (π) > (2n−�2
3 n −1)(ai−b)−((n+1)b+(12� 2n
3 )ai) >(2n − �2n
3 − 1 − 12�2n
3 )ai − (3n)b > 0 for n ≥ 3.
b) For an odd number i, the proof is analogous. We have dWn+1 −dVi < (n+
1)b+(ai+1 + . . .+a2n) < (n+1)b+ 2n−(i−1)2 ai ≤ (n+1)b+ 2n−2n+� 2
3n�+1
2 ai =(n + 1)b + (1
2�23 n + 1
2)ai, and thus F (π′) − F (π) > 0 for n ≥ 3.
Now we know that in all optimal schedules, all jobs Wj, j = 1, . . . , n + 1are processed at the end of the schedule.
3. For an optimal schedule, we also must have the following property: Leti be the last tardy job from set {V1, V2, . . . , V2j−1, V2j , . . . , V2n−1, V2n} in anoptimal schedule π∗ = (π1, i, π2). Assume that in schedule π∗, there are kon-time jobs. Then, before job i, there are 2n − k − 1 tardy jobs. Thus,i ≥ 2n− k since all tardy jobs are processed according to an LPT order. Wemust have F (π∗) > F (π = (i, π1, π2)) since π∗ is optimal, i.e., we must haveCi(π∗)−di ≥ (2n−k−1)pi ⇒ (a1+a3+. . .+a2n−1)+(a2+a4+. . .+a2n)−di ≥(2n − k − 1)ai.
a) Let i be even. Then di = (a2 + a4 + . . . + ai) + 2(n− i2 + 1)(ai−1 − ai) +
δ+( i2 −1)b, Ci(π∗)−di < (a1 +a3 + . . .+a2n−1)+(ai+2 +ai+4 + . . .+a2n) <
21
(2n − i2 + 1)ai. We must have (2n − i
2 + 1)ai > (2n − k − 1)ai ⇒ i2 − 1 <
k +1 ⇒ i < 2k +4. Thus, 2n−k ≤ i < 2k +4 ⇒ 2n−4 < 3k ⇒ k > 23 n− 4
3 .
b) Let i be odd. Then di = (a2+a4+. . .+ai+1)+δ+( i+12 −1)b, Ci(π∗)−di <
(a1 + a3 + . . . + a2n−1) + (ai+3 + ai+5 + . . . + a2n) < (2n − i+12 + 1)ai. We
must have (2n− i+12 +1)ai > (2n−k−1)ai ⇒ i+1
2 −1 < k +1 ⇒ i < 2k +3.Thus, 2n − k ≤ i < 2k + 3 ⇒ 2n − 3 < 3k ⇒ k > 2
3 n − 1.
4. For each stable schedule, we have 23 n − 1 < k < 2
3 n + 1 and therefore,k = �2
3 n or 23 n. Thus, we must select k on-time jobs and process them at
the beginning of the schedule. Now, we investigate the minimal number i ofa job Vi, which can be on-time in a stable schedule (di ≥
∑k∈S pk).
a) Let k = �23 n . In a stable schedule, we must have di > �2
3 n a2n.
If i is even, then di = (a2 + a4 + . . . + ai) + i−22 b + δ + 2(n − i
2 +1)(ai−1 − ai) < ( i
2 + 1)a2n. We must have ( i2 + 1)a2n > �2
3 n a2n. We geti > 2�2
3 n − 2 ≥ �43 n − 2, i.e., i ≥ �4
3 n − 1. Thus, we must select �23 n jobs
from the 2n−�43 n +1 shortest jobs. There are at most n combinations (and
at least 1 combination). Therefore, we can investigate these combinations(and the corresponding schedule) in O(n2) time.
If i is odd, then di = (a2 +a4 + . . .+ai+1)+ i−12 b+ δ < ( i+1
2 +1)a2n. Wemust have ( i+1
2 + 1)a2n > �23 n a2n. We have i > 2�2
3 n − 3 ≥ �43 n − 3, i.e.,
i ≥ �43 n − 2. So we must select �2
3 n jobs from the 2n − �43 n + 2 shortest
jobs. There are at most n2 combinations (and at least 1 combination). Thus,we can investigate these combinations (and the corresponding schedules) inO(n3) time.
b) Let k = 23 n. In a stable schedule, we must have di > 2
3 na2n.
If i is even, then di = (a2+a4+. . .+ai)+ i−22 b+δ+(n− i
2 +1)(ai−1−ai) <( i2 + 1)a2n. We must have ( i
2 + 1)a2n > 23 na2n. i > 22
3 n − 2 ≥ 43 n −
3, i ≥ 43 n−2. So we must select 2
3 n jobs from the 2n−43 n+2 shortest
jobs. There are at most n2 combinations (and at least 1 combination). Thus,we can investigate these combinations (and the resulting schedules) in O(n3)time.
If i is odd, then di = (a2 + a4 + . . . + ai+1) + i−12 b + δ < ( i+1
2 + 1)a2n.We must have ( i+1
2 + 1)a2n > 23 na2n. Then i > 22
3 n− 3 ≥ 43 n− 4, i.e.,
i ≥ 43 n − 3. So we must select 2
3 n jobs from the 2n − 43 n + 3 shortest
22
jobs. There are at most n4 combinations (and at least 1 combination). Thus,we can investigate these combinations (and the resulting schedules) in O(n5)time.
�
Thus, we can present the following Algorithm T3. All jobs W1, . . . ,Wn+1
are processed at the end of the schedule in any order. Then we investigate allschedules, which have k = �2
3 n or k = 23 n on-time jobs. We select these
jobs according to Step 4 of the proof. Finally, we select the best scheduleamong the considered schedules.
2.7 An exact algorithm for the special cased1 + p1 ≤ d2 + p2 ≤ . . . ≤ dn + pn, p1 < p2 < . . . < pn
Without loss of generality, let di <∑n
j=1 pj for all i ∈ N . This special casecan be solved by the following algorithm.
Algorithm T4
0. P :=∑n
j=1 pj, N := N, S := ∅, π = (), Π := ∅;
1. WHILE for each job j ∈ N , there is a job i ∈ N \ {j} such thatdi < P − pj DO
1.1. We select one job j∗ ∈ N with minimal processing time;
1.2. π = (j∗, π), P := P − pj∗, N := N \ {j∗};1.3. FOR each job i with di ≥ P DO N := N \ {i}, S := S
⋃{i}.2. WHILE there is a job j ∈ N such that another job i ∈ N \ {j} exists
for which di < P − pj DO
2.1. We investigate all schedules π′ = (π1, l, π), where π1 = (N \{l})⋃
S, di ≥ P − pl for all i ∈ N \ {l}. We include the bestschedule π′ into the set Π;
2.2. We select one job j∗ ∈ N with minimal processing time;
2.3. We investigate all schedules π′′ = (π1, l, j∗, π), where π1 = (N \
{l, j∗})⋃S, di ≥ P − pl − pj∗ for all i ∈ N \ {l, j∗}. We include
the best schedule π′′ into the set Π;
2.4. We keep only the best schedule in set Π;
2.5. π = (j∗, π), P := P − pj∗, N := N \ {j∗};
23
2.6. FOR each job i with di ≥ P DO N := N \ {i}, S := S⋃{i}.
3. Now, we can select additionally at most one tardy job. We selectjob j ∈ N with the minimal due date dj and construct the scheduleπ = (π1, j, π), π1 = (N \ {j})⋃
S. Then we compare schedule π withthe schedule from set Π and select the better one.
Lemma 23 Algorithm T4 constructs an optimal schedule for this specialcase in O(n2) time.
Proof. It is known that, if pi < pj and di ≤ dj , then there is an optimalschedule π, where (j → i)π (see Emmons’ rules). If there is a scheduleπ = (π1, i, π2, α, j, π3), where pi < pj, di > dj , job i is on-time, jobs α, j aretardy, then for schedule π′ = (π1, j, π2, α, i, π3) we have F (π′) − F (π) ≥ 0since Tα(π′)− Tα(π) = pj − pi, (Tj(π)−Tj(π′))− (Ti(π′)− Ti(π)) ≤ di − dj ,and di + pi ≤ dj + pj ⇒ di − dj ≤ pj − pi. This fact proves the optimalityof steps 1, 2.3. and 2.6. of the algorithm. It is obvious that the timecomplexity of Algorithm T4 is equal to O(n2). �
2.8 An exact algorithm for problem 1||max∑
Tj.
This algorithm is based on Lemma 9, i.e., there is an optimal schedule π =(S,F ) = (SPT,LPT ), where all jobs j ∈ F are tardy and all jobs i ∈ S areon-time.
Algorithm T0
1. We enumerate the jobs as follows: p1 ≥ p2 ≥ . . . ≥ pn. If pi = pi+1,then di ≥ di+1;
2. π1(t) := (1), F1(t) := max{0, p1 + t − d1} for all t ∈ Z with t ∈[0,
∑nj=2 pj];
3. FOR l := 2 TO n DO
FOR t := 0 TO∑n
j=l+1 pj (t ∈ Z) DO
π1 := (l, πl−1(t + pl)), π2 := (πl−1(t), l);F (π1) := max{0, pl + t − dl} + Fl−1(t + pl);
F (π2) := Fl−1(t) + max{0,l∑
j=1pj + t − dl};
Fl(t) := max{F (π1), F (π2)};πl(t) := arg max{F (π1), F (π2)}.
24
4. We have obtained an optimal schedule πn(0) with the optimal functionvalue Fn(0).
Theorem 1 Algorithm T0 constructs an optimal schedule in O(n∑
pj)time.
Proof. We prove the theorem indirectly. Assume that there is an optimalschedule of the form π∗ = (SPT,LPT ), where F (π∗) > F (πn(0)) = Fn(0).
Let π′ := π∗. For each l = 1, 2, . . . , n, we successively consider the partπl ∈ π′, {πl} = {1, . . . , l} of the schedule. Let π′ = (πα, πl, πβ). If πl �=πl(t =
∑i∈πα
pi) (for the notation, see the last row in Step 3 of AlgorithmT0, then π′ := (πα, πl(
∑i∈πα
pi), πβ). It is obvious that F ((πα, πl, πβ)) ≤F ((πα, πl(
∑i∈πα
pi), πβ)), and so on. At the end, we have F (π∗) ≤ F (π′) ≤Fn(0). Thus, schedule πn(0) is also optimal.
Obviously, the time complexity of Algorithm T0 is equal to O(n∑
pj).�
For a practical realization of the algorithm, we can use the idea from[11]. As computational experiments for the partition problem show, fora substantial part of instances, the time complexity time is polynomiallybounded which might also be expected for the problem under consideration.
2.9 An alternative exact algorithm for problem 1||max∑
Tj.
Renumber the jobs according to the rule: d1 ≤ d2 ≤ . . . ≤ dn, if di = di+1,then pi ≤ pi+1 (EDD order). Let j∗ be the job with maximal processingtime j∗ := argmax{di : pi = maxk∈N pk}. Denote by jf the first tardy jobin an optimal schedule π = (S,F ) and let P (A) =
∑i∈A pi.
According to Lemmas 10 and 13 we know that for all on-time jobs i ∈ S,we have di ≥ max{djf ,
∑k∈S pk}, where
∑k∈S pk = Sjf(π) with Sjf(π)
being the starting time of job jf in schedule π.We know that a job j can be the first tardy job only when there is no
job k with k < j, dk < dj , pk > pj (see Lemma 15). Let J = {j1, j2, . . . , j∗}
be the set of jobs that can be the first tardy job in an optimal schedule,where N = {1, 2, . . . , n} = {1, 2, . . . , j1 − 1, j1, j1 + 1, . . . , j2, . . . , j
∗, . . . , n}.If jk ∈ J and jl ∈ J, jk < jl, then Sjk
< djlin all optimal schedules,
where jk is the first tardy job. Then for each job jk ∈ J , we can considerall situations characterized by Sjk
∈ (dα, dα+1], α = jk, jk + 1, . . . , jk+1 − 1and Sjk
∈ (djk− pjk
, djk], where Sjk
is the starting time of job jk in anoptimal schedule. It is obvious that there exists a situation (jk, Sjk
) possiblycorresponding to an optimal schedule, where jk ∈ J is the first tardy job,
25
j*
Figure 1: EDD order and choice of a situation in an optimal schedule.
and Sjk∈ (dα, dα+1], α = jk, jk + 1, . . . , jk+1 − 1 or Sj ∈ (djk
− pjk, djk
]. Wecan consider each of these situations separately. There are at most n suchsituations.
If we assume that jk ∈ J is the first tardy job and Sjk∈ (dα, dα+1] in
an optimal schedule, then all jobs (1, . . . , α) are tardy, too. Without lostof generality, we can set djk
:= dα+1 and consider a new instance with amodified due date djk
(see Figure 1 with an EDD schedule).We propose the following algorithm.
Algorithm T
1. Compute j∗ := argmax{di : pi = maxk∈N pk} and the set J ={j1, j2, . . . , j
∗} of jobs that can be the first tardy job;
2. FOR each job jk ∈ J DO:
- We consider each interval (dα, dα+1], α = jk, jk + 1, . . . , jk+1 − 1and (djk
− pjk, djk
] separately. Let Sjk∈ (dα, dα+1]. We set
F := {i ∈ N, di < dα+1}⋃{jk}, S := {i ∈ N, pi > pjk
} andSF := N \F \S. For this situation, we get an optimal schedule π= BranchFunction(F, S, SF, jk , α). Now we compare this schedulewith the current best schedule.
BranchFunction(F, S, SF, jk, α)
1. For each job i ∈ F⋃
SF , we define the sets of jobs F_Ai = {j ∈F, pj ≥ pi}, F_Bi = {j ∈ F, pj < pi}, SF_Ai = {j ∈ SF, pj ≥ pi}and SF_Bi = {j ∈ SF, pj < pi} (see Figure 2);
2. Elimination rule 1 If for job j ∈ F , there is a job k ∈ SF_Bj such thatdk − dj < |F_Aj |(pj − pk), where |F_Aj | is the number of elementsin set F_Aj , then F := F
⋃{k}, SF := SF \ {k}. The proof isobvious. If in an optimal schedule π, job k is on-time and j is tardy,then we can exchange these jobs and for the resulting schedule π′, wehave F (π′) > F (π);
26
i
F_Ai
F_Bi
SF_AiSF_Bi
jk
Figure 2: Branch function and sets of jobs
3. Elimination rule 2 If for job j ∈ F , there is a job k ∈ SF_Bj suchthat dk ≥ dj, then F := F
⋃{k}, SF := SF \ {k}.4. Elimination rule 3 We know that for this situation Sjk
≤ dα+1 holds.If for all k ∈ SF_Ai
⋃F_Ai, where dα+1 +P (SF_Ak)+P (F_Ak)+
pk ≥ ∑nj=1 pj − P (SF_Bi) − P (SF_Bi), we have di − dk <
|F_Ak|(pk − pi), then F := F⋃{i}, SF := SF \ {i};
5. Elimination rule 4 If for all k ∈ SF_Bi⋃
F_Bi, where dα+1 +P (SF_Ai)+P (F_Ai) ≥
∑nj=1 pj−P (SF_Bk)−P (SF_Bk)−pk, we
have dk − di > |F_Ai⋃
SF_Ai|(pi − pk), then F := F⋃{i}, SF :=
SF \ {i};6. We construct the schedule π = (SPT,LPT ). All jobs from set S are
processed at the beginning of the schedule. All jobs from sets F andSF are processed at the end of the schedule in an LPT order. If alljobs from sets F and SF are tardy in the schedule, then RETURN π.
7. Let l ∈ F⋃
SF be the last on-time job in schedule π. It is ob-vious that there is no optimal schedule, where all jobs from setl⋃
SF_Bl
⋃F_Bl are tardy. Therefore, we must choose one job i
from set SF_Bl (or from set SF_Bl
⋃{l}, if l ∈ SF ) and put it intoset S.
8. Let i ∈ SF_Bl (or i = l, if l ∈ SF ) be the job with the maximalprocessing time from set SF_Bl (or i = l, if l ∈ SF );
9. We compute π1 = BranchFunction(F⋃{i}, S, SF \ {i}, jk , α) and π2
= BranchFunction(F, S⋃{i}, SF \ {i}, jk , α) and RETURN the best
27
schedule from π1 and π2.
Concluding remarks
In this paper, we have proposed a polynomial solution algorithm for problem1||max
∑Uj of maximizing the number of tardy jobs (when the first job
starts at time zero and there is no idle time between the jobs). For thesingle machine problem 1||max
∑Tj of maximizing total tardiness, we have
developed a pseudo-polynomial solution algorithm. In addition, for severalspecial cases of problem 1||max
∑Tj , we have presented exact polynomial
algorithms.
References
[1] Lazarev, A.: Dual of the Maximum Cost Minimization Problem, Journalof Mathematical Sciences, Springer, Vol. 44, No. 5, 1989, 642 – 644.
[2] Moore, J.M.: An n Job, One Machine Sequencing Algorithm for Mini-mizing the Number of Late Jobs, Management Sci., Vol. 15, No. 1, 1968,102 – 109.
[3] Huang, R.H.; Yang, C.L.: Single-Machine Scheduling to Minimize theNumber of Early Jobs, IEEE International Conference on IndustrialEngineering and Engineering Management, 2007, art.no. 4419333, 955– 957.
[4] Du J.; Leung J. Y.-T.: Minimizing Total Tardiness on One Processoris NP-hard, Math. Oper. Res., 1990, Vol. 15, 483 – 495.
[5] Lazarev, A.A.; Gafarov, E.R.: Special Case of the Single-Machine To-tal Tardiness Problem is NP-hard, Journal of Computer and SystemsSciences International, 2006, Vol. 45, No. 3, 450 – 458.
[6] Lawler, E.L.: A Pseudopolynomial Algorithm for Sequencing Jobs toMinimize Total Tardiness, Ann. Discrete Math, 1977, Vol. 1, 331 – 342.
[7] Szwarc, W.; Della Croce, F.; Grosso, A.: Solution of the Single MachineTotal Tardiness Problem, Journal of Scheduling, 1999, Vol. 2, 55 – 71.
[8] Potts C.N.; Van Wassenhove L.N.: A Decomposition Algorithm for theSingle Machine Total Tardiness Problem, Oper. Res. Lett., 1982, Vol.1, 363 – 377.
28
[9] Lazarev, A.A.; Werner, F.: Algorithms for Special Cases of the SingleMachine Total Tardiness Problem and an Application to the Even-OddPartition Problem, Mathematical and Computer Modelling, Vol. 49, No.9-10, 2009, 2061 – 2072.
[10] Lazarev A.A.; Kvaratskheliya A.G.; Gafarov E.R.: Algorithms for Solv-ing the NP-Hard Problem of Minimizing Total Tardiness for a SingleMachine, Doklady Mathematics, 2007, Vol. 75, No. 1, 130 – 134.
[11] Lazarev A.A.; Werner F.: A Graphical Realization of the Dynamic Pro-gramming Method for Solving NP-Hard Combinatorial Problems, Com-puters and Mathematics with Applications, 2009, Vol. 58, No. 4, 619 –631.
29