Single Machine Scheduling with Tardiness Involved Objectives : A Survey

(1)

Link¨

opings Universitet

Institute of Technology

Department of Mathematics

Link¨

oping Studies in Science and Technology. Theses

No. 1117

The k-assignment Polytope and the

Space of Evolutionary Trees

Jonna Gill

Matematiska institutionen

Link¨

opings universitet, SE-581 83 Link¨

oping, Sweden

Link¨

oping 2004

20th September 2004 (15:20)

Single Machine Scheduling with Tardiness

Involved Objectives: A Survey

Master-Thesis

LiTH-MAT-EX-2007/09-SE

Handed in by:

Andreas Mundt

Thomas Wich

Auenstraße 8 Am Burgsteg 8

63791 Karlstein 63755 Alzenau

Germany Germany

Email: mundt a@gmx.de Email: thomaswich@web.de

Examiner: Ph.D Mathias Henningsson

(2)

(3)

Abstract

This thesis contributes to theoretical and quantitative aspects of machine scheduling. In fact, it is dedicated to the issue of scheduling n jobs on one single machine. The scope is limited to deterministic problems - i.e. those with all data available and known with certainty in advance - with tardiness involved objectives; hence, the common de-nominator of all problems addressed are jobs with a predetermined due date assigned to. A job is finished on time as long as it is completed before its due date, otherwise it is said to be tardy. Since the single machine utilized is assumed to be restricted to process at most one job at a time, the aim is to find a proper sequence - a schedule - of how to process the jobs in order to best fulfill a certain objective. The contribution of this thesis aims at giving a state of the art survey and detailed review of research effort considering the objectives “minimizing the number of tardy jobs” and “minimiz-ing the weighted number of tardy jobs”. Further, the objectives of “minimiz“minimiz-ing the total tardiness”, “minimizing the total weighted tardiness” and “mini-mizing the maximum tardiness” are adumbrated but reduced to a rough overview of research effort made.

Keywords Single Machine, Scheduling, Branch and Bound, Heuristics, Dynamic

Pro-gramming, Tardiness

(4)

(5)

Acknowledgements

First of all, we want to thank Link¨oping’s Institute of Technology for offering an interna-tional master’s program and providing the opportunity to live and study as a foreigner in Sweden. So far, studying in Sweden, traveling through the country and getting to know its nationals are one of the experiences we do not want to miss and we will never forget.

Especially, we would like to express our gratitude to Ph.D Mathias Henningsson at

Link¨oping’s Department of Mathematics and Prof. Dr. Wolfgang Domschke, head of

the Department of Operations Research at Darmstadt University of Technology, for supervising our thesis and giving valuable impetus.

Of course, we want to thank our parents and the whole family for their encouragement and support during all our years as pupils and students, and Sina and Renate for the joy, patience and understanding throughout the long time we spent abroad.

Last but not least, we want to thank our fellow students during our stay in Sweden for sharing all the great times and moments.

Link¨oping, March 2007

Andreas and Thomas

(6)

(7)

List of Figures

2.1 NP problem space . . . 15

2.2 Analysing scheduling problems . . . 16

2.3 Branching tree - example . . . 19

2.4 A sequence for purposes of dynamic programming . . . 22

3.1 Treated problem types - overview . . . 45

4.1 Branching scheme - example . . . 70

4.2 Timeline . . . 73

4.3 Release date adjustments to achieve a nested problem - initial problem . 82 4.4 Release date adjustments to achieve a nested problem - nested problem . 83 4.5 Lower bound calculation - example . . . 91

4.6 CPU time distribution (for n = 60) . . . 101

4.7 Illustrating the calculation of µk(a, b) - Gantt chart . . . 108

4.8 Interval structure . . . 111

5.1 B&B approach by M’Hallah and Bulfin (2003) - flow chart . . . 137

5.2 Minimizing the relaxed problem - flow chart . . . 143

5.3 B&B approach by M’Hallah and Bulfin (2007) - flow chart . . . 165

5.4 Effective processing time - Gantt chart . . . 173

5.5 Adding-a-new-job decision - Gantt chart . . . 174

5.6 Maximum weight calculation in the non-preemptive case - Gantt chart . 178 5.7 Maximum weight calculation in the preemptive case - Gantt chart . . . . 180

5.8 Calculation of completion time - Gantt chart . . . 185

(12)

(13)

List of Tables

2.1 Machine environment classification . . . 7

2.2 Job and resource classification . . . 9

2.3 Optimality criteria classification . . . 11

2.4 Complexity and growth rate for some polynomial and exponential algo-rithms . . . 14

2.5 Simple priority rules - selection . . . 32

3.1 Complexity of elementary SMS problems . . . 40

4.1 Minimizing the number of tardy jobs - overview . . . 50

4.2 Kise et al. (1978) algorithm - problem data . . . 56

4.3 Kise et al. (1978) algorithm - example . . . 56

4.4 Comparing the heuristic (Algorithm 4.4.2.1) and Algorithm 4.4.1.1 . . . . 65

4.5 Comparing the heuristic (Algorithm 4.4.2.1), Algorithm 4.4.1.1 and an exact branch and bound procedure . . . 65

4.6 Transforming an optimal sequence into the master sequence - example . . 67

4.7 Generating the master sequence - example . . . 68

4.8 Exemplary lower bound computation - problem data . . . 91

4.9 Dauzère-Pérès and Sevaux (2004) on “DPS ” instances - detailed results (for n = 140) . . . 98

4.10 Dauzère-Pérès and Sevaux (2004) on “DPS ” instances - summarized re-sults (1) . . . 99

4.11 Dauzère-Pérès and Sevaux (2004) on “DPS ” instances - summarized re-sults (2) . . . 100

4.12 Baptiste et al. (1998) on “BAP ” instances . . . 100

4.13 Baptiste et al. (2003) on “BAP ” instances . . . 102

4.14 Comparison on “BAP ” instances . . . 103

4.15 Comparison on “DPS ” instances . . . 103

4.16 Finding an admissible sequence - example . . . 117

4.17 Finding an admissible sequence (first iteration) - example . . . 117

5.1 Minimizing the weighted number of tardy jobs - overview . . . 124

(14)

5.2 Exemplary “list making and merging approach” - problem data . . . 130

5.3 “List making and merging approach” - example . . . 131

5.4 Crossover operators . . . 148

5.5 Relative gap for LRA . . . 153

5.6 Relative gap for GA . . . 153

5.7 Relative gap for GLS . . . 153

5.8 Improvement of the genetic algorithm (GALag) . . . 154

5.9 Improvement of the hybrid genetic algorithm (GLSLag) . . . 154

5.10 M’Hallah and Bulfin (2007) on “DPSw ” instances - runtime CPU seconds in the weighted case . . . 167

5.11 M’Hallah and Bulfin (2007) on “DPS ” instances - runtime CPU seconds in the non-weighted case . . . 167

5.12 Influence of problem type - runtime CPU seconds over all 640 instances . 168 5.13 The paramters’ influence on the mean CPU time - runtime CPU seconds 168 5.14 M’Hallah and Bulfin (2007) vs. Baptiste et al. (2003) on “DPS ” and “BAP ” instances . . . 169

5.15 M’Hallah and Bulfin (2007) on Baptiste et al. (2003) unsolved instances (for n = 200) . . . 169

5.16 M’Hallah and Bulfin (2007) vs. Sadykov (2004) vs. P´eridy et al. (2003) on “DPSw ” instances (for n = 100) . . . 170

6.1 Minimizing the total tardiness - overview . . . 192

6.2 Minimizing the total weighted tardiness - overview (1) . . . 195

6.3 Minimizing the total weighted tardiness - overview (2) . . . 196

(15)

Fundamental Symbols

Below’s list only highlights the most fundamental, repetitive symbols building the struc-ture of this thesis work. In the course of this thesis, plenty further symbols are introduced and explained in detail.

J Set (or sequence) containing all (n) jobs; J = {1, ..., n}, with

j ∈ J denoting a typical jobs. Alternatively, a typical job is denoted Jj; consequently J = {J1, ..., Jn}.

Uj Binary variable equal to 1 if job j is tardy; 0 otherwise.

P Uj Number of tardy jobs

P wjUj Weighted number of tardy jobs

xj Complementary binary variable to Uj: xj equals 1 if job j is

on time; 0 otherwise.

O Set (or sequence) of on-time jobs

L Set (or sequence) of jobs deemed to be tardy

F Set of jobs that do not belong to O or L (free jobs)

rj Release date / release time of job j

dj Due date of job j

pj Processing time of job j

Cj Completion time of job j

sj Actual starting time of job j

wj Weight of job j

t Point in time (or date) currently in focus

(16)

(17)

1 INTRODUCTION AND

MOTIVATION

Imagine some exemplary real world scenarios:

• Consider a hospital; every patient - from the doctor’s perspective a task - needs a bunch of different medical treatments (like surgery, x-raying, etc.). Each treatment symbolizes a scarce resource - in most cases due to limited staff. In which order shall a given number of patients with individual needs for medical treatments be served in order to minimize the average waiting time?

• Consider the processor of a computer as a resource; tasks arrive over time needing to be processed. In which order shall these tasks be accomplished in order to minimize the average time a task is in the system?1

• Consider a certain machine within a manufacturing process as a resource; there is a set of jobs that must be processed on this machine - like semi-finished goods waiting to be completed. Each job has individual characteristics - it takes a certain time to be completed, should be finished before a certain instant of time, etc. How shall the jobs be scheduled in order to meet certain objectives?

All these scenarios have in common that a decision must be made concerning the assign-ment of patients / tasks / jobs to the available resources and concerning the sequence to process them on each of those resources in order to “best” fulfill a certain predeter-mined objective; in other words, a schedule must be deterpredeter-mined. These questions can be ascribed to the so called scheduling theory.

Let’s focus on the last example given: it is a representative of what is referred to as machine scheduling problems, the framework where most of the scheduling issues are addressed in. When limiting the number of resources to one single machine, the issues are characterized as single machine scheduling problems (SMS). Assigning jobs to machines then becomes superficial, and the question is reduced to finding a schedule of jobs for only one particular machine with respect to the underlying objective.

1_{Comp. Karger et al. (1997, p. 1)}

(18)

2 Chapter 1: INTRODUCTION AND MOTIVATION

This thesis is dedicated to the problem of scheduling n jobs on one single machine. The scope is limited to deterministic2 problems with tardiness involved objectives; hence, the common denominator of all problems addressed are jobs with a due date assigned to. A job is finished on time as long as it is completed before its due date, otherwise it is said to be tardy.

Satisfying due dates is necessarily crucial, since tardiness is typically connected with extra costs. Think of penalty payments that might be incurred if a delay in delivering a product to a customer occurs, or of the negative effect if a subsequent step in a production line is forced to wait. But besides focusing on “hard money”, customer satisfaction and a company’s reliability might be stressed.

From a theoretical point of view, scheduling problems have extensively been studied by operations research (OR) practitioners, mathematicians, production researchers and

others since the beginning of the 1950s.3 Motivated by the numerous publications,

research efforts, various approaches and algorithms even in the field of single machine scheduling, this thesis aims at shedding some light on the class of deterministic SMS problems that are tardiness related. A state of the art survey is given comprising a detailed description of recent approaches and algorithms for two selected problem classes and a more superficial overview for some remaining.

The thesis’ structure in a short preview:

• Chapter 2 starts with a provision of basic knowledge about scheduling theory in general and some initial background for handling scheduling issues, including a short outlining of popular solving methods and approaches.

• Chapter 3 narrows the scope to single machine scheduling issues and introduces the specific problem types addressed.

• The core of this thesis is represented by Chapter 4 and 5. The first is dedicated to the objective of minimizing the number of tardy jobs, whereas the sec-ond handles problems considering job dependent weights, i.e. minimizing the weighted number of tardy jobs. Several recent solution approaches for differ-ent specific problems are reviewed.

• Consequently, Chapter 6 adumbrates some remaining tardiness involved problem classes. A survey concerning the objectives of minimizing the total tardiness, minimizing the total weighted tardiness and minimizing the maximum tardiness is given, but a detailed presentation of solution techniques is omitted. 2_{All data defining a problem is available and known with certainty (comp. Lawler et al. (1993, p.}

446)).

(19)

2 SCHEDULING THEORY

The first part of this chapter is organized as follows: We start with an outlining of the necessary basics concerning scheduling problems. Alongside a general scheduling prob-lem, technical terms are introduced and defined. This is supplemented by a literature-based classification scheme enabling a comprising characterization of problem types due to several criteria. An excursion toward complexity theory and a short overview of an-alyzing and solving techniques and approaches completes this section. The part is then closed by a summary of the historical developments and milestones within the area of scheduling theory.

Second, a wide class of solving techniques is introduced - the scheduling rules. The early introduction is motivated by two reasons. First, those rules quite simple in nature -are popular in real life practice,4 and second, they are fundamental for solving simple problems or approximating optimal solutions especially as steps or subparts of larger algorithms.

Remark This chapter provides an overview of basic knowledge concerning machine

scheduling theory. Readers familiar with that field of research may skip it and can continue directly with Chapter 3, which amounts the core of this thesis.

2.1 Basics

Scheduling problems are concerned with “[...] the allocation of resources over time to perform tasks”5. Tasks can be seen as jobs and the resources are typically divided into

processors (machines) and additional resources.6 Thus, scheduling means allocating

scarce production resources (machines) in order to complete tasks (jobs) under certain constraints with the aim to best fulfill specific objectives.7 _{The goal is the determination}

4_{Comp. Domschke et al. (1993, p. 255)} 5_{MacCarthy and Liu (1993, p. 59)} 6_{Comp. Blazewicz et al. (1996, p. 57)}

7_{Comp. Blazewicz et al. (1996, p. 57) and Graves (1981, p. 646)}

(20)

4 Chapter 2: SCHEDULING THEORY

of a schedule “[...] that specifies when and on which machine each job is to be executed [...] ”8.

2.1.1 Notions and definitions

Let n be the number of jobs to be processed, with j ∈ {1, ..., n} denoting a typical job. Alternatively, a job is denoted Jj and the set of jobs to be processed is given by

{J1, ..., Jn}; both notations will be used within this thesis. Let further i ∈ {1, ..., m} be a

certain machine of a set of m machines available. In general, a job can be characterized Remark Note that using the index j for jobs and i for machines is a general convention. Since within this work only problems with one machine are treated, and since it is often necessary to compare several relations between jobs, differing notations are used. Thus, in the course of the main parts of this thesis it might happen that both notations, j or Jj (j = 1, ..., n or Jj = J1, ..., Jn) and i or Ji (i = 1, ..., n or Ji = J1, ..., Jn) are used to

mark the jobs to be processed. by following data:9

• Release time /date (synonymously arrival or ready time / date) rj: The point in

time when a job j is ready to be processed.

• Processing time pji: The time it takes to process job j on machine i.

– Focusing on a set of identical machines (comp. Section 2.1.2.1), the pro-cessing time is independent of the machine (pji= pj).

– Focusing on uniform machines (comp. Section 2.1.2.1), the processing time can be expressed as pji = pj/bi with pj as standard processing time and bi as

processing speed factor of the individual machine.

• Due date dj: The point in time at which job j should be completed.

• Weight (priority) wj: A weight can be added to the jobs to express relative urgency

or priority between them.

• Number of operations gj: For some kind of problems jobs are further subdivided

into different operations Aj1, ..., Ajgj, with gj denoting the number of operations

of job j.

Depending on the release times, a model (problem) is referred to as a static model if the release times of all jobs are zero (rj = 0 ∀j). Problems with varying non zero release

times are called dynamic. 8_{Karger et al. (1997, p. 1)}

(21)

2.1: Basics 5

In contrast to stochastic models - models that assume some of the data to be randomly fluctuating (e.g. defects, break-downs, set-ups, etc. as stochastic data)10 - a model is deterministic if all data defining a problem is available and known with certainty.11 Since in context of this work only deterministic models are considered, the following classification scheme is limited to such problems.

Most of the scheduling models are restricted by some recurring basic assumptions. These are relaxed under certain instances but cover numerous of the treated problems. The most frequent assumptions appearing in the literature shall be introduced:12

• Machine break-downs are neglected, thus a machine is always available.

• A machine cannot process more than one job at a time. Resources (machines) fulfilling this property are referred to as disjunctive.

• Each job cannot be processed by more than one machine at a time.

• Set-up times are not treated separately but included in the processing times.

2.1.2 Classification

Motivated by the vast number of scheduling problems, a general classification scheme attracted attention. Based on a work of Graham et al. (1979), this scheme has become widely accepted and represents the standard notation system in literature. Scheduling problems are characterized by parameters and idiosyncratic instances alongside the three dimensions of the tripel [α|β|γ] (“three-field notation”), with:

• α denoting the machine environment,

• β describing job and resource characteristics, • γ denoting the optimality criterion.

Following sections are dedicated to the description of the various instances of the three dimensions. They shall be used as kind of reference work.

2.1.2.1 Machine environment

The dimension characterizing the machine environment can be subdivided into two pa-rameters, α = α1, α2, with:

10_{Comp. Domschke et al. (1993, p. 398)} 11_{Comp. Lawler et al. (1993, p. 446)}

(22)

• α1 describing the types of machines used or their arrangement, respectively.

• α2 describing the number of machines or the number of processing steps,

respec-tively.

Machine types and arrangements Focusing on the types of machines used, i.e.

parameter α1 ∈ {◦, P, Q, R, O, F, J} ,13 one has to distinguish between parallel and

dedicated processors. In the first case, each machine performs the same operation and in the latter each machine is specialized for performing a different operation.14 _Hence,

we differentiate between jobs consisting of only one operation and jobs embracing more than one. The simplest special case of one processor and one operation leads to single machine scheduling problems.15

Remark ◦ represents the “empty” symbol. “Empty” parameters or instances are

usually omitted in the three-field notation.

• One processor, one operation:

– α1 = ◦: Single processor; only one machine is available for processing jobs.

• Parallel processors, one operation:

– α1 = P : Identical processors; there are m identical machines available with

identical processing speed. Thus, the processing time is machine-independent (pji = pj).

– α1 = Q: Uniform processors; there are m machines available but with

indi-vidual processing speed bi (processing speed factor). The processing time of

a certain job depends on the machine (pji = pj/bi) but not on the job.

– α1 = R: Unrelated processors; there are m machines available but processing

speed is both, machine- and job-dependent. • Dedicated processors, more than one operation:

– α1 = O: Open shop; there are m dedicated machines available. The jobs do

not follow specified flow patterns through the machines, but each job has to seize each machine exactly once. Hence, the number of machines equals the number of operations (gj = m).

– α1 = F : Flow shop; there are m dedicated machines available. All jobs have

identical flow patterns, and each job has to seize each machine exactly once.

Hence, the number of machines equals the number of operations (gj = m).

13_{The notation for the instances varies slightly within the literature. We refer to Blazewicz et al. (1996).} 14_{Comp. Blazewicz et al. (1996, p. 57)}

(23)

2.1: Basics 7

– α1 = J : Job shop; there are m dedicated machines available. Each job has

its individual flow pattern. A job can seize all machines, can skip certain machines, as well as certain machines can be seized more than once.

Machine number Parameter α2 ∈ {◦, m} describes either the number of machines,

in case of parallel processors and one operation, or the number of processing steps, in case of dedicated processors with more than one operation.

Overview - machine environment classification Table 2.1 gives a summary

concerning the different parameters’ instances describing the machine environment:

one processor, one operat

ion

Single

processor - Only one machine available

- m identical machines available at a certain stage - Each job seizes only one of these machines - Identical processing speed for each machine - m machines available at a certain stage - Each job seizes only one of these machines - Machines differ in their processing speed

- Processing speed dependent on machine but independent of job

- m machines available at a certain stage - Each job seizes only one of these machines - Machines differ in their processing speed - Processing speed dependent on machine and job - No specified flow pattern for any job

- Each job must seize each machine once - Identical flow patterns for each job - Each job must seize each machine once - Individual flow pattern for each job

- Machines can be skipped or seized more than once Uniform

processors

- Number of processors / processing steps equals m - Number of processors / processing steps arbitrary

Number of processors (machines) used parallel processors, one operat ion Job shop system

PROCESSOR (MACHINE) ENVIRONMENT:

dedicat ed processors, more t han one operat

ion _{Flow shop}

system Identical processors Unrelated processors Open shop system Type of processors (machines) used 2 1,α α α= o = 1 α P = 1 α R = 1 α O = 1 α F = 1 α J = 1 α o = 2 α m = 2 α } , , , , , , { 1∈ oPQROF J α } , { 2∈ om α Q = 1 α

Table 2.1: Machine environment classification

2.1.2.2 Job and resource characteristics

Since the parameters for characterizing the attributes and specifications of jobs and additional resources vary slightly between different authors, in accordance with Dom-schke et al. (1993) we use ten different parameters β = β1, ..., β10.16 The meanings of

(24)

these parameters are presented shortly, their instances are outlined in Table 2.2 at the end of this section.

• β1 ∈ {n, ◦}: Number of jobs; the number of jobs to be processed is either arbitrary

(◦) or constant (n).

• β2 ∈ {pmtn, ◦, no wait}: Preemption; preemption of a job while being processed

on a machine, or between two consecutive machines in a sense of waiting time, can be allowed or permitted.

• β3 ∈ {prec, tree, ◦}: Precedence constraints; the order of how to process jobs can

be independent, or precedence constraints must be taken into consideration. • β4 ∈ {rj, nj, ◦}: Release times (heads) and / or follow-up times (tails); processing

of a job cannot begin before its release time (rj), and - in case of jobs consisting of

several operations - it might take a certain follow-up time (nj) after finishing one

operation before a job is completed or its subsequent operation can be started. • β5 ∈ {pji, ◦}: Processing times; jobs / operations might be restricted to certain

processing time constraints (e.g. all processing times are equal (pj = p ∀j) or

bounded (pmin ≤ pj ≤ pmax ∀j)), or the processing time is arbitrary.

• β6 ∈τjki , ◦ : Set-up times; sequence-dependent set-up times between two defined

jobs on a certain machine might be taken into consideration. τ_jki denotes the set-up time between jobs j and k on machine i.

• β7 ∈ {res λσρ, ◦}: Resource constraints; besides the machines, additional scarce

resources (manpower, additives) might be integrated leading to further constraints. • β8 ∈ dj, ◦ : Deadlines; deadlines mark the latest point in time at which a job

is accepted to be finished. The terms due date and deadline might sometimes be used as synonyms. To differentiate: A due date marks the point in time a job should be finished (otherwise typically penalty costs occur), whereas a job must necessarily be finished before its deadline (otherwise the schedule is not feasible). • β9 ∈ {gj, ◦}: Number of operations per job; in case of problems with dedicated

machines, the number of operations per job might be restricted (e.g. gj = c or

gj ≤ c).

• β10 ∈ {κ, ◦}: Storage capacity constraints; in case of problems with dedicated

machines, the storage capacity of a machine for finished / or semi-finished jobs waiting to be processed on the next machine might be limited.

Overview - job and resource characteristics Analogical to the previous section,

an overview is given in Table 2.2 summing up the job and resource characteristics and explaining the instances of the parameters in detail.

(25)

2.1: Basics 9

Number of resource types Number of resource types arbitrary

With:

Availability of each resource type per time unit as vector

Availability arbitrary

Resource requirement of job j per time unit as a vector

Resource requirements arbitrary

JOB AND RESSOURCE CHARACTERISTICS:

No set-up times

Sequence-dependent set-up times considered Processing times restricted (e.g. pji=p= const) Processing times arbitrary

Follow-up time differs among jobs Ready time differs among jobs

All ready times zero; all follow-up times zero No precedence constraints

Precedence constraints in form of a tree Number of jobs arbitrary

Number of jobs equals n

Number of operations arbitrary

represents the storage capacity for machine i for finished / semi-finished jobs waiting to be processed on the subsequent machine

General precedence constraints (j,k ): job j is predecessor of job k

No preemptions and no waiting time permitted Preemption not permitted but waiting time between finishing one job and starting it at the consecutive machine allowed

Preemption of a job on a machine permitted

Infinite storage capacity for each machine No additional resource constraints Deadline differs among jobs

Number of operations per job restricted No deadlines assumed Number of jobs Preemption Precedence constraints Ready times (heads) and

follow-up times (tails)

Number of operations per job

Storage capacity constraints Processing times Set-up times Additional resource constraints Deadlines ra = σ o = σ o = ρ ) ,..., (ra1 raπ ra= n = 1 β o = 1 β pmtn = 2 β o = 2 β wait no = 2 β prec = 3 β tree = 3 β j r = 4 β j n = 4 β o = 4 β ji p = 5 β o = 5 β i jk τ β6= π λ= o = λ λσρ β7 =res } , { π λ∈ o )} ( , {o rb j ∈ ρ j g = 9 β o = 9 β κ β =10 } , { 1∈ no β } , , { 2∈ pmtn o nowait β } , , { 3∈ prec tree o β } , , { 4∈ rj nj o β } , { 5∈ pjio β } , { 6 o i jk τ β ∈ } , { 7 λσρo β ∈ res } , { 8∈ dj o β } , { 9∈ gj o β } , { 10 κ o β ∈ 10 1,...,β β β = o = 10 β o = 3 β o = 6 β o = 8 β o = 7 β } , { rao ∈ σ ρ =rb( j) ) ) ( ,..., ) ( ( ) (j rb j1 rb j π rb = j d = 8 β i κ

Table 2.2: Job and resource classification

2.1.2.3 Optimality criteria

Scheduling problems are investigated from different perspectives. Performance mea-sures are common terms enabling an assessment of the performance of a schedule’s performance. They provide a basis for improvement. These improvements aim at a certain objective (or a set of hierarchically ranked objectives); the optimality crite-rion γ. Let z denote a performance measure, three main types of optimality criteria (γ ∈ {zmax,P zj, z#}) are typically differentiated between, with:17

(26)

• zmax: Minimizing the maximum value of a certain performance measure,

• P zj: Minimizing the sum of a certain performance measure. Minimizing the

weighted sum, i.e. P wjzj, is subsumed as a special case. z denotes the average

of a measure, which is nothing else than adding constant weights wj = (1/n), j =

1, ..., n.

• z#: Minimizing the absolute number of jobs fulfilling a certain condition.

Mini-mizing the weighted sum of those jobs is again subsumed.

Instead of adding simple weights to the performance measures, it might be useful to construct more complex objectives via nonlinear functions of the performance measures: P fj(zj). This is done for instance to express a non-linear development of

penalty-payments.

Further, Domschke et al. (1993) group the objectives into three classes:18 • Flow time related objectives,

• capacity related objectives, • lateness related objectives.

Objectives do not necessarily have to aim at only one criterion; it is also possible to construct so called “[...] multiple criteria objectives [...] ”19_:20

• either as composite objectives by adding weights (e.g. z = wαzα+ wβzβ),

• or by introducing a hierarchical relationship (e.g. min zα subject to zβ = zβ∗).

Before we introduce the most common optimality criteria, we briefly outline the under-lying performance measures:

• Completion time Cj: Point in time at which job j is completed.

• Makespan Cmax = max {Cj|j = 1, ..., n} (also schedule length): Point in time at

which all jobs belonging to a defined schedule are completed .

• Flow time Fj = Cj − rj: Span of time between a job’s release date and its

com-pletion time.

• Waiting time Wj = Fj− pj: Waiting time of an already released job j before being

processed on the machine. • Idle time Ii = Cmax−

Pn

j=1pji: Span of time a certain machine i is idle throughout

the makespan.

18_{Comp. Domschke et al. (1993, p. 261)} 19_{Gupta and Kyparisis (1987, p. 210)} 20_{Comp. Gupta and Kyparisis (1987, p. 210)}

(27)

2.1: Basics 11

• Lateness Lj = Cj−dj: Lateness occurs if a job does not meet its due date. Thereby,

a job can be completed too early (earliness) or too tardy (tardiness). – Earliness Ej = max {0, dj− Cj}

– Tardiness Tj = max {0, Cj− dj}

– Number of tardy jobs T#or P Uj =

Pn j=1Uj, with: Uj =    1, if Tj > 0, 0, if Tj = 0.

Remark “Lateness” and “tardiness” are often used as synonyms by many authors.

But following above’s definition, “lateness” only indicates the deviation of a job’s com-pletion time from its due date, whereas “tardiness” is restricted to a positive deviation.

Overview - optimality criteria classification Referring to the above mentioned

performance measures, Table 2.3 gives an overview of the main optimality criteria used when dealing with scheduling problems.

Maximum time Total time Total weighted time* Number Weighted number Completion Time: Flow time: Waiting time: Make-span: Idle-time: Lateness: Tardiness: or or and

This case is referred to as:

Flow time related objectives Capacity related objectives Lateness related objectives

OPTIMALITY CRITERIA / OBJECTIVES (PERFORMANCE MEASURES)

*Annotation: The average value of a performance measure is a special case of the weighted sum with

Minimizing the maximum value of a certain performance measure Minimizing the (weighted) sum of a certain performance measure* Minimizing the (weighted) number of jobs fulfilling a certain condition

General notation j C j j j C r F = − j j j F p W = − } { max max j j C C = j j j C d L = − } { max max j j C C = } { max max _j Fj F = } { max max j j W W = } { max max _j Cj C = } { max max i i I I = } { max max j j L L = } { max max j j T T =

∑

= = n j j C C 1

∑

= = n j j F F 1

∑

= = n j j W W 1

∑

= = m i i I I 1

∑

= = n j j L L 1

∑

= = n j j T T 1

∑

= = n j j j w C w C 1

∑

= = n j j j w F w F 1

∑

= = n j j j w W w W 1 ∑ = = m i i i w _w_I I 1

∑

= = n j j j w L w L 1

∑

= = n j j j w T w T 1

∑

Uj

∑

= = n j j U T 1 #

∑

wjUj

∑

= = n j j j w U w T 1 # max z = γ γ=

∑

zj γ=z_#

∑

= z_j γ max z = γ # z = γ

∑

∈(zmax, zj,z#) γ 0 0 = = j j if T U 0 1 > = _j j if T U . ,..., 1 ) / 1 ( n j n w_j = ∀ = . ) / 1 (

∑

= n zj z } , 0 max{ j j j C d T = −

∑

= − = n j ji i C p I 1 m ax

(28)

2.1.3 Complexity theory

Mathematical programming problems are typically solved by algorithms. Depending on the problem type, the solving algorithms consist of a varying number of computational steps. Neglecting the speed-performance of the computer used and expressing time by counting computational steps,21 _{one can say that different types of problems need}

different solution time. The complexity theory analyzes the maximum computational effort for solving problems underlying a worst case scenario, i.e. the representation of the problem’s input data that demands the most effort, and it establishes a classification scheme.22

Starting with some required definitions: Let n characterize the size of a problem - the size of the input necessary to characterize the problem - and E(n) a function describing the computational effort of an algorithm to translate the input of size n into an output. Let further abstract from the precise form of the function E(n) and focus only on its

asymptotic order f (n).23 _{The computational effort E(n) of an algorithm is of the}

order f (n) - one writes O(f (n)) in this case, which is also referred to as complexity O(f (n)), instead of computational effort O(f (n)) - if:

There exists a c ∈ <+ and a n0 ∈ <+ such that for every n ≥ n0 the computational

effort E(n) is not larger than cf (n), i.e. E(n) ≤ cf (n).

The computational effort is characterized as polynomial (the algorithm is polynomially bounded) if f (n) is a polynomial function of n; and therefore O(f (n)) = O(nk_{), with}

k being some constant. Otherwise, the effort is called exponential.24 _{The notation is}

referred to as “big-O notation”.25

The complexity theory is based on an analysis of what is called the recognition versions (synonymously decision version) of optimization problems. Hence, we first differentiate between both terms:26

• Optimization problem: Optimization problems aim at finding the optimal solu-tion for a problem representasolu-tion (e.g. “how should a given set of jobs be sequenced to minimize the number of tardy jobs ?”).

21_{Comp. Dasgupta et al. (2006, p. 15)}

22_{Comp. Domschke and Drexl (2005, p. 125 et seq.)} 23_{Comp. Lawler et al. (1993, p. 448)}

24_{For this section comp. Domschke and Drexl (2005, p. 125) and Winston and Venkataramanan (2003,}

p. 800 et seq.)

25_{Comp. Dasgupta et al. (2006, p. 15)}

(29)

2.1: Basics 13

• Recognition / decision version: Optimization problems can be rearranged in such way that the solution is a “yes” or “no” answer (e.g. “is there a schedule for a given set of jobs that generates a number of tardy jobs less than a predetermined number - say |L| ?”).

If the recognition version of the problem is answered with “yes”, the underling instance is called a certificate (for the above given example a certificate would be the schedule that achieves a number of tardy jobs less than |L|).

Given such certificate for a problem, this problem belongs to the so called NP class if the certificate can be verified by an algorithm with polynomial computational effort (bounded by polynomial time). This assumption leads to following classification for recognition problems:27

• NP class of problems: NP stands for nondeterministic polynomial time. The class comprises all problems for which a certificate can be checked by an algorithm with polynomial computational effort. The NP problem space comprises a rich class of mathematical problems and can be subdivided into three regions:

– P class of problems: The P class comprises all recognition problems that can be solved with polynomial computational effort.

– NP -complete class of problems: For problems belonging to the NP -com-plete class there is no yet-known algorithm that guarantees a solving with polynomial computational effort. Any problem of the NP -complete class can be transformed in polynomial time to any other problem of the same class. Thus, finding a method that enables solving one NP -complete problem in polynomial time would guarantee that all problems in the class are polyno-mially solvable.

– Nondeterministic region / open region: This class “[...] contains prob-lems, for which polynomial solution algorithms are possible”28 and those that remained open.

In complexity terms, both, the optimization problem and the recognition version, are equivalent. Hence, solving one in polynomial time assures that the other can be solved with polynomial effort as well.29

When expanding the view by including optimization problems, one distinguishes between two classes:30

27_{Comp. Domschke et al. (1993, p. 48)}

28_{Winston and Venkataramanan (2003, p. 803)} 29_{Comp. Winston and Venkataramanan (2003, p. 802)} 30_{Comp. Domschke et al. (1993, p. 50)}

(30)

• Class of polynomially solvable problems (analogically called class P ): The problems within this class can all be solved with polynomial computational effort. • Class of NP -hard problems: For problems of the NP -hard class no known polynomial bounded algorithm exists that guarantees solving. If such an algorithm existed for one problem, all problems of the class could be solved with polynomial effort. For the hard problems algorithms tend to require exponential computational effort; at least no polynomially bounded algorithm is known yet.

The above mentioned differentiation is more general since both, optimization and recog-nition problems, are included.

In contrast to problems of the NP -hard class, which are literally “hard” to solve, poly-nomially solvable problems are also called “easy” or “efficiently solvable”.31 _{But even}

within the NP -hard class, some problems exist which in practice can be solved quite efficiently. Their algorithms are polynomially bounded by two variables, namely the problem’s seize and the value of some input data itself. Consider a scheduling prob-lem, the complexity might depend on the number of jobs n and the sum of processing times P pj for instance. Due to their idiosyncrasy, these problems are referred to as

pseudopolynomial, but the underlying solving methods should not be mistaken for polynomial methods since they still are a subset of the exponential algorithms.32

Table 2.4 represents some common examples of the complexity of polynomially solv-able problems (of the underlying polynomial algorithms, respectively) and of NP -hard problems (of the underlying exponential algorithms, respectively).

n f(n) n log(n) 10 26,02 84,95 200 n2 100 400 2500 10000 n3 1000 8000 125000 1000000 n5 100000 3200000 312500000 1E+10 n10 1E+10 1,024E+13 9,7656E+16 1E+20

2n 1024 1048576 1,1259E+15 1,2677E+30 n! 3628800 2,4329E+18 3,0414E+64 9,333E+157 5n 9765625 9,53674E+13 8,8818E+34 7,8886E+69 10n 1E+10 1E+20 1E+50 1E+100 Complexity and growth rate for some polynomial and exponential algorithms

Complexity (O(f(n))

Polynomially

solvable problems

NP-hard _problems

(exponentially

solvable) Actual computational effort depending on problem size

10 20 50 100

Table 2.4: Complexity and growth rate for some polynomial and exponential algorithms (Comp. Winston and Venkataramanan (2003, p. 801))

31_{Comp. Gupta and Kyparisis (1987, p. 210)}

(31)

2.1: Basics 15

It is further shown how the actual computational effort develops depending on the size of the problems.

Just in order to sensitize to the seize of and proportion between the different complexity classes: Already in the 1980s, a computer program was used to track deterministic machine scheduling problems and record them according to their complexity. At this time out of 4536 problems investigated only 9 % were classified as “easy” and 82 % as “hard”, the remaining 9 % were still open.33

Finally, Figure 2.1 shows the relationship between the different classes.

P NP-complete nondeterministic region NP-hard NP problem space

Figure 2.1: NP problem space (Comp. Domschke et al. (1993, p. 49) and Winston and Venkataramanan (2003, p. 803))

As mentioned above, the NP space is divided into three subsets: NP -complete, P , nondeterministic region. On the one hand, problems belonging to the NP -complete space are not likely to be solvable in polynomial time. Thus, these problems also represent NP -hard problems. On the other hand, a NP -hard problem does not necessarily have to belong to the NP -complete region since it might not belong to the NP -space at all. Thus, the NP -complete space is a subset of the NP -hard space. Class P comprises all recognition problems that are guaranteed to be solvable by a polynomial bounded algorithm. Each recognition version of optimization problem

of the class of polynomially solvable problems is part of class P .34

33_{Comp. Lenstra and Rinnooy Kan (1984, p. 255) and especially Lageweg et al. (1982)} 34_{Comp. Domschke et al. (1993, p. 50)}

(32)

2.1.4 Analyzing and solving scheduling problems

Since numerous techniques for analyzing and solving scheduling problems under different constraints are known, a complete overview and description is cumbersome. The aim of this section is to introduce a general scheme of how to approach scheduling problems, to roughly classify the most common solving techniques and to give some examples of certain frequently used methods.

The next section then provides a closer description of those techniques addressed within this thesis.

Scheduling problems (complexity analysis)

Easy problem NP-hard problem

Relaxation Exakt enumerative algorithms Approximation algorithms Efficient optimal methods

Heuristics Enumerative optimal methods

Figure 2.2: Analysing scheduling problems (Comp. Blazewicz et al. (1996, p. 65) and MacCarthy and Liu (1993, p. 64 et seqq.))

Figure 2.2 shows a schematic approach of how to analyze scheduling problems proposed by Blazewicz et al. (1996). The three typical groups which - according to MacCarthy and Liu (1993) - comprise most of the solving methods are outlined. This figure serves as guideline for the following discussion.

Referring to the above mentioned groups of solving methods, it is distinguished be-tween:

• Efficient optimal methods: This group includes the methods / algorithms typ-ically used for the class of polynomially solvable problems. Thus, they guarantee an optimal solution within polynomial time even for large problems. Most of the optimal algorithms are dedicated only to a specific kind of problem or to a rather

(33)

2.1: Basics 17

small class. Hence, they are rare and applicable only for a few and quite funda-mental issues. Even if such methods exist, it might sometimes be more useful to rely upon other approaches, like good heuristics, if the exact optimal algorithm is of too high complexity.

• Enumerative optimal methods: Enumerative methods typically use a partial enumeration of the set of all solutions that are possible.35 _{Methods of implicit}

enu-meration variety “[...] consider certain solutions only indirectly, without evaluating them explicitly.”36 _{Representatives are:}

– Dynamic programming – Branch and Bound (B&B)

Both are exponential in nature but promising mainly for problems of smaller size. Especially dynamic programming algorithms can often be constructed to obtain pseudopolynomially bounded approaches.

• Heuristic methods: Heuristics are kind of rule-of-thumbs techniques which ap-proximate the optimal solution but cannot guarantee its finding in all the cases.37 They are applied for both, solving specific problems to optimality and providing a fast and simple but acceptably good solution for hard problems.38 _{Heuristics are}

typically judged by their “goodness” of approximation; their performance, often in a worst case scenario, compared with the optimal solution (if known) as ratio or difference. Heuristics with analytically evaluated accuracy are referred to as ap-proximation algorithms.39 In this context, a ρ-approximation algorithm generates a result of at most ρ times the optimal value in polynomial time.40 Some heuristic algorithms and strategies for scheduling problems are:41

– Relaxation based heuristics – Scheduling rules / priority rules – Simulated annealing

– Tabu search

– Genetic algorithms

The above mentioned heuristics represent only a small number of examples. A systematic classification can be found in Zanakis et al. (1989). Concerning theory and application of metaheuristics42_{, Osman and Laporte (1996) provide an}

exten-35_{Comp. MacCarthy and Liu (1993, p. 64)} 36_{Blazewicz et al. (1996, p. 32)}

37_{Comp. Winston and Venkataramanan (2003, p. 804)} 38_{Comp. Karger et al. (1997, p. 2)}

39_{Comp. Blazewicz et al. (1996, p. 35 et seq.)} 40_{Comp. Lawler et al. (1993, p. 449)}

41_{Comp. for example ˇ}_Sori´_{c (2002, p. 14 et seqq.) and Jones and Rabelo (1998)} 42_{For definition and examples comp. Section 2.1.5.3 on page 23}

(34)

sive bibliographic survey. Further, a textbook by Michalewicz and Fogel (2004) is worth mentioning giving an introduction of problem solving via heuristics.

Focusing on the general approach to analyze scheduling issues, it becomes obvious that handling scheduling problems is strongly connected with the knowledge of the problem’s complexity class, since it is the belonging to one of the above mentioned classes that determines the choice of the general kind of method to solve / approach the problem.43 Starting with an examination of the complexity, the problem is either “easy” or not polynomially bounded and thus NP -hard.

For the first - the easy problems - algorithms are applicable to generate an optimal solution. But notwithstanding, their usefulness might be questioned if the computational complexity of the underlying algorithm is indeed polynomial but of too high order. In this case good heuristics are a promising alternative.

For the latter - the hard problems - no polynomially bounded algorithm is likely to exist. Under certain conditions enumerative approaches - sometimes pseudopolynomially bounded - should be considered if applicable and of acceptable effort. Otherwise, one also has to revert to heuristic methods. In this case choosing the best performing method attracts attention.44 _{Relaxing the constraints and reducing the original problem to an}

easier one is a promising strategy amongst others.

Finally, it is worth noting that the above mentioned differentiation is of very rough nature, neglecting many of the techniques’ intrinsic singularities. Furthermore, assigning a solving method to one of the above mentioned classes is never of dogmatic nature but problem-dependent instead. Therefore, the different classes are overlapping. What is a heuristic for one type of problem might be an optimal method for solving a different type.

2.1.5 Operations Research fundamentals

Even though the reader is expected to posses operations research fundamentals, this section outlines some solving techniques that are addressed frequently within this the-sis work. Two basic enumerative solving methods, namely dynamic programming and branch and bound, are presented; both not in detail, however, the main features are re-minded. Additionally, Section 2.1.5.3 gives a short overview of emerging heuristics.45

43_{This section is mainly based on Blazewicz et al. (1996, p. 62 et seqq.).} 44_{Comp. the discussion above within the description of heuristic methods}

45_{Dynamic programming and branch and bound methods are detailed for instance in Domschke and}

(35)

2.1: Basics 19

2.1.5.1 Branch and bound (B&B) basics

Even complex scheduling problems can be formulated as an integer linear programming problem. Lawler and Wood (1966) emphasized already in 1966 the importance of branch and bound procedures (in the following referred to as B&B) for solving constrained optimization problems especially in the area of integer linear programming and travel-ing salesman problems. Generally, B&B methods decompose a complex problem into

multiple subproblems and utilize known methods to solve the “easier” subproblems.46

Another advantage of B&B approaches is that, although the worst-case complexity is exponential, especially in situations where the search for a solution takes a lot of time the B&B procedure can be aborted at any stage using the best solution known so far.47

The name branch and bound denotes that this method is based on two main steps. The already mentioned problem decomposition is the result of the branching procedure leading to subproblems which are:

• mutually exclusive and exhaustive subproblems of the original, • partially solved problems of the original,

• smaller problems than the original.48

Since decomposing can be continued, i.e. a problem is branched and its subproblems are further decomposed, a tree-like form is obtained. Figure 2.3 gives an example.

Figure 2.3: Branching tree - example (Lawler and Wood (1966, p. 702))

The other main procedure is bounding which calculates lower and upper bounds and fathoms a branch if necessary. If one considers a minimizing objective function in an

46_{Comp. Lawler and Wood (1966, p. 699 et seqq.)} 47_{Comp. ˇ}_Sori´_{c (2002, p. 13)}

(36)

integer linear programming problem, for each subproblem a lower bound (noted as LB ) might be calculated by ignoring integer constraints, allowing those variables to take real values. This kind of relaxation is known as linear programming relaxation

(LP-relaxation).49 _{Additionally, an initial upper bound (noted as UB ) is computed by a}

fast heuristic or is arbitrarily determined to be infinite. During the algorithm, the current best LB obtained by a solution which feasible to the subproblem as well as to

the underlying main problem becomes the new UB.50 _{At each node within the search}

tree it is checked if the current branch should be partitioned further. If a branch is no more considered in the ongoing algorithm, it is said to be fathomed. Obviously, due to not partitioning the fathomed branches any further, the enumeration process can be curtailed.51 Following reasons cause a branch to be fathomed:52

• No feasible solution is available for the relaxation.

• The LB received by relaxation is larger or equal than the current UB.

• The relaxation’s solution is feasible for the subproblem and the underlying main problem, and its objective value is even better than the current UB. In the latter case, the LB becomes the new UB.

Due to the branching process, a B&B algorithm maintains a list of unsolved problems. They are part of the branching tree but are neither fathomed yet nor eliminated by a dominance rule. Dominance rules are rules for speeding up the algorithm by curtailing the branching tree. They are not discussed at this place, even though they will be considered in later discussions. The mentioned subproblems are sometimes called active problems, and in order to find an optimal solution they attract attention.53 _{A policy}

(respectively a decision rule) is needed in order to choose from the list of unsolved, active problems. Most common policies, in the case of a minimization problem, are the minimum-lower-bound-rule (noted as MLB rule) and the last-in-first-out-rule (noted as LIFO ). The MLB rule always branches from the subproblem with the smallest lower bound currently available. The LIFO rule continues with the latest problem created by branching. The benefit of the LIFO rule is that compared with the MLB rule -mostly less computational storage is needed. The MLB rule, on the other hand, typically involves less computational effort.54 55

49_{Of course, other kinds of relaxations exist, like for instance Lagrangean relaxation or surrogate}

relax-ation. Their underlying ideas are elucidated when necessary in the course of this thesis.

50_{Comp. Domschke and Drexl (2005, p. 132 et seq.)} 51_{Comp. Baker (1974, p. 57)}

52_{Comp. Domschke et al. (1993, p. 44)} 53_{Comp. Baker (1974, p. 58 et seqq.)}

54_{Comp. Lawler and Wood (1966, p. 712 et seqq.)} 55_{Comp. Domschke and Drexl (2005, p. 136 et seq.)}

(37)

2.1: Basics 21

2.1.5.2 Dynamic programming

The contribution of Bellmann (1954) is seen as pioneer work. Dynamic programming is a powerful algorithm paradigm. Problems are solved by identifying smaller subproblems and by solving one subproblem after the other, starting with the smallest and using the answers to the small problems until the initial problem is solved.56

An example of Baker (1974) is used to outline the characteristics of dynamic program-ming procedures: 57

• A set J of j = 1, ..., n jobs is to be scheduled on a single machine. S denotes a subset of J and S its complement, i.e. the set of jobs not contained in S. Schedules are to be constructed such that all jobs in S precede every job in S.

• Cj is the completion time of job j and C(S) the total time required to process all

jobs in S.

• Let z be a performance measure with an additive structure like Pn

j=1gj(Cj), with

gj(Cj) being the marginal contribution of job j to the overall cost in dependency

of its completion time Cj. If z is the number of tardy jobs, gj(Cj) would be 1 if

job j is scheduled tardy and 0 otherwise. • The aim is to minimize the value of z.

Most applications of dynamic programming have following characteristics - described alongside the introduced example - in common:58

1. The initial problem can be divided into several stages. A decision is required at each stage. Considering the example, a stage k could be characterized by the size of the subset S, i.e the number of jobs to schedule at this stage. Hence, in the first stage the task consists of scheduling one job, in the second of scheduling two jobs and so on.

2. Each stage has a number of associated states, the information needed at any stage to make an optimal decision. In the mentioned example the states are the possible subsets S. If J consists of four jobs j = 1, ..., 4 and one looks at the second stage, i.e a pair of two jobs is to be considered, the states are:

{1, 2} , {1, 3} , {1, 4} , {2, 3} , {2, 4} , {3, 4} .

56_{Comp. Dasgupta et al. (2006, p. 170)} 57_{Comp. Baker (1974, p. 45 et seqq.)}

(38)

3. Decisions have to be made in any stage. Decisions describe how the state at the current stage is transformed into the state at the next stage. In our example a decision is simply the subsequent job to be chosen in next stage’s S, determining the next states.

4. Principle of optimality: Given the current state, the optimal decision for each of the remaining stages must not depend on previously reached states or previously made decisions. Keeping in mind that a sequence is constructed such that the jobs belonging to subset S precede every job in subset S (see Figure 2.4): If such a sequence is optimal, the principle of optimality requires that subset S must be scheduled optimally, independent of whatever the schedule of S looks like. S is only forced to be scheduled after C(S); otherwise the jobs’ processing times would overlap. Thus, when scheduling set S at the k’th stage, it is completely irrelevant how this stage was reached.

5. Since the overall problem consists of several stages, there must obviously be a re-cursion, that relates the costs or rewards from one stage to the other. Let G(S) be the minimum cost realizable for the jobs in set S subject to the constraint that no job in S starts prior to C(S). The recursion looks as following:

G(S) = min

j∈S



gj(C(S) + pj) + G(S − {j})

| {z }

refers to previous stage



.

In order to calculate the value for G(S) for each particular subset of k jobs at the k’th stage, one needs to know the value for G(S − {j}) for subsets of size k − 1 at the k − 1’th stage.

job job

_…

job job j

_…

job t ) (S C p j set (S−{j}) set S set S

Figure 2.4: A sequence for purposes of dynamic programming (Comp. Baker (1974, p. 45))

Focusing on a certain state, for every job in S one schedules this particular job prior to the others (directly after C(S)), calculates g(C(S) + pj), uses the information

from the previous stage by adding G(S − {j}) (since the set (S − {j}) is now the one scheduled at the end of the sequence), and keeps track of the minimum value

(39)

2.1: Basics 23

(i.e. G(S)) of the best obtained sequence for this certain state. The procedure’s start is marked by G(∅) = 0. The optimum value is obtained by G(S = J ). Tracking each state’s minimum, the optimal sequence can be reconstructed back-ward from G(J ).59 60 _{Subsuming, at each stage one schedules one job j (j ∈ S)}

directly at C(S) such that the termgj(C(S) + pj) + G(S − {j}) is minimized.

The illustrated example is capable of solving the problem [1||P Uj]. With increasing

complexity, the dynamic programming approach increase in complexity as well.

2.1.5.3 Heuristics and metaheuristics

Generally, scheduling problems belong to the broad class of combinatorial problems. Branch and bound and dynamic programming are enumerative approaches and solve scheduling problems to optimality. For some problems even polynomially bounded op-timization algorithms exist. However, not for all scheduling problems, especially the NP -hard problems, they are likely. In such cases, suboptimal heuristic algorithms that do not guarantee to find an optimal solution are promising.61 These heuristic approaches can also be embedded into B&B procedures to generate an initial suboptimal, however feasible, solution.

Many heuristics build up a solution piece by piece, always choosing the next piece that offers the most obvious and immediate benefit. Such heuristics are myopic and called

greedy algorithms.62 Due to that myopia, they tend to get trapped in local optima

and fail to find the global optimum.63 _{To overcome this drawback, local search}

heuris-tics are designed as universal global optimization methods that guide lower-level local decision rules to their best outcome. These methods comprise several metaheuristics which allow for an adaption to a very general class of computational problems - and might be described as strategies with knowledge-engineering and learning capabilities to improve and quicken the optimization process.64 _{Such heuristics often mimic natural}

adaptive systems and try to avoid local optima by accepting solutions that may not be an improvement or by considering several solutions at a time.65 In the following some basics concerning different metaheuristics are given:

59_{Comp. Winston and Venkataramanan (2003, p. 756 et seq.)} 60_{Comp. Baker (1974, p. 46)}

61_{Comp. Blazewicz et al. (1996, p. 35)} 62_{Comp. Dasgupta et al. (2006, p. 137)}

63_{Comp. Winston and Venkataramanan (2003, p. 804 et seq.)} 64_{Comp. Blazewicz et al. (1996, p. 37)}

Single Machine Scheduling with Tardiness Involved Objectives : A Survey

Link¨

opings Universitet

Institute of Technology

Department of Mathematics

Link¨

oping Studies in Science and Technology. Theses

No. 1117

The k-assignment Polytope and the

Space of Evolutionary Trees

Jonna Gill

Matematiska institutionen

Link¨

opings universitet, SE-581 83 Link¨

oping, Sweden

Link¨

oping 2004

Single Machine Scheduling with Tardiness

Involved Objectives: A Survey

Master-Thesis

LiTH-MAT-EX-2007/09-SE

Andreas Mundt

Thomas Wich

Abstract

Acknowledgements

Contents

List of Figures

List of Tables

Fundamental Symbols

1 INTRODUCTION AND

MOTIVATION

2 SCHEDULING THEORY

2.1 Basics

2.1.1 Notions and definitions

2.1.2 Classification

∑

∑

∑

∑

∑

∑

∑

∑

∑

∑

∑

∑

∑

∑

∑

∑

∑

∑

∑

∑

2.1.3 Complexity theory

2.1.4 Analyzing and solving scheduling problems

2.1.5 Operations Research fundamentals

…

…

_…

_…