Exact and heuristic approaches to single machine earliness-tardiness scheduling

JOANNA JÓZEFOWSKA and MICHAŁ MURAS Keywords: single machine scheduling, earliness-tardiness, exact algorithms, heuristics

Abstract. The concept of Just-in-Time scheduling requires that jobs are completed as close to

their due date as possible. Various models have been developed to support scheduling decisions

in such environment. In this paper the problem of scheduling independent non-preemptable jobs

with distinct due-dates on a single machine to minimise total weighted earliness and tardiness is

considered. The model with distinct and asymmetric weights is examined and machine idle time

is allowed. Since the problem is known to be NP-hard several heuristics are proposed as well as a

branch and bound algorithm and a dynamic programming procedure. The performance of the

proposed algorithms is examined on a basis of computational experiments.

1 Introduction

In modern enterprises the control of the production process involves the whole supply chain. One

of the benefits of such approach is the reduction of inventory management costs. The supplier is

supposed to deliver goods as close to the required date as possible. This concept is often called

Just-in-Time (JIT) production. JIT is a philosophy of production control that focuses on

eliminating waste striving for zero inventory, zero employee non-productive time, zero defects

and so on. Since the late seventies, there has been much interest in the Just-in-Time production

control methods. The first reports from introducing this concept in Japanese companies, like

Toyota, Nissan, Mazda and Hyundai were very promising. The implementation of JIT systems

led to shorter cycle times and reductions in inventory costs, labour costs, space requirements and

material costs. Golhar and Stamm (1991) present an interesting and comprehensive literature

review on JIT systems.

1

JIT concept for production control has induced a new type of machine scheduling problems in

which both early and tardy completions of jobs are penalised. Inventory can be viewed as

expensive waste because it represents idle resources and incurs holding costs. Thus, the earliness

costs include inventory management costs emerging when a product is completed before its due

date. The tardiness costs relate to penalty costs emerging if production is completed after the due

date. The objective is to minimise the total cost. Various models for Just-in-Time scheduling are

considered in the literature (Baker and Scudder 1990). It is generally assumed that jobs are

independent non-preemptable and scheduled on a single machine. Most of the research concentrates

on problems with a common due date. Gordon et. al. (2002) present a comprehensive up-to-date

survey of models and algorithms for these problems.

More general is the problem with distinct due dates and the objective function defined as the total

weighted earliness and tardiness. Garey, Tarjan and Wilfong (1988) showed that this problem is

NP-complete even if all the weights are equal. A special case of the problem with distinct due

dates without idle time is often considered in the literature. Abdul-Razaq and Potts (1988), Li

(1997) and Liaw (1999) developed branch and bound algorithms for this problem while Ow and

Morton (1988, 1989) proposed some heuristic approaches.

In general, insertion of idle time can reduce the total earliness and tardiness cost and is more

consistent with the earliness-tardiness criterion. In this case solving the problem consists of two

steps: to find optimal sequence of jobs and to find optimal timing for the given sequence. Fry et.

al. (1987) showed that the latter problem can be formulated and solved as a linear programming

problem. However, more efficient algorithms are known. Garey, Tarjan and Wilfong (1988)

proposed an O(nlogn) algorithm to find optimal timing for the non-weighted problem. Yano and

Kim (1991) adopted the dynamic programming approach, while Davis and Kanet (1993)

developed optimal timing algorithms for the case of independent asymmetric weights. Lee and

Choi (1995) proposed a simplification of the Yano and Kim approach. Further, Chrétienne (1999)

extended the algorithm developed by Garey, Tarjan and Wilfong to the case of asymmetric, but

2

job independent weights and proposed an O(n3logn) algorithm for the general case. Bauman and

Józefowska (2002) presented O(nlogn) algorithm for the latter problem. Scheduling algorithms

proposed in the literature for the problem with idle time include branch and bound approaches

(Fry, Darby-Dowman and Armstrong 1988 ; Yano and Kim 1986, 1991; Davis and Kanet 1993;

Chang 1999), local search algorithms (Lee and Choi 1995, James and Buchanan 1997) and

greedy heuristics (Fry et. al. 1987, 1990). The branch and bound algorithms for the non-weighted

case were proposed by Fry, Darby-Dowman and Armstrong (solving up to 20 jobs), Yano and

Kim (1986) (solving up to 30 jobs) and Chang (solving up to 45 jobs within 6000 CPU seconds

on a VAX/6510 machine). Yano and Kim (1991) considered the case where job penalties are

proportional to the processing times but their branch and bound algorithm solved only small

problems. Davis and Kanet considered arbitrary weights and tested their algorithm on problems

with eight jobs. Lee and Choi proposed a genetic algorithm solving up to 80 jobs within less than

800 CPU seconds on an IBM486SX computer. They compare their solutions with optimal ones

for small instances only. James and Buchanan developed a tabu search approach. They report

solutions of problems with up to 250 jobs, but the computational times are large and exceed 6000

CPU seconds on a VAX6000 mainframe and the quality of solutions obtained for large problems

is difficult to asses.

Another possible generalisation of the above problem is to consider time windows instead of due

dates. Such models were examined by Koulamas (1996), Mazzini and Armenanto (2001) and

Wan and Yen (2002).

In this paper we consider the problem of scheduling independent non-preemptable jobs with

distinct due-dates on a single machine to minimise the total weighted earliness and tardiness. The

model with arbitrary weights and idle time is examined. Exact algorithms based on branch and

bound and dynamic programming approaches are developed to solve the considered problem.

However, since the problem is NP-hard heuristic algorithms are also proposed. They include

simple greedy heuristics as well as a tabu search algorithm. The problem is formulated in

3

Section 2. An algorithm used for finding an optimal vector of completion times for a given

sequence of jobs is presented in Section 3. In the following Sections algorithms for constructing a

sequence of jobs are proposed: a branch and bound algorithm in Section 4 and heuristic

algorithms in Section 5. A dynamic programming approach is discussed in Section 6. The results

of the computational experiments are summarised in Section 7. Conclusions and directions of

further research are outlined in Section 8.

2 Problem formulation

Let us consider set J = {1, …, n} of n non-preemptable, independent jobs to be scheduled on a

single machine, each job i having processing time pi, and due date di, i = 1, …, n. Without loss of

generality we can assume that the processing times and the due dates are integers. The machine

can handle no more than one job at a time and is assumed to be continuously available from time

zero onwards only. Let S be a feasible schedule (i.e. such that the jobs do not overlap in their

execution and no job starts its processing before time zero) in which Ci is the completion time of

job i, i = 1, …, n. We assume that the earliness, as well as tardiness, costs are linear functions of

the deviation of job's completion time Ci from its due date di. The earliness cost is positive only if

di – Ci ≥ 0, otherwise it is zero. On the other hand, the tardiness cost is positive only if Ci

})

– di ≥ 0,

otherwise it is zero. In general, the total earliness and tardiness cost of schedule S may be

calculated as follows:

(1) { } {(∑=

−+−=n

iiiiiii dCCdSf

1,0max,0max)( βα

where αi is the cost of job i being completed one time unit before its due date, and βi is the cost of

job i being completed one time unit after its due date i = 1, …, n. Our goal is, obviously, to find a

feasible schedule S* with the minimum value of function f(S).

An optimal schedule is constructed by first finding an optimal sequence of jobs. For a given

sequence of jobs the problem is to find an optimal vector of completion times of jobs. Observe

that unlike for regular objective functions (like Cmax or Lmax) inserting machine idle time may be

4

desirable. In the next Section a O(nlogn) time algorithm for finding an optimal vector of

completion times is presented. The problem of constructing an optimal sequence of jobs is

examined in Sections 4 and 5.

3 Optimal assignment of completion times

In general, the vector of optimal completion times for a given sequence (permutation) of jobs

may be found by solving a linear programming problem. This approach is rather time consuming.

Bauman and Józefowska (2002) proposed O(nlogn) algorithm to find an optimal timing.

In this algorithm jobs are added to the schedule in a predefined order. At each step an optimal

timing is found for the subsequence of jobs already scheduled. Let us assume that jobs 1, 2, …, k

– 1 are already scheduled optimally and Ck – 1 is the completion time of job k – 1. If Ck – 1 + pk – dk

≤ 0 then job k can be scheduled in time without changing the schedule of jobs 1, 2, …, k – 1.

Obviously in this way we obtain an optimal schedule of k jobs. If Ck – 1 + pk – dk > 0 then either

job k is tardy causing additional cost of βk(Ck – 1 + pk – dk ) or jobs already scheduled must be

shifted left causing additional cost as well. It is now to calculate how far the jobs should be

shifted left (considering a zero shift as the minimal one) to obtain an optimal schedule of k jobs.

To this end a function K(x) is defined where K(x) is the minimum total cost of shifting the last job

in the current sequence and its required predecessors to the left by x time units. This function is

piecewise linear and convex. The points at which the slope of function K(x) changes are called

characteristic points and are calculated during the scheduling procedure. As long as there is no

idle time in the schedule K(x) = ∞, because no left shift is possible (the first job can not start

before time 0). Let i be the first job that can be scheduled in time with idle time of x1 time units. It

means that it can be shifted left by at most x1 time units. Thus, the first characteristic point is

created. At the same time the slope coefficients are updated. Function K(x) is defined as follows:

( )

>∞≤

=1

1 if if

xxxxx

xK iα (2)

5

If the next job i + 1 also can be scheduled in time with idle time x2, function K(x) is updated as

follows:

( ) ( )

+>∞+≤<+

≤= +

+

21

2121

21

if if

if

xxxxxxxx

xxxxK ii

iαα

α (3)

Thus, updating function K(x) while scheduling job i that can be scheduled in time with idle time

xi requires adding a new characteristic point and shifting the existing characteristic points by xi.

Further, in each interval the coefficient of function K(x) has to be increased by αi.

If job i that can not be scheduled in time it is easy to calculate the optimal shift comparing the

coefficient of function K(x) with βi. Job i is shifted left as long as K(x) ≤ βix. Updating function

K(x) requires removing an interval of length z, where z is the length of the shift. Notice that a new

characteristic point may occur. It is necessary to decrease the coefficients of function K(x) in

every remaining interval by ∆, the value attained by function K(x) at the last characteristic point

removed. An example of function K(x) for a sequence consisting of three jobs is presented in

figure 1.

Insert figure 1 about here.

Briefly the algorithm is presented below. This algorithm can be implemented to run in O(nlogn)

time. It will be used to calculate the value of the objective function in the branch and bound and

heuristic algorithms proposed in the following sections.

Algorithm 1

begin C := 0; {start scheduling at time 0}

for k := 1 to n do

begin x := C + pk – dk; {schedule job k starting at time C and calculate its lateness}

if x ≤ 0 then {job is early}

update function K(x);

C := dk; {move job k right so that it is completed in time}

6

else {job is late}

begin calculate the optimal shift y;

update function K(x);

C := C – y;

end; Ck = C;

end;

for k := n to 1 step –1 do

begin calculate the completion time Ck of job k as minimum of Ck and starting time of

job k + 1;

cost := cost + max{0, dk – Ck}* αk + max{0, Ck – dk}* βk;

end;

end;

4 Branch and bound algorithm

It is known that the considered problem is NP-hard (Garey, Tarjan and Wilfong 1988), so it is

justified to use heuristic scheduling algorithms. However, in order to obtain optimal solutions for

small problem instances a branch and bound procedure has been developed.

The branch and bound algorithm uses the depth-first-search rule to explore the solution tree.

Branching is based on fixing the positions of jobs in the sequence, starting from the last one.

Assume that a sequence of jobs {k + 1, k + 2, …, n} is fixed. The lower bound is calculated as

follows. It is assumed that processing of job k + 1 may not start before time . An

assignment of completion times to jobs {k + 1, k + 2, …, n} is found using Algorithm 1. The

lower bound is the cost of scheduling jobs {k + 1, k + 2, …, n} according to this assignment. The

initial upper bound is calculated as the cost of schedule generated by the sorting algorithm

described in the next Section.

∑=

=k

iipt

1

7

5 Heuristic algorithms

Several simple heuristics as well as a tabu search algorithm have been developed for the

considered problem. In each of the proposed heuristics an optimal timing for a given sequence

was found using Algorithm 1 described in Section 3. Below we introduce the heuristic algorithms

tested.

Sorting algorithm. Jobs are ordered according to non-decreasing due dates. This order is also

used as an initial order of jobs in all the proposed heuristics.

Random algorithm. A given number of sequences are randomly generated and for each

sequence the optimal timing is calculated. The best solution found is chosen.

Greedy algorithm. This algorithm works similarly as the branch and bound algorithm, however

it searches only one path in the search tree, in each step choosing the node with the best lower

bound.

Iterative improvements. A neighbouring solution is found by swapping two adjacent jobs in the

current sequence starting from the first position. The optimal timing is calculated after each

change. If solution better than the current one is found, it becomes the current solution and the

neighbourhood search starts from the first position in the current sequence. If the current solution

can not be improved, the procedure stops (often in a local optimum).

Three versions of this algorithm were implemented:

• Iterative improvement, starts from the sequence generated by the sorting algorithm.

• Iterative improvement 10, starts from a random sequence of jobs and the best solution

out of 10 consecutive runs of the algorithm is chosen.

• Greedy algorithm with an improvement procedure. It is the iterative improvement

algorithm with an initial solution generated by the greedy algorithm.

Tabu search algorithm. A solution is represented by a sequence of jobs. For such sequence the

value of the objective function is calculated using Algorithm 1. The initial sequence is generated

by the sorting algorithm. The neighbourhood consists of 2(n – 1) elements. First (n – 1) elements

8

are created by swapping each pair of adjacent jobs in the sequence. The remaining elements are

constructed by swapping two pseudorandomly selected jobs in the sequence. The tabu list

consists of 14 elements and it contains positions of jobs swapped. It means that if (i, j) is on the

tabu list than it is forbidden to swap the jobs in positions i and j in the sequence, regardless which

jobs occur in these positions. A move from the tabu list can be chosen if it generates a solution

better than the current best solution (aspiration criterion). If the current solution is not improved

in 80 consecutive iterations the algorithm is terminated. The parameters of the tabu search

algorithm were chosen on a basis of an extensive computational experiment.

6 Dynamic programming approach

The dynamic programming approach was examined for the problem of scheduling jobs with

weights fulfilling special conditions by Yano and Kim (1991). Below, we present a dynamic

programming procedure working for the general case, i.e. jobs with arbitrary asymmetric weights

and individual due dates.

Let us first determine the scheduling horizon H. It is often specified in the problem formulation.

Otherwise it can be calculated as . Now, let us assume that n∑=

≤≤+

n

iiini

pd11

max – k jobs are

scheduled in the interval [0, T], T ≤ H. We would like to schedule the set J of remaining k jobs

optimally, starting at time T. Let us assume that job j ∈ J is the job scheduled first in J and its

processing starts at time T. Thus Cj = T + pj and the cost of scheduling job j equals:

( ) { } { }jjjjjjj dpTpTdTv −++−−= ,0max,0max βα .

Assume further that f*(J\{j}, T + pj} is the optimal cost of scheduling set J\{j} starting not earlier

than at time T + pj. The cost of scheduling set J starting with job j at time T equals:

f(J, j, T ) = vj(T) + f*(J\{j}, T + pj} (4)

9

Equation (4) is the recursive relation of our dynamic programming procedure. At each stage k,

k = 1, 2, …, n (with k jobs in set J) it is to chose the job j ∈ J to be scheduled first and its starting

time (t ≥ T), so that the value of the recursive function f(J, j, T) is minimum:

f*(J, T} = min{ f(J, j, t): j ∈ J , for all feasible T ≤ t ≤ H}.

It is easy to observe that the condition ‘for all feasible t’ reduces the number of decisions to be

considered. Namely, we know that the last job has to be completed before H, so it is sufficient to

consider . Nevertheless, at each iteration k, k = 1, 2,…, n∑∈

−≤Jj

jpHt , all k-element subsets of

the set of jobs have to be examined, so the complexity of the problem is O(n2nH). It should be

noticed that for many special cases, the time horizon H can be significantly reduced. Thus, for

large n the proposed dynamic programming procedure can be more effective than the full

enumeration which is O(n!). Moreover, some dominance relations can be applied to further

reduce the computational effort of both the algorithms.

7 Computational experiments

Computational experiments were carried out to evaluate the performance of the heuristics. All the

algorithms were implemented in C++ and the experiments were carried out on Celeron 300 MHz

computer with 128 MB RAM. The instances were generated randomly with uniform distribution:

job processing times (pi) were generated from the interval [0, 20], earliness penalties (αi) from

the interval [2, 58], tardiness penalties (βi) from the interval [3, 76]. Three types of due dates

were considered: tight, medium and lose due dates. Tight due dates mean that it is unlikely that

idle time occurs in optimal schedules, while lose due dates in most cases result in idle time

inserted. Due dates were also generated using the uniform distribution from intervals depending

on the tightness: [5, 0. 5S] - for tight due dates, [5, S] - for medium due dates and [5, 3S] - for lose

due dates, where S is total processing time of jobs in the given instance.

Two experiments were carried out. The aim of the first one was to compare the results obtained

by heuristic algorithms for large problem instances of 50, 100, 150, 200, 250, 300, 350, 400, 450,

10

500, and 600 jobs. Since the iterative improvement algorithm started from 10 randomly generated

sequences (iterative improv.10) performed much worse that the one started from the EDD

sequence this algorithm was not considered any further. The greedy algorithm was also excluded

from further consideration for similar reasons. For each problem size 10 instances were

generated. The results are grouped depending on the tightness of the due dates. The notation used

in tables 1-3 is the following: n denotes the number of jobs (problem size), MAD denotes the

mean relative deviation from the best solution found by all the tested algorithms and CPU means

the maximum CPU time over 10 instances tested for a given problem size. Zero CPU time means

less than 1 s computational time.

Insert table 1 about here.

Lose due dates show the advantage of the EDD sorting. Both the greedy algorithm with

improvement and iterative improvement find the same solutions, however iterative improvement

requires less computational time. Random sampling finds very bad solutions. Tabu search

requires more CPU time for larger instances, but even for 600 jobs the CPU time does not exceed

8 minutes.

Insert table 2 about here.

Medium due dates appear difficult for the simple sorting algorithm. In this case the iterative

improvement gives very good solutions, however at high computational cost. Both quality of

solutions and CPU time required are comparable with those of tabu search. The improvement

procedure started from the greedy solution gives slightly worse results but with much smaller

computational times. Random sampling is always worse than the sorting procedure.

Insert table 3 about here.

In the case of tight due dates iterative improvement and tabu search generate the best solutions.

Iterative improvement requires more time than tabu search, especially for large instances.

Random sampling is sometimes slightly better than the sorting algorithm.

11

Tabu search requires more time for larger instances. For 1000 jobs the processing time exceeded

2 hours, so the experiment was performed only up to 600 jobs. For small instances (up to 100

jobs) tabu search stops in less than 10 seconds. Moreover, problems with medium due dates

require largest computational effort.

In the second experiment the results obtained by the best heuristic algorithms were compared

with optimal solutions, obtained by the branch and bound algorithm. This was possible only for

small instances up to 20 jobs. For each problem size 15 instances were generated, 5 in each group

with tight, medium and lose due dates respectively. Mean relative deviations from optimum are

presented in tables 4-6. For instances with less than 15 jobs computational time of the heuristics

was negligible. Average computational time for problems with more than 15 jobs was less than 1

second in case of heuristics and 11 minutes for the branch and bound algorithm. Only twice the

maximum computational time exceeded 1 hour (1h:02min and 1h:14min). This experiment is

going to be continued.

Insert table 4 about here.

In the case of lose due-dates tabu search found optimal solutions for all the instances tested. Both,

the greedy algorithm with improvement and iterative improvement found the same solutions,

being very close to optimal ones.

Insert table 5 about here.

Instances with medium due dates were more difficult for heuristic algorithms, but only in few

cases tabu search failed to find optimal solution with mean relative deviation from optimum less

than 3%. Both the greedy algorithm with improvement and iterative improvement found the same

solutions, rather distant from optimum.

Insert table 6 about here.

Problems with tight due dates were most challenging for the heuristic algorithms. Tabu search

found solutions with minimal mean relative deviation from optimum. Iterative improvement with

12

greedy start point algorithm was over 10 times worse, but still better than the standard iterative

improvement.

8 Conclusions

Two exact approaches to solving the problem of scheduling independent non-preemptable jobs

with distinct due-dates and distinct and asymmetric weights and machine idle time allowed on a

single machine to minimise total weighted earliness and tardiness are proposed. These are

dynamic programming and branch and bound algorithms. Since it may be expected that for small

instances the branch and bound approach is more effective this algorithm was implemented to

find optimal solutions in one of the computational experiments.

Some heuristic algorithms for the considered problem are developed and tested on a basis of

computational experiments. In the first experiment the greedy heuristics are compared with a tabu

search algorithm for instances of 50 to 600 jobs. Compared to the results reported in the

literature, the tabu search algorithm presented is able to solve large instances in reasonable time.

A fast timing procedure used to find an optimal vector of completion times for a given sequence

of jobs is probably the reason for the high efficiency of the algorithm.

In the second experiment the results obtained by the best heuristics are compared with optimal

solutions. This experiment was performed for at most 20 jobs due to large computational times of

the branch and bound procedure used to find optimal solutions. This experiment proved that the

tabu search algorithm finds solutions close to optimal ones.

Further research is planned to improve the branch and bound algorithm and to develop a local

search heuristic to solve large problems with a good accuracy.

Acknowledgement

The authors would like to express their deep thanks to Prof. Salah Elmaghraby for

encouragement and very instructive suggestions concerning the development of the dynamic

programming procedure.

13

This research was supported by the Polish State Committee for Scientific Research Grant No.

4T11F 001 22.

References

ABDUL-RAZAQ, T., and POTTS, C., 1988, Dynamic programming state-space relaxation for

single-machine scheduling, Journal of the Operational Research Society, 39, 141-152.

BAKER, K., and SCUDDER, G., 1990, Sequencing with earliness and tardiness penalties:

A Review, Operations Research, 38, 22-36.

BAUMAN, J., and JÓZEFOWSKA, J., 2002, Minimizing the earliness-tardiness costs on a single

machine, Research Report, Poznań University of Technology, RA-002/2002.

CHANG, P. C., 1999, A branch and bound approach for single machine scheduling with earliness

and tardiness penalties, Computers and Mathematics with Applications, 37, 133-144.

CHRÉTIENNE, P., 1999, Minimizing the earliness and tardiness costs of a sequence of tasks on

a single machine, Research Report Laboratoire d'Informatique de Paris 6.

DAVIS, J. S., and KANET, J. J., 1993, Single machine scheduling with early and tardy

completion costs, Naval Research Logistics, 40, 85-101.

FRY, T., ARMSTRONG, R., and BLACKSTONE, J., 1987, Minimizing weighted absolute

deviation in single machine scheduling, IEEE Transactions, 19, 445-450.

FRY, T., ARMSTRONG, R. D., and ROSEN L. D., 1990, Single machine scheduling to

minimize mean absolute lateness. A heuristic solution, Computers and Operations Research, 17,

105-112.

FRY, T., DARBY-DOWMAN, K., and ARMSTRONG, R., 1988, Single machine scheduling to

minimize mean absolute lateness, Working Paper, College of Business Administration,

University of South Carolina, Columbia, USA.

GAREY, M., TARJAN, R., and WILFONG G., 1988, One-processor scheduling with symmetric

earliness and tardiness penalties, Mathematics of Operations Research, 13, 330-348.

14

GOLHAR, D. Y., and STAMM C. L., 1991, The JIT philosophy: A review, International Journal

of Production Research, 29, 657-676.

GORDON, V., PROTH, J.-M., and CHU, C., 2002, A survey of the state-of-the-art of common due

date assignment and scheduling research, European Journal of Operational Research, 139, 1-25.

JAMES, R. J. W., and BUCHANAN, J. T., 1997, A neighbourhood scheme with a compresses

solution space for the early/tardy scheduling problem, European Journal of Operational Research,

102, 513-527.

KOULAMAS, C., 1996, Single machine scheduling with time windows and earliness/tardiness

penalties, European Journal of Operational Research, 91, 190-202.

LEE, C. Y., and Choi, J.Y., 1995, A genetic algorithm for job sequencing problem with distinct

due dates and general early-tardy penalty weights, Computers and Operations Research, 22, 857-

869.

LI, G., 1997, Single machine earliness and tardiness scheduling. European Journal of Operational

Research, 96, 546-558.

LIAW, C. F., 1999, A Branch and Bound algorithm for the single machine earliness and tardiness

scheduling problem, Computers and Operations Research, 26, 679-693.

MAZZINI, R., ARMENTANO, V. A. , 2001, A heuristic for single machine scheduling with

early and tardy costs, European Journal of Operational Research, 128, 129-146.

OW, P., and MORTON T., 1988, Filtered beam search in scheduling, International Journal of

Production Research, 26, 35-62.

OW, P., and MORTON T., 1989, The single machine early-tardy problem, Management

Science, 35, 177-191.

WAN, G., and YEN B. P.-C., 2002, Tabu search for single machine scheduling with distinct due

windows and weighted earliness/tardiness penalties, European Journal of Operational Research,

142, 271-281.

15

YANO, C., and KIM Y., 1986, Algorithms for single machine scheduling problems minimizing

earliness and tardiness, Technical Report #86-40, Department of Industrial Engineering,

University of Michigan, Ann Arbor.

YANO, C., and KIM Y., 1991, Algorithms for a class of single machine weighted tardiness and

earliness problems, European Journal of Operational Research, 52, 167-178.

16

∆

K(x)

t

t

z

d1

β3x

x3

x3

p3

x2

p2

x1

p1

β2x

β1x

α2x α3x

α1x

d3d2

x1x2

d1

Figure 1. Function K(x) for three consecutive jobs. The third job should be shifted left by z.

17

Table 1. Results of the experiment for lose due dates.

Sorting random Greedy+ iterative tabu search n

MAD CPU MAD CPU MAD CPU MAD CPU MAD CPU

50 0.489 0 164.949 1 0.052 1 0.052 0 0 0 100 0.566 0 416.560 3 0.045 1 0.045 0 0 5 150 0.528 0 782.326 4 0.055 2 0.055 1 0 15 200 0.552 0 1929.427 4 0.065 3 0.065 2 0 30 250 0.579 0 776.777 11 0.111 4 0.111 7 0 71 300 0.507 0 2804.006 5 0.084 4 0.084 2 0 79 350 0.524 0 2606.932 7 0.073 10 0.073 5 0.004 123 400 0.506 0 4783.126 8 0.044 11 0.044 7 0 177 450 0.498 0 3605.387 9 0.060 12 0.060 9 0.005 221 500 0.591 0 3331.650 10 0.097 19 0.097 14 0 328 600 0.627 0 1510.349 12 0.102 28 0.102 24 0 433

improve improv.

Table 2. Results of the experiment for medium due dates.

Sorting random Greedy+ Iterative improv. tabu search n

MAD CPU MAD CPU MAD CPU MAD CPU MAD CPU 50 1.702 0 9.490 1 0.424 1 0.348 0 0 1

100 2.428 0 13.752 1 0.199 2 0.123 2 0.072 8150 3.084 0 12.151 2 0.290 11 0.071 17 0.028 41200 3.052 0 15.146 3 0.227 43 0.061 123 0.138 116250 2.927 0 22.237 3 0.487 31 0.159 58 0.171 112300 3.201 0 25.019 4 0.335 57 0.071 132 0.113 187350 3.553 0 24.615 4 0.336 155 0.063 253 0.254 342400 3.712 0 17.297 5 0.318 144 0.011 399 0.241 446450 3.865 0 19.618 5 0.336 282 0.008 758 0.297 963500 4.085 0 20.785 6 0.341 288 0 1052 0.286 1172600 4.337 0 20.967 8 0.400 627 0 2312 0.532 2348

improve

18

Table 3. Results of the experiment for tight due dates.

Sorting random Greedy+ iterative improv. tabu search n

MAD CPU MAD CPU MAD CPU MAD CPU MAD CPU 50 1.142 0 0.710 1 0.032 1 0.021 1 0 1

100 1.178 0 0.819 1 0.029 2 0.008 4 0.001 4150 1.279 0 1.116 3 0.043 14 0.003 27 0.002 23200 1.518 0 1.530 2 0.062 36 0.012 198 0 53250 1.341 0 1.298 2 0.055 62 0.008 133 0.004 102300 1.495 0 1.648 3 0.055 247 0.009 1448 0.002 285350 1.426 0 1.564 3 0.059 213 0.002 781 0.005 191400 1.700 0 2.176 4 0.077 326 0.006 842 0.007 334450 1.650 0 1.983 12 0.070 2217 0.005 6225 0.009 1189500 1.614 0 1.888 6 0.074 797 0.006 2601 0.003 539600 1.476 0 1.659 4 0.062 1566 0.002 5002 0.002 1024

improve

Table 4. Results of the experiment for lose due dates (MAD).

n Greedy+ improve iterative improv. tabu search 6 0 0 0 8 0 0 0 9 0 0 0 10 0,096316 0,096316 0 11 0 0 0 12 0 0 0 13 0 0 0 14 0 0 0 15 0,096313 0,096313 0 16 0 0 0 17 0,039266 0,039266 0 18 0,05119 0,05119 0 19 0 0 0 20 0,081841 0,081841 0

19

Table 5. Results of the experiment for medium due dates (MAD).

n Greedy+ improve iterative improv. tabu search 6 0 0 0 8 0,154573 0,154573 0 9 0,018223 0,018223 0 10 0,07947 0,07947 0 11 0,022244 0,022244 0 12 0,125 0,125 0,012019 13 0,090733 0,090733 0 14 0,01982 0,01982 0 15 0,118232 0,118232 0 16 0,033126 0,033126 0 17 0,196273 0,196273 0 18 0,217244 0,217244 0 19 0,1948 0,1948 0,005909 20 0,154661 0,154661 0,024208

Table 6. Results of the experiment for tight due dates (MAD).

n Greedy+ improve iterative improv. tabu search

6 0 0 0 8 0,080952381 0,036734694 0 9 0,022135684 0 0 10 0,046877872 0,040627489 0 11 0,030892256 0,081481481 0,021759259 12 0,075618347 0,056742476 0,001454935 13 0,151565074 0,104742912 0,020419665 14 0,068074216 0,068522073 0 15 0,0727562 0,100737411 0,010253043 16 0,041957042 0,153407669 0,002019227 17 0,045526745 0,102172164 0,008292592 18 0,085014962 0,113788076 0,009667766 19 0,129043229 0,122808343 0,008464329 20 0,029762761 0,075629044 0

20