All Minimal and Maximal Open Single Machine Scheduling Problems are Polynomially Solvable

(1)

All Minimal and Maximal Open Single Machine

Scheduling Problems are Polynomially Solvable

(2)

Master’s Thesis Operations Research

Supervisor: Prof. Sc.D. B. Goldengorin

(3)

All Minimal and Maximal Open Single Machine

Scheduling Problems are Polynomially Solvable

H.W. Bouma

Abstract

In this thesis, Boolean Linear Programming (BLP) models are presented for three single machine scheduling problems with equal-length jobs and different release dates, and it is proven that they are polynomially solvable. The objec-tive of the first problem, in which preemption is allowed, is to minimize the total weighted completion time. The objective of the other two problems is to minimize the total weighted tardiness. The second problem is preemptive, the third is not. To this date, the complexity status of these problems has remained open. The open complexity status was mentioned by Labetoulle et al. [21] in 1984.

The BLP models are based on the Assignment Problem formulation, which is a well-known polynomially solvable problem in combinatorial optimization. The Assignment Problem can be used to solve many problems, including for example the single machine scheduling problems in which the total weighted tardiness is minimized and in which all jobs have unit processing times and different release dates. In order to solve the three problems mentioned above only preoptimized permutations are incorporated into the Assignment Problem formulation. The proof that the problems are polynomially solvable is based on the notion of Total Dual Integrality.

(4)

(5)

Preface

Since the fifties of the twentieth century Scheduling Theory has been a popular research area. In the early years pioneers came up with algorithms to solve simple job scheduling problems. In the years that followed, many algorithms and heuristics were found to solve both basic and more complicated problems. Nowadays, the complexity status of many basic scheduling problems is known, although there are still some problems with an open complexity status.

In this thesis I will show that three of these open problems are polynomially solvable. Two of the problems are about finding a preemptive schedule in a single machine setting where the jobs have equal processing times and different release dates. The objectives are to minimize the total weighted completion time and the total weighted tardiness, respectively. The third problem is the non-preemptive version of the total weighted tardiness problem. All problems will be modeled as Assignment Problems with side constraints.

The thesis is organized as follows. In Chapter 1 an overview of single ma-chine scheduling problems is given and some basic concepts of computational complexity and Integer Linear Programming are discussed. In Chapter 2 the problems are defined and an informal description of 1|pmtn; pj = 2; rj|P wjCj

is presented which motivates the use of the Assignment Problem formulation. A similar approach is used for the other open problems. Chapter 3 contains a discussion of problems that are modeled as a variation on the Assignment Problem as well. In Chapter 4, the Boolean Linear Programming (BLP) model for the problem 1|pmtn; pj = 2; rj|P wjCj is given and it is proven that the

corresponding system of equations is Totally Dual Integral. This implies that the problem is polynomially solvable. In Chapter 5 these results are generalized to the case pj = p. In Chapter 6 the BLP models are presented for the total

weighted tardiness scheduling problems and it is proven that they are also poly-nomially solvable. In Chapter 7 some computational results are presented and Chapter 8 contains recommendations for future research and a short summary. I wish to thank my supervisor Prof. Sc.D. B. Goldengorin for giving me the opportunity to do this research. He advanced the idea of solving the problem by a model based on the Assignment Problem. I would like to thank him for his support and advice he provided me with during my research. Furthermore, I would like to thank Prof. dr. G. Sierksma, who was willing to be co-assessor of this research project, and Guido Diepen of Paragon Decision Technology for his technical support with AIMMS.

(6)

(7)

List of Figures

1.1 The EDD and optimal schedule for an instance of 1|rj|Lmax. . . 19

1.2 The preemptive WSPT and the optimal schedule for an instance of 1|pmtn; rj|P wjCj. . . 20

3.1 Graphical representation of a special case of the three-dimensional assignment model. . . 37

3.2 Graphical representation of the multidimensional assignment prob-lem for 1|pmtn; pj= 2; rj|P wjCj with n = 3. . . 37

4.1 Schedule S1, where d ∈ {2, 4, 6, . . .}, 0 < λ < 1 . . . 55 4.2 Schedule S2, where d1, d2∈ {1, 3, 5, . . .}, 0 < λ < 1. . . 55 4.3 Schedule S3, where d1, d2∈ {1, 3, 5, . . .}, 0 < λ < 1. . . 56 4.4 Schedule S4, where d1, d2∈ {1, 3, 5, . . .}, 0 < λ < 1. . . 56 4.5 Schedule S5, where d1∈ {2, 4, 6, . . .}, d2, d3∈ {3, 5, 7, . . .}, d2 > d1, d3> d2, 0 < λ < 1. . . 56 4.6 Schedule S6, d1 ∈ {2, 4, 6, . . .}, d2, d3 ∈ {3, 5, 7, . . .}, d2 > d1, d3> d2, 0 < λ < 1. . . 57

7.1 The differences in terms of percentages between the optimal

val-ues of the problems 1|pmtn; pj = p; rj|P wjCjand 1|pj= p; rj|P wjCj. 78

7.2 The differences in terms of percentages between the optimal

(10)

(11)

List of Tables

1.1 Overview of complexity results of problems that are related to

the open problems that are solved in this thesis. . . 26

2.1 The cost matrix W , representing the costs of assigning job parts to time intervals. . . 30

2.2 The cost matrix W , representing the costs of assigning job parts to time intervals whenP wjTj is the objective. . . 32

4.1 The way in which dual variables p, q and s correspond to the rows and columns of the cost matrix W . . . 48

4.2 Cost matrix W adjusted by the dual variables. . . 49

7.1 CPU time in seconds and optimal solutions for the problem 1|pmtn; pj= p; rj|P wjCj, for p = 2. . . 75

7.2 CPU time in seconds and optimal solutions for the problem 1|pmtn; pj= p; rj|P wjCj, with p = 3 and p = 4. . . 76

7.3 CPU time in seconds and optimal solutions 1|pmtn; pj= p; rj|P wjTj, for p = 2. . . 76

7.4 CPU time in seconds and optimal solutions for the problem 1|pmtn; pj= p; rj|P wjTj, with p = 3 and p = 4. . . 77

7.5 CPU time in seconds and optimal solutions 1|pj= p; rj|P wjTj, for p = 2. . . 77

7.6 CPU time in seconds and optimal solutions for the problem 1|pj = p; rj|P wjTj, with p = 3 and p = 4. . . 78

7.7 Optimal solutions for the problem 1|pj= p; rj|P wjCj. . . 78

8.1 The problems that are solved in this thesis and problems that are closely related to them. . . 83

C.1 Instances with 20 jobs and p = 2. . . 97

(12)

(13)

Chapter 1

Introduction

In many manufacturing and service industries planning and scheduling belong to the day-to-day activities. Whether it is about a copy shop holder who needs to determine which order to print first, or the type of aircraft that should be assigned to a particular flight, the decisions made can substantially affect the efficiency or profitability of a company.

Consider for example a copy shop holder, who serves several business clients. Some orders are urgent, while others are not. A report that is just finished and should be presented the following morning has higher priority for a firm than the quarterly staff magazine. The urgency of an order is given by the difference between the deadline of an order and the point in time at which the order actu-ally comes in at the copy shop. This is the so-called time window. Furthermore, each order has a different processing time, depending on its size, its quality etc. Last but not least, each order has a certain weight. When the copy shop holder does not meet a deadline, the client receives a discount based on the amount of delay and the weight of the order. Naturally, urgent and large orders have higher weights than low priority and small jobs. Given all orders, the copy shop holder would like to determine the printing schedule such that the total amount of discount is as small as possible.

Now consider the airline company. It needs to assign airplanes to flights such that none of the flights is canceled. The cost of assigning a certain type of air-craft to a particular flight is known in advance. Each flight is characterized by a departure and arrival time and by the expected number of passengers. Each airplane has a certain capacity. Obviously, it is desirable that an airplane has sufficient capacity to carry all passengers, since otherwise a certain amount of revenue is missed. On the other hand, when there is overcapacity the revenues may not be sufficient to cover the flight’s costs. Given the departure and ar-rival time, the cost of a flight, the expected number of passengers per flight and the revenue per passenger, the airline is interested in assigning its airplanes to flights such that total profits are maximized.

(14)

over fifty years. Pinedo [28] defines scheduling as the allocation of limited re-sources to activities that have to be done over time. This allocation needs to be such that a company optimizes its objectives and achieves its goals. In the examples stated above, the photocopiers in the copy shop and the fleet of the airline company are the resources. The activities are the orders and the flights. The objectives are to minimize the total amount of discount and to maximize profits, respectively.

Scheduling techniques rely heavily on mathematical models, exact algo-rithms and heuristics. For many problems efficient algoalgo-rithms have been found to solve the problems to optimality. However, there are still many problems that have not been solved yet. In this thesis suitable models for three of these unsolved scheduling problems will be presented. In Chapter 2 the problem is formulated and in Chapter 3 some background information is given about the modeling techniques that are used in Chapters 4 to 6. In the remainder of the Introduction an overview of scheduling problems is given in which only one type of resource is involved, the so-called single machine models. Furthermore, the concept of computational complexity and the mathematical techniques that are used in this thesis are shortly discussed.

1.1 Single Machine Scheduling Problems

Most of the scheduling problems that were solved during the fifties of the twen-tieth century involved only one machine. Although single machine problems do not arise frequently in practice, a study of them is valuable for two reasons. Firstly, the solution methods for single machine models provide insights into solution techniques that could be used in more complex situations with sev-eral machines. Secondly, in many production settings there is one stage that is crucial for the overall performance of a schedule. This stage is called the bottleneck. Optimizing the schedule for the bottleneck, which could well be a single machine, then optimizes the schedule for the entire problem (Chen, Potts and Woeginger [11]).

In a single machine model there is a certain resource which is generally referred to as a ‘machine’. This resource is needed to fulfill a number of tasks, usually called ‘jobs’. The machine can only handle one job at a time. Each job may have different characteristics, such as the time that is needed to complete a job or the point in time at which a job becomes available for processing. Finally, there is an objective that has to be optimized. For example, one might be interested in minimizing the total number of tardy jobs, or the point in time at which all jobs are completed.

(15)

Job Characteristics. Assume that there are n jobs to be scheduled and let the subscript j refer to a particular job. Examples of job characteristics are:

Processing time (pj). The time that is needed to fully process job j.

Release date (rj). The time at which job j becomes available for processing.

Due date (dj). The time at which job j is committed to be completed. When

this due date is not met, a penalty is incurred. When the due date must be met at all costs, it can replaced by a (strict) deadline Dj.

Weight (wj). The weight of a job, which is a priority factor. It reflects the

importance of job j relative to other jobs.

Preemption (pmtn). When preemption is allowed, a job can be removed from a machine before it is fully processed. At a later stage it can then be resumed. In case of preemption, processing that has already been done is not lost.

Precedence constraints (prec). When a job cannot be processed before an-other job is completed, the problem is subject to so-called precedence constraints. Precedence constraints can be depicted by acyclic graphs, where each node is a job and each arc a precedence constraint. When the graph consists of chains, prec is replaced by chains in the β-field. Similarly, when the precedence constraints can be represented by a series-parallel graph, prec is replaced by sp-graph.

It should be noted that pj only appears in the β-field when pj = p, i.e.,

when all processing times are equal. In general, wj and dj do not appear at all

in the β-field since it is clear from the objective whether there are weights and due dates. This is not the case for strict deadlines Dj. Note that it could well

be that the β-field is empty.

Objective Criteria. Let the time at which job j is finished be denoted by Cj, the completion time of job j. Define the lateness Lj and the tardiness Tjof

job j as follows:

Lj = Cj− dj,

Tj = max{Cj− dj, 0}.

The lateness of job j indicates the amount of time that a job is delayed. Note that a negative value implies that a job is early. The tardiness indicates the amount of delay of a job, and is zero when a job is early or exactly in time.

Furthermore, let

Uj=

1 if Cj> dj

0 otherwise.

When job j is delayed Uj is one, otherwise it is zero. This criterion can be

used to count the number of tardy jobs. However, the amount of delay is not expressed by it.

(16)

Makespan (Cmax = maxjCj). The makespan is the maximum completion

time, or the time at which all jobs are processed. When the makespan is minimized, the schedule tends to finish processing as early as possible. Total completion time (P

jCj). This objective sums the completion time of

all jobs. Minimizing the total completion time can be used as a surrogate for minimizing the total Work-In-Process, since it tends to finish each job as quickly as possible.

Total weighted completion time (P

jwjCj). This objective sums the completion

time of all jobs, after they have been adjusted for their weights. When total weighted completion time is minimized it becomes advantageous to finish jobs with high weights early relative to jobs with low weights. The total weighted completion time can be used to minimize the total value of the Work-In-Process.

Maximum lateness (Lmax = maxjLj). The maximum lateness records the

largest delay in a schedule. The maximum lateness objective minimizes in a way the worst performance of a schedule, since all delays are kept as small as possible.

Total number of tardy jobs (P

jUj). This objective counts the number of tardy

jobs. Minimizing the number of tardy jobs can be used to maximize the percentage of on-time deliveries.

Total weighted number of tardy jobs (P

jwjUj). This objective counts the

cu-mulative weight of all tardy jobs. This objective can be used to maximize the percentage of on-time deliveries adjusted for their weights.

Total tardiness (P

jTj). The total tardiness criterion sums all delays.

Minimiz-ing the total tardiness may be preferable to minimizMinimiz-ing the total number of tardy jobs. When the total number of tardy jobs is minimized, some jobs may get seriously delayed in order to keep the number of tardy jobs low. This in turn may lead to unacceptable situations in practice and does not occur when the total tardiness objective is used.

Total weighted tardiness (P

jwjTj). The total weighted tardiness sums the

total amount of tardiness adjusted for the weights of the jobs. It can be used when some delays are more expensive than other delays.

1.2 Computational Complexity

One of the most important questions in scheduling theory concerns the complex-ity status of a problem. The complexcomplex-ity status roughly describes the relation-ship between the size of a problem and the computation time that is needed to solve that problem. The problem size is determined by the input data and it is generally assumed that the input data is binary encoded. The following can be found in any textbook on Complexity Theory (see e.g. Garey and Johnson [14]). For problem size n, let TA(n) denote the worst-case time complexity when

a problem is solved by algorithm A. That is, TA(n) is the maximum number of

(17)

of algorithm A. When the computational complexity is determined, it is crucial to look at the order of the function TA(n). Consider for example algorithm A1

with TA1(n) = 0.5n

2 _{and algorithm A}

2with TA2(n) = 5n. Although algorithm

A1 is faster than algorithm A2 for 1 ≤ n ≤ 9 and equally fast for n = 10,

algorithm A2 is faster for all n > 10. This has to do with asymptotic growth

and is caused by the fact that TA2(n) is of lower order than TA1(n).

Given two functions F (n) and G(n), with n ∈ N, the order of F (n) is said to be lower than or equal to the order of G(n) if

F (n) ≤ K · G(n) for all n > n0,

where K and n0 are two positive constants. When the order of F is lower than

or equal to the order of G, it is denoted F = O(G). Hence TA1(n) is O(n

2_{) and}

TA2(n) is O(n).

The worst-case time complexity of an algorithm is important in order to determine whether it is efficient or not. Complexity theory is used to classify algorithms either as efficient or inefficient. Any O(P )-algorithm, where P is a polynomial in the problem size, is an efficient algorithm. All problems that can be solved by an O(P )-algorithm are said to be polynomially solvable and belong to the class P. A problem is said to be pseudo-polynomially solvable, when the running time is polynomial in the numerical value of the input (using unary encoding), but non-polynomial with respect to binary encoding.

Problems which can only be solved by non-polynomial algorithms belong to the class N P. It has been shown that the majority of the problems belonging to this class are equivalent to each other. This implies the following: if an effi-cient algorithm could be developed that solves one problem in this class, it can be used to solve all problems that are in this class. Conversely, when it can be proven that no such algorithm possibly exists for one of these problems, it immediately follows that no efficient algorithm exists for any problem in this class. These problems are called NP-complete. A more formal definition will be given below. However, it is necessary to introduce the difference between optimization and recognition problems first.

An optimization problem is concerned with the solution that actually min-imizes (maxmin-imizes) a certain objective function. A recognition problem deals with the question whether or not there exists a certain instance such that the objective function is at most (at least) k, where k is an arbitrary constant. Hence, a recognition problem can be answered by YES or NO. An instance of a recognition problem is a YES instance if the answer to this problem is YES, and a NO instance if it is NO. Note that the optimization problem can be solved by repetitive application of the recognition problem. To define NP-complete and NP-hard problems the following is needed as well:

A problem P1polynomially reduces to a problem P2if some polynomial-time

algorithm that solves P1 uses the algorithm for solving P2 at unit cost. Here,

at unit cost means that the algorithm for P2 requires unit time to execute.

From this definition the following property arises: If P1 polynomially reduces

to P2 and some polynomial-time algorithm solves P2, then some polynomial

(18)

A special form of problem reduction is called problem transformation. A problem P1 polynomially transforms to problem P2 if for every instance I1 of

problem P1an instance I2of problem P2can be constructed in polynomial time

such that I1is a YES instance of P1 if and only if I2 is a YES instance of P2.

Now, a recognition problem P1 is said to be NP-complete if

1. P1∈ N P, and

2. all other problems in the class N P polynomially transform to P1.

A recognition problem P1 is said to be NP-hard if all other problems in

the class N P polynomially reduce to P1. Note that this class of problems is

broader than the class NP-complete, because it includes the class N P as well as problems that are not in this class.

Note that these definitions of NP-completeness and NP-hardness are based on the assumption of binary encoded problem sizes. A problem that is NP-complete or NP-hard could well be pseudo-polynomially solvable. When a problem is NP-complete with respect to unary encoding as well, it is said to be strongly NP-complete. A similar result holds for strongly NP-hard problems (see e.g. Leung [24]). For a more detailed description of computational com-plexity, the reader is referred to Garey and Johnson [14] or Leung [24].

1.3 Overview of Complexity Status of Single

Ma-chine Scheduling Models

Many single machine models have already been shown to be (pseudo-)polyno-mially solvable or NP-hard. On a website, Brucker and Knust [10] keep track of the complexity results of scheduling problems. Problems that were solved in the fifties of the previous century are for example

1||Lmax and 1||

X wjCj.

In the first problem (Jackson [18]) the objective is to find a schedule that min-imizes the maximum lateness. The β-field is empty, which implies that all jobs have different processing times and due dates, but that preemption is not al-lowed and there are no release dates, precedence constraints, etcetera. This problem is solved by the Earliest Due Date (EDD) first rule, which orders all jobs by their due date (from low to high) and schedules them accordingly. This algorithm runs in O(n2_).

In 1||P wjCj (Smith [33]) the schedule that minimizes the total weighted

completion time needs to be determined. All jobs have different processing times and weights. This problem is solved by the Weighted Shortest Processing Time (WSPT) first rule, where job j is scheduled before job k if

wj

pj

> wk pk

.

(19)

Another example of a scheduling problem that is polynomially solvable is 1|pj = p; rj|

X wjCj.

In this problem the schedule that minimizes the total weighted completion time needs to be determined. All jobs have the same processing time and different release dates. The problem can be solved by a dynamic programming algorithm that was introduced by Baptiste [4]. The time complexity of the algorithm is O(n7_).

Examples of problems that are NP-hard are: 1|rj|Lmax and 1|pmtn; rj|

X wjCj.

The problem 1|rj|Lmax is a generalization of the problem 1||Lmax. In this

problem, the jobs have different release dates, processing times and due dates. In Lenstra, Rinnooy Kan and Brucker [23], it is proven that this problem is strongly NP-hard. To see why the EDD rule does not necessarily solve this problem to optimality, consider the following example:

job j 1 2 3 4 pj 4 1 6 4

rj 0 0 1 3

dj 13 14 7 11

The EDD schedule is depicted in Figure 1.1a. It is not difficult to see that Lmax = L3 = L4 = 3. In Figure 1.1b, the optimal schedule is depicted, with

Lmax= L1= L2= 2.

Figure 1.1: (a) The EDD schedule with Lmax = 3. (b) The optimal schedule

with Lmax= 2.

Now consider the problem 1|pmtn; rj|P wjCj, which is a generalization of

1||P wjCj. A possible approach for this problem would be to check whether

(20)

job j 1 2 3 pj 2 3 4

rj 0 1 2

wj 1 4 10

The preemptive WSPT schedule is depicted in Figure 1.2a and has objective valueP wjCj= 101. However, the optimal schedule is depicted in Figure 1.2b

and has objective value P wjCj = 98. The proof that 1|pmtn; rj|P wjCj is

strongly NP-hard is given in Labetoulle et al. [21].

Figure 1.2: (a) The preemptive WSPT schedule withP wjCj = 101. (b) The

optimal schedule withP wjCj = 98.

In Appendix A a complete overview of the complexity status of single ma-chine problems is given.

1.3.1 Open Problems

Although the complexity status of most single machine scheduling problems is known, there still exist problems with an open complexity status. This means that it is not known whether they are polynomially solvable or not. One of these problems is the preemptive equal-length job scheduling problem with release dates 1|pmtn; pj= p; rj|P wjCj, in which the total weighted completion time is

minimized. This problem is similar to two of the problems that were discussed in the preceding paragraph, namely 1|pj= p; rj|P wjCj and 1|pmtn; rj|P wjCj.

The non-preemptive problem 1|pj = p; rj|P wjCj, which is an easier case

of the open problem, is polynomially solvable. It can be shown that this is the case for all easier cases of the open problem. Therefore, 1|pmtn; pj =

p; rj|P wjCj is said to be minimal open. The problem 1|pmtn; rj|P wjCj is

slightly harder than the open problem, since the processing times of the jobs may differ. As was already indicated, this problem is strongly NP-hard. However, 1|pmtn; pj = p; rj|P wjCj is not maximal open, which implies that there are

harder cases that are not known to be NP-hard. Consider for example the open problem with strict deadlines, 1|pmtn; pj = p; rj; Dj|P wjCj. This problem

is harder than the open problem under consideration and its complexity status is open as well. The problem can be solved by the model presented in Chapter 5.

Two problems that are very similar to 1|pmtn; pj = p; rj|P wjCj are

1|pmtn; pj = p; rj|

X

wjTj and 1|pj= p; rj|

(21)

In both problems the total weighted tardiness is minimized instead of the to-tal weighted completion time. The first problem allows for preemption, the second does not. According to the website of Brucker and Knust [10], the non-preemptive problem is both minimal and maximal open. This implies that all easier problems are polynomially solvable and all harder cases are NP-hard. Apparently, Brucker and Knust do not regard the preemptive problem as an easier or harder case. This is in agreement with a observation in Pinedo [29], which says that allowing preemptions usually simplifies the analysis of a prob-lem, but not always. On the website of Brucker and Knust [10] it is also stated that the preemptive problem is maximal open, but not minimal. However, it will be shown in the following section that all easier problems (i.e., with equal job weights or without release dates) are known to be polynomially solvable. Since 1|pj = p; rj|P wjTj is not regarded as an easier problem, this implies

that 1|pmtn; pj= p; rj|P wjTj must be minimal open as well.

1.3.2

1.4 Linear and Integer Programming

Many decision problems like the scheduling problems of the preceding section -can be modeled by Linear Programming (LP) models. An LP model consists of an objective function and a number of constraints which are all linear functions of the decision variables. When the decision variables can only take integer val-ues, the resulting model is called an Integer Linear Programming (ILP) model. Similarly, when the decision variables can only take boolean values (i.e., 0 or 1), the model is called a Boolean Linear Programming (BLP) model.

(24)

where A is a m × n-matrix, w and x are vectors in Rn

and b is a vector in Rm_.

Every LP model has a dual, which is a LP model itself. The original LP model is called the primal model. When the primal model is a minimization problem, the dual is a maximization problem and vice versa. Each decision variable (constraint) of the primal model corresponds to a constraint (decision variable) of the dual model. The dual of the primal LP model presented above is given by

max{yb | yA ≤ w, y ≥ 0},

where y is a vector in Rm_{. By the strong duality theorem of Linear Programming}

(see e.g. Schrijver [30]), the optimal solution of the primal model is equal to the optimal solution of the corresponding dual model, provided that both solutions are feasible and bounded. A nice relation between the optimal solutions of the primal and dual model is called Complementary Slackness (CS), which states that x and y are both optimal solutions (provided that they are feasible) if and only if

yi(aix − bi) = 0 for all i,

(wj− yAj)xj = 0 for all j.

Here, ai denotes the ith row of A and Aj the jth column of A.

It is generally known that LP models are polynomially solvable. However, ILP models are NP-complete. Therefore, no efficient algorithms are known to solve ILP problems. A possible way to solve an ILP model is by solving the corresponding LP relaxation. That is, the model is solved without the restriction of integrality. When the optimal solution of the LP relaxation appears to be integer, it is the optimal solution to the ILP model as well. However, this occurs only in certain special cases and sometimes just by coincidence.

1.4.1 Total Unimodularity and Total Dual Integrality

The set of all possible solutions to a LP model is a polyhedron. The polyhedron P corresponding to the model presented above is

P = {x ∈ Rn| Ax ≥ b, x ≥ 0}.

Polyhedra are closed, convex sets. To define what a face of a polyhedron is, we need the following:

A hyperplane is a set of the form Hw,d= {x ∈ Rn| wx = d}, where w ∈ Rn

is a nonzero row vector and d ∈ R. The hyperplane Hw,d is a supporting

hy-perplane of P if max{wx | x ∈ P } = d.

Now, F is called a face of P if F = P or F = P ∩ H for some supporting hyperplane H of P . Furthermore, a point p ∈ P is a vertex of P if {p} is a face of P (see e.g. Schrijver [30]).

(25)

when one is trying to solve an ILP model. When the polyhedron is integral, it suffices to solve the LP relaxation corresponding to the ILP model.

Sometimes it is possible to tell from the properties of the constraint matrix A that the polyhedron P = {x ∈ Rn_{| Ax ≥ b, x ≥ 0} is integral for each integral}

vector b. This is the case if and only if A is Totally Unimodular (TU). A matrix A is called TU if each subdeterminant of A is 0, 1, or −1. In particular, each entry of A is 0, 1, or −1. There exist polynomial time algorithms to check whether A is TU (see e.g. Schrijver [30]).

However, when the constraint matrix A is not TU, the integrality of the polyhedron P = {x ∈ Rn| Ax ≥ b, x ≥ 0} for a particular integral vector b can still be guaranteed by the notion of Total Dual Integrality (TDI). The system Ax ≥ b, x ≥ 0 is TDI if the dual has an integral optimal solution y for each integral vector w for which the maximum is finite. Furthermore, it can be shown that when Ax ≥ b, x ≥ 0 is a TDI system, and when b is integral, the polyhedron P = {x ∈ Rn_{| Ax ≥ b, x ≥ 0} is integral (see e.g. Schrijver [30]).}

The difference between a TDI system in which A is not TU, and a TDI system in which A is TU, is that in the former case an integral optimal solution is only guaranteed when w is an integer vector, while in the latter case this restriction is not needed.

(26)

(27)

Chapter 2

Problem Formulation

In this chapter the three scheduling problems that are solved in this thesis will be defined. By means of an example, a motivation is given for the use of the AP formulation. In Section 2.3 the structure of the proof of polynomial solvability will be explained.

2.1 Minimizing the Total Weighted Completion

Time

Consider the problem 1|pmtn; pj = p; rj|P wjCj, in which n jobs with

process-ing time p have to be scheduled. Each job j has a certain release date rj and

cannot be finished before rj+ p. Without loss of generality, assume that the

release dates are such that r1 ≤ r2 ≤ . . . ≤ rn. Furthermore, assume that all

entries are nonnegative integers and that there exists a schedule without idle time, i.e., the machine remains busy until all jobs are completed. It immedi-ately follows from the assumption of integral entries that in an optimal schedule preemption occurs only at unit points in time. Hence, the time horizon can be divided into pn time intervals of unit length and each job j needs to be assigned to p of these time intervals.

This problem presented above is an open problem. At the website of D¨urr [13] two attempts are presented to solve the (more general) problem

1|pmtn; pj= p; rj|

X wjCj.

The first is a LP model (Baptiste et al. [8]), the second is a dynamic program-ming model (Baptiste et al. [7]) for the special case when p > max rj. The LP

model will be shortly discussed below.

The BLP Model. Let the indices be given by j ∈ {1, 2, . . . , n},

(28)

Let the boolean decision variable xjtdenote how much of job j is completed

at time t. The BLP model reads minX j,t wjtxjt subject to PT t=0xjt = 1 j = 1, . . . , n P j≥i P t<ri+(a+1)pxjt ≤ a a = 0, . . . , n − 1 i = 1, . . . , n − a + 1 xjt ∈ {0, 1} for all j, t.

The first set of constraints states that every job should eventually be fully processed. The second set states that in an interval strictly less than (a + 1)p time units at most a jobs that are released at or after the starting time of that interval can be entirely executed and completed.

Baptiste et al. [8] show that the polyhedron determined by the LP relaxation contains vertices which are not integral. Therefore, it cannot be assured that the optimal solution of the LP relaxation is integral. Although this is not a proof that the LP relaxation does not solve the problem in polynomial time, another observation could be made that explain the incorrectness of the model. The LP relaxation of the model presented above allows for solutions that do not correspond to a feasible schedule. Consider for example the case with n = p = 3 and rj= j − 1. A feasible solution is given by

x13= x19= x26= x29= x35= x37=

1 2,

and all other variables are zero. Hence, after 2 time units nothing of job 1 is produced yet, but after 3 time units it is already processed for 11₂ time units. Al-though Baptiste et al. [8] mention this example and show that it is not optimal, they do not say anything about the infeasibility of the corresponding schedule. In the models presented in Chapters 4 to 6, all feasible solutions - integral and fractional - correspond to feasible schedules.

2.1.1 The Assignment Model

In order to show that the problem

1|pmtn; pj = p; rj|

X wjCj

is polynomially solvable the problem is modeled as an Assignment Problem (AP) with additional constraints. The AP is widely discussed in the literature and can be found in most textbooks on combinatorial optimization and integer lin-ear programming (see e.g. Sierksma [31]). The first polynomial time algorithm for the AP was suggested by Kuhn [19]. The AP can be formulated as follows: Consider two sets U and V , both containing T elements and a cost matrix W where wjt is the cost of assigning element j ∈ U to t ∈ V . An assignment

(29)

PT

j=1wjπ(j). The Assignment Problem can be stated as a BLP model as follows:

min T X j=1 T X t=1 wjtxjt subject to PT j=1xjt = 1 t = 1, . . . , T PT t=1xjt = 1 j = 1, . . . , T xjt ∈ {0, 1} for all j, t.

When the boolean constraint is replaced by 0 ≤ xjt≤ 1,

the LP relaxation is obtained. Since the constraint matrix of the AP is TU (see e.g. Sierksma [31]), there always exists an integral optimal solution to the LP relaxation. This implies that the AP is polynomially solvable.

In order to illustrate how to use the AP formulation for the problem 1|pmtn; pj = p; rj|P wjCj, consider the following example for the special case

with p = 2.

Example. Let there be 5 jobs with processing time 2 that have to be sched-uled. The release dates and weights of the jobs are given in the following table:

job j 1 2 3 4 5 rj 0 1 2 3 4

wj 1 3 7 16 33

Processing of the jobs starts at time 0 and is finished at time T = 10. Hence, there are 10 unit time intervals to which the jobs have to be assigned. Since the processing time of each job is 2, they can be divided into two parts such that each of the ten evolving job parts is assigned to exactly one time interval. It should be noted that when job j is released at time rj, the first part can be

assigned to time interval rj+ 1 or any later time interval. The second part can

only be processed at time interval rj+ 2 or at any later time interval.

Now consider the AP in which ten job parts have to be assigned to ten time intervals against minimum costs, where the costs of assigning each job part j to a certain time interval t are given in Table 2.1.

Here, 1.1 denotes the first part of job 1, 2.1 the first part of job 2, etcetera. Since the objective value of the scheduling problem, P wjCj, depends on the

completion time of the jobs, it follows that the assignment of the first part of a job to a certain time interval does not come with any costs. However, since a job can not be processed before it is released and since processing has to start before the final time interval T , the costs for t < rj+ 1 and t = T are set to

infinity. Consequently, the first part of a job will never be assigned to one of these intervals.

If the second part of a job is assigned to time interval t the costs are wjt.

(30)

Table 2.1: The cost matrix W , representing the costs of assigning job parts to time intervals. Time Intervals t 1 2 3 4 5 6 7 8 9 10 1.1 0∗ 0 0 0 0 0 0 0 0 ∞ J 2.1 ∞ 0∗ 0 0 0 0 0 0 0 ∞ o 3.1 ∞ ∞ 0 0 0 0 0∗ 0 0 ∞ b 4.1 ∞ ∞ ∞ 0 0 0 0 0∗ ₀ _∞ p 5.1 ∞ ∞ ∞ ∞ 0 0 0 0 0∗ _∞ a 1.2 ∞ 2 3 4 5 6 7 8 9 10∗ r 2.2 ∞ ∞ 9∗ 12 15 18 21 24 27 30 t 3.2 ∞ ∞ ∞ 28∗ 35 42 49 56 63 70 s 4.2 ∞ ∞ ∞ ∞ 80∗ 96 112 128 144 160 5.2 ∞ ∞ ∞ ∞ ∞ 198∗ 231 264 297 330 follows that the corresponding costs can be set to infinity as well.

An optimal solution for the Assignment Problem is given by the asterisks in Table 2.1. Note that, although the resulting schedule

S = (1, 2, 2, 3, 4, 5, 3, 4, 5, 1)

is feasible, the objective value corresponding to this schedule (P wjCj = 493)

is not equal to the objective value of the AP, which is 325. The reason for this difference is that in the AP the first parts of jobs 3, 4 and 5 are scheduled after their second parts, which has a positive effect on the costs, but which should not be possible in a correct model. It is not difficult to see that the schedule S cannot be optimal; it is possible to assign job 3 to the 4th and 6th time interval and to assign job 5 to the 7th and 9th interval. The completion time of job 5 does not change by this operation while the completion time of job 3 decreases. Hence, the resulting schedule is better than S.

A natural question that comes to mind is whether the solution of the AP can be used to construct an optimal solution of the scheduling problem under consideration. A possible way to do this would be the following:

1. Let the sequence in which the second job parts are scheduled be as in the optimal solution of the AP.

2. Starting at time interval 1, assign each first job part that was originally scheduled after its second part to the time interval right before this second part. Note that the second job part and all subsequent job parts move to the next time interval.

3. Repeat step 2 until all first job parts are scheduled before the correspond-ing second job parts.

(31)

with objective value 460. Unfortunately, it can be shown that S0 is not optimal either. It is not difficult to see that interchanging jobs 4 and 5 leads to a better schedule.

Although the AP formulation clearly does not lead to an optimal solution of the problem 1|pmtn; pj= 2; rj|P wjCj, the example shows that this

formu-lation could be used when additional constraints are added which ensure that the second part of a job can not be processed before its first part. However, it is desirable to maintain the nice properties of the AP that assure an inte-gral optimal solution of the LP relaxation. In general, these nice properties are destroyed when side constraints are added to the AP. In the literature, there can be found many examples that have to contend with these difficulties. A selection of them is treated in Chapter 3. However, first the other two open problems are formulated.

2.2 Minimizing the Total Weighted Tardiness

The open problems in which the total weighted tardiness is minimized consist of a preemptive and a non-preemptive version. They are very similar to the problem defined in Section 2.1 as will be shown below.

2.2.1 The Preemptive Problem

Consider the problem 1|pmtn; pj = p; rj|P wjTj, in which n jobs with

process-ing time p have to be scheduled. Each job has a certain release date and due date and can not be finished before rj+ p. Without loss of generality, assume

that the release dates are such that r1 ≤ r2 ≤ . . . ≤ rn. Furthermore, assume

that all entries are nonnegative integers and that there exists a schedule without idle time intervals, i.e., all pn time intervals will be assigned without any time interval remaining idle. This implies that at least one job is released at time zero and all jobs are completed at time T = pn.

Just like the problem 1|pmtn; pj = p; rj|P wjCj, this is an open problem.

It should be noted that the problems are very similar. To see this, consider the example of Section 2.1.1 with due dates. Recall that in this example p = 2. Example

job j 1 2 3 4 5 rj 0 1 2 3 4

wj 1 3 7 16 33

dj 5 8 7 7 6

A similar cost matrix as depicted in Table 2.1 can be constructed. Note that in this case, assigning the second part of job j to time interval t does only come with any costs if dj > t.

(32)

Table 2.2: The cost matrix W , representing the costs of assigning job parts to time intervals whenP wjTj is the objective.

Time Intervals t 1 2 3 4 5 6 7 8 9 10 1.1 0∗ 0 0 0 0 0 0 0 0 ∞ J 2.1 ∞ 0∗ 0 0 0 0 0 0 0 ∞ o 3.1 ∞ ∞ 0∗ 0 0 0 0 0 0 ∞ b 4.1 ∞ ∞ ∞ 0 0 0 0 0 0∗ ∞ p 5.1 ∞ ∞ ∞ ∞ 0∗ 0 0 0 0 ∞ a 1.2 ∞ 0 0 0 0 1 2 3 4 5∗ r 2.2 ∞ ∞ 0 0 0 0 0 0∗ 3 6 t 3.2 ∞ ∞ ∞ 0∗ ₀ ₀ ₀ ₇ ₁₄ ₂₁ s 4.2 ∞ ∞ ∞ ∞ 0 0 0∗ ₁₆ ₃₂ ₄₈ 5.2 ∞ ∞ ∞ ∞ ∞ 0∗ 33 66 99 132

(1, 2, 3, 3, 5, 5, 4, 2, 4, 1). Note that the AP schedules the second part of job 4 be-fore its first part. Therebe-fore, the corresponding objective value is not equal to the total weighted tardiness, which is in fact 37. This schedule is not optimal. By in-spection, it is possible to find the better schedule (1, 1, 3, 3, 5, 5, 4, 4, 2, 2) with

ob-jective value 22.

Although the AP does not lead to an optimal solution of the problem 1|pmpn; pj = p; rj|P wjTj, the example shows that the AP formulation can

be used when extra constraints are added that ensure that the job parts are scheduled in the right order.

2.2.2 The Non-Preemptive Problem

Consider the problem 1|pj = p; rj|P wjTj, in which n jobs with processing

time p have to be scheduled. Each job has a certain release date and due date. Without loss of generality, assume that jobs are ordered by their release date, r1≤ r2≤ . . . ≤ rnand that there is always a job available for processing. When

this assumption does not hold, the problem can be split up into two separate problems. Furthermore, assume that all entries are nonnegative integers. Just as in the preemptive case, the time horizon can be divided into time intervals of unit length. However, since preemption is not allowed, it should be noted that an optimal schedule might contain idle time intervals. Consider for example the following instance with p = 2:

job j 1 2 3 rj 0 1 4

dj 8 3 6

wj 1 1 1

It is not difficult to see that the schedule

2 2 3 3 1 1

(33)

Note that the maximum number of idle time intervals is (n−1)(p−1). To see this, consider the case in which the machine remains idle during the first (p − 1) time intervals before it starts processing job j = 2. When this job is completed, the machine remains idle for another p − 1 time units until it starts processing job j = 3. This can be repeated until job j = n is completed and processing of job j = 1 is started. It follows that all job parts have to be assigned to time intervals t = 1, . . . , T , where T = (n − 1)(p − 1) + np.

This is an open problem. In Chapter 6 it is shown that it can be solved by the AP with side constraints. The cost matrix is similar to the one in Table 2.2. Since there are more time intervals than job parts, the constraints of the AP require that each time interval is assigned at most (but not exactly) one job part. The side constraints require that as soon as the first job part is scheduled, all other job parts are scheduled successively and in the right order.

2.3 Outline of the Proof

In order to prove that the preemptive problems discussed in this thesis are polynomially solvable the following line of reasoning is used:

First, a crucial property for any optimal preemptive schedule is introduced. This property is used to formulate a BLP model. Then, it is shown that the constraint matrix corresponding to this BLP model is not Totally Unimodu-lar. Therefore, it can not be concluded directly that the polyhedron determined by the LP relaxation is integral. Nevertheless, it can be proven that the sys-tem of (in)equalities determined by the LP relaxation is Totally Dual Integral. Since the LP relaxation is polynomially solvable, this directly implies that the corresponding scheduling problem is polynomially solvable.

The proof of Total Dual Integrality is based on the dual of the LP relax-ation. After the dual is formulated, it is proven that it always has an integral optimal solution. Since all job weights are assumed to be integral, it then im-mediately follows from the definition of Total Dual Integrality that the system of (in)equalities determined by the LP relaxation is Totally Dual Integral.

(34)

(35)

Chapter 3

Variations on the

Assignment Problem

In this chapter four problems will be discussed that can be modeled using the framework of the Assignment Problem. From the examples it follows that the nice properties of the AP are not always preserved when extra constraints are added; the first two problems are polynomially solvable, the others are not.

3.1 Finding Subdigraphs with Prescribed

De-grees

The following is a special case of the problem discussed in Bang-Jensen and Gutin [3, p. 142]. Let there be a directed weighted graph D. Suppose one would like to identify the minimum cost subgraph of D, if one exists, with prescribed degrees on the vertices. This could be of interest for example when the cheapest cycle factor of D is required. This problem can be stated as follows: Given the weighted graph D = (V, A) with V = {v1, v2, . . . , vn} and

inte-gers a1, a2, . . . , an, b1, b2, . . . , bn, find the cheapest subgraph D0 = (V, A∗) of D

which satisfies d+_D0(vi) = ai and d−D0(vi) = bi for each i = 1, 2, . . . , n, or show

that no such subdigraph exists. Here, d+_D0(vi) and d−D0(vi) denote the out- and,

respectively, in-degree of vertex i in subgraph D0.

This problem can be formulated as a BLP model as follows. Let wij denote

the weight of arc (i, j). Assume that ai ≤ d+D(vi) and bi ≤ d−D(vi) for all

i ∈ {1, 2, . . . , n} and Pn

i=1ai = P

n

i=1bi. Furthermore, define the following

decision variable:

xij =

1 if (i, j) ∈ A∗ 0 otherwise. The model reads:

(36)

subject to P

j:(i,j)∈Axij = ai i = 1, . . . , n

P

i:(i,j)∈Axij = bj j = 1, . . . , n

xij ∈ {0, 1} for all i, j.

This is a special case of the AP since many possible assignments are excluded beforehand (only existing arcs can be included in the subdigraph). One could also say that extra constraints which ensure that xij = 0 when (i, j) /∈ A need

to be added to the AP. Note also that aiand bjare not necessarily equal to one.

Bang-Jensen and Gutin [3] show that this problem can be solved in polynomial time.

3.2 A Polynomial Solvable Case of the Axial

Three-Dimensional Assignment Model

The following is taken from Gilbert and Hofstra [15]. Consider the problem in which there are p jobs, q workers and r machines, p ≤ q ≤ r. Each job has to be assigned to a worker and a machine, but each worker and each machine can be assigned to at most one job. Suppose the cost of assigning job i to worker j and machine k can be expressed as the cost of assigning job i to worker j plus the cost of assigning job j to machine k, i.e., wijk = w0ij+ w00jk. This problem

can be formulated by means of the (two-dimensional) Assignment Problem. Define the following decision variables:

xij =

1 if job i is assigned to worker j 0 otherwise,

for i = 1, . . . , p and j = 1, . . . , q, yjk=

1 if worker j is assigned to machine k 0 otherwise,

for j = 1, . . . , q and k = 1, . . . , r, zj =

0 if worker j is assigned a job 1 otherwise.

The BLP model can now be formulated as: min p X i=1 q X j=1 w_ij0 xij+ q X j=1 r X k=1 w_jk00xjk subject to Pq j=1xij = 1 i = 1, . . . , k Pp i=1xij+ zj = 1 j = 1, . . . , q Pr k=1yjk+ zj = 1 j = 1, . . . , q Pq j=1yjk ≤ 1 k = 1, . . . , r xij, yjk, zj ∈ {0, 1} for all i, j, k.

In Figure 3.1 the two-dimensional representation of this problem is given. Note that the cells in the upper left quadrant correspond to the variables xij,

(37)

the variables yjk, which assign workers to machines. The cells on the diagonal

of the lower left quadrant correspond to the zj variables. All black cells are

infeasible. Since this problem is now formulated as a classical AP, it immediately follows that it is polynomially solvable.

Figure 3.1: Graphical representation of a special case of the three-dimensional assignment model.

A suggestion would be to use this formulation for the problem 1|pmtn; pj = 2; rj|P wjCj, by assigning each first job part to a certain time

interval and each time interval to another (idle) time interval. This second time interval can then be assigned to a second job part. A graphical representation with a possible assignment is given in Figure 3.2 for n = 3.

Figure 3.2: Graphical representation of the multidimensional assignment prob-lem for 1|pmtn; pj= 2; rj|P wjCj with n = 3.

(38)

3.3 The Imbalanced Time Minimizing

Assign-ment Problem

This problem is taken from M¨uller, Camozzato and Bassi de Ara´ujo [27]. Con-sider the problem of assigning n jobs to m machines, n > m, each job with a distinct processing time for each machine. One job is assigned to exactly one machine and each machine is assigned to at least one job. Hence, this is the problem R||Cmax, where R stands for unrelated parallel machines, with the

constraint that each machine performs at least one job.

Let pijdenote the processing time of job j on machine i. Define the following

decision variable: xij =

1 if job j is assigned to machine i 0 otherwise.

Furthermore, let t be a positive integer. The BLP model is given by: min Z = t subject to Pm i=1xij = 1 j = 1, . . . , n Pn j=1xij ≥ 1 i = 1, . . . , m Pn j=1pijxij ≤ t i = 1, . . . , m xij ∈ {0, 1} for all i, j.

Constraint 1 assures that every job is assigned to exactly one machine. The second constraint assures that every machine is assigned to at least one job. The third constraint imposes that every machine finishes processing not later than time t, which is the time to be minimized.

Note that this problem is equivalent to the recognition problem where the question is posed whether there exists a feasible schedule for R||Cmaxsuch that

the maximum completion time is at most t. This question can be answered by YES or NO. If there is a polynomial time algorithm that solves the latter problem, it can be applied iteratively for smaller and smaller values of t until the answer is NO. The solution to the former problem is then equal to the solution to the latter problem where t is chosen such that the answer is just YES.

However, this problem is proven to be NP-hard. It is already difficult to solve the model for relatively short instances.

3.4 Resource-Constrained Assignment

Schedul-ing

(39)

worker i is assigned to job j is denoted by rijk. The budget of department k

is denoted by bk. Similar to the AP, let xij be the decision variable indicating

whether worker i is assigned to job j or not. The Assignment Problem with Side Constraints (APSC) is given by:

min n X i=1 n X j=1 wijxij subject to Pn i=1xij = 1 j = 1, . . . , n Pn j=1xij ≥ 1 i = 1, . . . , n Pn i=1 Pn j=1rijkxij ≤ bk k = 1, . . . , s xij ∈ {0, 1} for all i, j.

The APSC is shown to be NP-complete.

(40)

(41)

Chapter 4

Minimizing the Total

Weighted Completion Time

when p = 2

In this chapter, the BLP model for the problem 1|pmtn; pj = 2; rj|P wjCj

will be presented, as well as its Integer and LP relaxations. By means of the dual problem, it will be shown that the system of (in)equalities determined by the LP relaxation is TDI. The immediate consequence is that the problem 1|pmtn; pj = 2; rj|P wjCj is polynomially solvable. The chapter will be

con-cluded with the optimality conditions that evolve from Complementary Slack-ness.

4.1 The Number of Time Intervals between the

First and Second Part of a Job

Consider the following simple example with 2 jobs, r1 = 0, r2 = 1 and

p = 2. Depending on the job weights either the schedule (1, 2, 2, 1) or (1, 1, 2, 2) is optimal. The feasible schedule (1, 2, 1, 2) can never be optimal since (1, 1, 2, 2) has a strictly better objective value irrespective of the weights. It appears that, when it is profitable to interrupt job 1, job 2 is fully processed before job 1 is resumed. A generalization of this result is given in Theorem 1.

Theorem 4.1 In an optimal schedule of the problem 1|pmtn; pj= 2; rj|P wjCj,

there are either zero or an even number of time intervals between the intervals to which the first and second part of a particular job are assigned.

(42)

Suppose part 1 of job j is scheduled at time interval t, its second part is scheduled at time interval t + d, d ∈ {2, 4, 6, . . .}, and part 1 of job k is sched-uled somewhere in between at time interval t + c, c ∈ {1, 3, 5, . . .}, c < d. Now interchange the positions of part 2 of job j and part 1 of job k. All other jobs remain in the same position. Note that the number of time intervals between the first and second part of job j is now zero or even. Call the new schedule S0. The total weighted completion time of all jobs completed before job j is not affected by the interchange, nor is the total weighted completion time of the jobs finished after job j. Since the weighted completion time of job j is strictly less in schedule S0 than in schedule S, it follows that S cannot be optimal. This

com-pletes the proof of the theorem.

Theorem 4.1 appears to be crucial for the implementation of the side con-straints in the AP formulation. It makes it possible to formulate the extra constraints such that the system of (in)equalities remains TDI.

It should be noted that Theorem 4.1 is a direct consequence of Lemma 2.1 in-troduced by Tian et al. [34]. This lemma states that in a p-active schedule, job i is either fully processed before job j is started, or job i is interrupted by job j and not resumed before job j is completed. This implies that if job i is interrupted, it is interrupted for p = 2 or a multiple of p time units. Note that a preemptive schedule is p-active if no job’s completion time can be advanced without postponing the completion time of some other job. It is not difficult to show that an optimal preemptive schedule is p-active when the total weighted completion time is minimized.

4.2 The Primal Model

The following indices, parameters and decision variables are used in the BLP model.

Indices

j ∈ {1, . . . , n} job index; t ∈ {1, . . . , T } time index;

k ∈ {1, 3, 5, . . . , T − 1} the set of all odd time indices;

l ∈ {2, 4, 6, . . . , T − 2} the set of all even time indices up to and including T − 2.

Parameters

w0_jt cost of part 1 of job j when it is processed at time interval t; w00_jt cost of part 2 of job j when it is processed at time interval t; rj release date of job j.

In the BLP model the regular weight wj will not be used. Instead, w0jt and

w00_jt are introduced. They are defined as: w0_jt=

0 for all j, for T − 1 ≥ t ≥ rj+ 1

(43)

w00_jt=

wjt for all j, for t ≥ rj+ 2

∞ otherwise. Decision Variables

x0_jt=

1 if job j’s first part is assigned to time interval t 0 otherwise.

x00_jt=

1 if job j’s second part is assigned to time interval t 0 otherwise.

Furthermore, the following subsets of time intervals, Tk and Ul, are used.

Tk = {1, 3, 5, . . . , k} The subset of odd time intervals up to and including

interval k;

Ul= {2, 4, 6, . . . , l} The subset of even time intervals up to and including

interval l.

4.2.1 BLP Model

The BLP model can now be formulated as:

min n X j=1 T X t=1 w0jtx0jt+ n X j=1 T X t=1 wjt00x00jt subject to T X t=1 x0_jt ≥ 1 j = 1, . . . , n (4.1) T X t=1 x00_jt ≥ 1 j = 1, . . . , n (4.2) n X j=1 x0_jt+ x00_jt = 1 t = 1, . . . , T (4.3) X t∈Tk x0_jt−X t∈Tk x00_j,t+1 ≥ 0 j = 1, . . . , n (4.4) k = 1, 3, 5, . . . , T − 1 X t∈Ul x0jt− X t∈Ul x00j,t+1 ≥ 0 j = 1, . . . , n (4.5) l = 2, 4, 6, . . . , T − 2 x0_jt, x00_jt ∈ {0, 1} j = 1, . . . , n t = 1, . . . , T. (4.6) Constraints (4.1) and (4.2) ensure that each first respectively second part of a job is processed for the duration of at least one time interval. Constraints (4.3) take care of the fact that each time interval is assigned to exactly one job part. Since the number of job parts is equal to the number of time intervals, it immediately follows from (4.1) and (4.2) that each job part is assigned to exactly one time interval. This can be seen as follows:

(44)

T − 1 job parts that have to be assigned to the remaining T − 2 time intervals. Since at most one job part can be assigned to each time interval by constraints (4.3), this contradicts the feasibility of x0_jt= 1 and x0_jˆ_t= 1.

Constraints (4.4) and (4.5) together assure that one cannot start processing the second part of a job before the first part is processed. Furthermore, they assure that the number of time intervals that lies between the processing of the first and second part of a job is either zero or even; when part 1 is assigned to time interval t, part 2 can only be assigned to time interval t+d, d ∈ {1, 3, 5, . . .}. Constraints (4.6) are boolean constraints.

4.2.2 Example

Consider the example of Chapter 2.

job j 1 2 3 4 5 rj 0 1 2 3 4

wj 1 3 7 16 33

The optimal solution is given by

x011= 1, x029= 1, x330 = 1, x047= 1, x055= 1,

x0012= 1, x002,10= 1, x3400 = 1, x0048= 1, x0056= 1,

and all other variables are zero. Hence, it follows that (1, 1, 3, 3, 5, 5, 4, 4, 2, 2)

is the optimal schedule and the objective valueP wjCj is 386.

4.2.3 Integer and LP Relaxations

Consider the BLP model presented in Section 4.2.1. Note that constraints (4.6) may be replaced by

x0jt, x00jt ∈ Z+ for all j, t. (4.7)

Constraints (4.7) require that the decision variables are non-negative integers. Note that it is sufficient to require that the decision variables are non-negative; it is not necessary to add x0_jt, x00_jt ≤ 1. By constraints (4.3), we already have that the decision variables x0_jt and x00_jt can not take any value larger than one. When (4.6) is replaced by (4.7), an ILP model is obtained.

From the ILP, it immediately follows that the LP relaxation is obtained when constraints (4.6) are replaced by

All Minimal and Maximal Open Single Machine Scheduling Problems are Polynomially Solvable

All Minimal and Maximal Open Single Machine

Scheduling Problems are Polynomially Solvable

Master’s Thesis Operations Research

Supervisor: Prof. Sc.D. B. Goldengorin

All Minimal and Maximal Open Single Machine

Scheduling Problems are Polynomially Solvable

H.W. Bouma

Preface

Contents

List of Figures

List of Tables

Chapter 1

Introduction

1.1

Single Machine Scheduling Problems

1.2

Computational Complexity

1.3

Overview of Complexity Status of Single

Ma-chine Scheduling Models

1.3.1

Open Problems

1.3.2

Related Problems

1.4

Linear and Integer Programming

1.4.1

Total Unimodularity and Total Dual Integrality

Chapter 2

Problem Formulation

2.1

Minimizing the Total Weighted Completion

Time

2.1.1

The Assignment Model

2.2

Minimizing the Total Weighted Tardiness

2.2.1

The Preemptive Problem

2.2.2

The Non-Preemptive Problem

2.3

Outline of the Proof

Chapter 3

Variations on the

Assignment Problem

3.1

Finding Subdigraphs with Prescribed

De-grees

3.2

A Polynomial Solvable Case of the Axial

Three-Dimensional Assignment Model

3.3

The Imbalanced Time Minimizing

Assign-ment Problem

3.4

Resource-Constrained Assignment

Schedul-ing

Chapter 4

Minimizing the Total

Weighted Completion Time

when p = 2

4.1

The Number of Time Intervals between the

First and Second Part of a Job

4.2

The Primal Model

4.2.1

BLP Model

4.2.2

Example

4.2.3

Integer and LP Relaxations