Scholarly article on topic 'Open Shop Scheduling with Synchronization'

Open Shop Scheduling with Synchronization Academic research paper on "Computer and information sciences"

CC BY
0
0
Share paper
Academic journal
Journal of Scheduling
OECD Field of science
Keywords
{""}

Academic research paper on topic "Open Shop Scheduling with Synchronization"

J Sched

DOI 10.1007/s10951-016-0490-0

CrossMark

Open Shop Scheduling with Synchronization

C. Weiß1 • S. Waldherr2 • S. Knust2 • N. V. Shakhlevich1

© The Author(s) 2016. This article is published with open access at Springerlink.com

Abstract In this paper, we study open shop scheduling problems with synchronization. This model has the same features as the classical open shop model, where each of the n jobs has to be processed by each of the m machines in an arbitrary order. Unlike the classical model, jobs are processed in synchronous cycles, which means that the m operations of the same cycle start at the same time. Within one cycle, machines which process operations with smaller processing times have to wait until the longest operation of the cycle is finished before the next cycle can start. Thus, the length of a cycle is equal to the maximum processing time of its operations. In this paper, we continue the line of research started by Weiß et al. (Discrete Appl Math 211:183-203, 2016). We establish new structural results for the two-machine problem with the makespan objective and use them to formulate an easier solution algorithm. Other versions of the problem, with the total completion time objective and those which involve due dates or deadlines, turn out to be NP-hard in the strong sense, even for m = 2 machines. We also show that relaxed models, in which cycles are allowed to contain less than m jobs, have the same complexity status.

B N. V. Shakhlevich

N.Shakhlevich@leeds.ac.uk

C. Weiß

mm12cw@leeds.ac.uk S. Waldherr

swaldher@uni-osnabrueck.de S. Knust

sknust@uni-osnabrueck.de

1 School of Computing, University of Leeds, Leeds LS2 9JT, UK

2 Institute of Computer Science, University of Osnabrück, 49069 Osnabrück, Germany

Keywords Open shop • Synchronization • Complexity

1 Introduction

Scheduling problems with synchronization arise in applications where job processing includes several stages, performed by different processing machines, and all movements of jobs between machines have to be done simultaneously. This may be caused by special requirements of job transfers, as it happens, for example, if jobs are installed on a circular production unit which rotates to move jobs simultaneously to machines of the next stage (see Soylu et al. 2007; Huang 2008; Waldherr and Knust 2014). Alternatively, there may be health and safety regulations requiring that no machine is in operation while jobs are being removed from or moved to a machine. Similar synchronization takes place in the context of switch-based communication systems, where senders transmit messages to receivers in a synchronous manner, as this eliminates possible clashes for receivers (see Gopal and Wong 1985; Rendl 1985; Kesselman and Kogan 2007).

Synchronization arises naturally in assembly line systems where each assembly operation may start only after all preceding operations are completed, see Doerr et al. (2000), Chiang et al. (2012), and Urban and Chiang (2016), and the survey by Boysen et al. (2008). In the context of shop scheduling models, synchronization aspects were initially studied for flow shops (Soylu et al. 2007; Huang 2008; Waldherr and Knust 2015), and later for open shops (Weiß et al. 2016). In the latter paper the makespan problem is addressed, with the main focus on the underlying assignment model. In the current paper we continue that line of research, elaborating further the study of the makespan minimization problem and addressing other variants of the model with different objective functions.

Published online: 08 August 2016

Springer

Formally, the open shop model with synchronization is defined as follows. As in the classical open shop, n jobs J1, J2,.Jn have to be processed by m machines Mi, M2,..., Mm, n > m. Each job Jj, 1 < j < n, consists of m operations Oij for 1 < i < m, where Oij has to be processed on machine Mi without preemption for pij time units. The synchronization requirement implies that job processing is organized in synchronous cycles, with operations of the same cycle starting at the same time. Within one cycle, machines which process operations of smaller processing times have to wait until the longest operation of the cycle is finished before the next cycle can start. Thus, the length of a cycle is equal to the maximum processing time of its operations. Similar to the classical open shop model, we assume that unlimited buffer exists between the machines, i.e., jobs which are finished on one machine can wait for an arbitrary number of cycles to be scheduled on the next machine.

The goal is to assign the nm operations to the m machines in n cycles such that a given objective function f is optimized. Function f depends on the completion times Cj of the jobs Jj, where Cj is the completion time of the last cycle in which an operation of job Jj is scheduled. Following the earlier research by Huang (2008) and Waldherr and Knust (2015), we denote synchronous movement of the jobs by "synmv" in the j-field of the traditional three-field notation. We write O\synmv\f for the general synchronous open shop problem with objective function f and Om\synmv\f if the number m of machines is fixed (i.e., not part of the input). The most common objective function is to minimize the makespan Cmax, defined as the completion time of the last cycle of a schedule. If deadlines Dj are given for the jobs Jj , the task is to find a feasible schedule with all jobs meeting their deadlines, Cj < Dj for 1 < j < n.Weusethe notation O \synmv, Cj < Dj \— for the feasibility problem with deadlines. In problem O\synmv\ £ Cj the sum of all completion times has to be minimized.

Usually, we assume that every cycle contains exactly m operations, one on each machine. In that case, together with the previously stated assumption n > m, exactly n cycles are needed to process all jobs. However, sometimes it is beneficial to relax the requirement for exactly m operations per cycle. Then a feasible schedule may contain incomplete cycles, with less than m operations. We denote such a relaxed model by including "rel" in the j-field. Similar to the observation of Kouvelis and Karabati (1999) that introducing idle times in a synchronous flow shop may be beneficial, we will show that a schedule for the relaxed problem O\synmv, rel\f consisting of more than n cycles may outperform a schedule for the nonrelaxed problem O\synmv\f with n cycles.

The synchronous open shop model is closely related to long known optimization problems in the area of commu-

nication networks: the underlying model is the max-weight edge coloring problem (MEC), restricted to complete bipartite graphs, see Weiß et al. (2016) for the link between the models, and Mestre and Raman (2013) for the most recent survey on MEC and other versions of max-coloring problems. As stated in Weiß et al. (2016), the complexity results from Rendl (1985) and Demange et al. (2002), formulated for MEC, imply that problems O \synm v\Cmax and O\synmv, rel\Cmax are strongly NP-hard if both n and m are part of the input. Moreover, using the results from Demange et al. (2002), Escoffier et al. (2006), Kesselman and Kogan (2007), de Werra et al. (2009), and Mestre and Raman (2013), formulated for MEC on cubic bipartite graphs, we conclude that these two open shop problems remain strongly NP-hard even if each job is processed by at most three machines and if there are only three different values for nonzero processing times.

On the other hand, if the number of machines m is fixed, then problem Om\synmv\Cmax can be solved in polynomial time as m-dimensional assignment problem with a nearly Monge weight array of size n x ••• x n, as discussed in Weiß et al. (2016) and in Sect. 2 of the current paper. The relaxed version Om\synmv, rel\Cmax admits the same assignment model, but with a larger m-dimensional weight array extended by adding dummy jobs. As observed in Weiß et al. (2016), the number of dummy jobs can be bounded by (m — 1)n. Both problems, Om\synmv\Cmax and Om\synmv, rel\Cmax, are solvable in O(n) time, after operations are sorted in nonincreasing (or nondecreasing) order of processing times on all machines. However, this algorithm becomes impractical for larger instances, as the constant term of the linear growth rate exceeds (m!)m.

The remainder of this paper is organized as follows. In Sect. 2, we consider problem O2\synmv\Cmax and establish a new structural property of an optimal solution. Based on it we formulate a new (much easier) O(n)-time solution algorithm, assuming jobs are presorted on each machine. Then we address in more detail problem O \synmv, rel\Cmax and provide a tight bound on the maximum number of cycles needed to get an optimal solution. In Sects. 3 and 4 we show that problems O2\synmv, Cj < Dj\— and O2\synmv\ £ C} are strongly NP-hard. Finally, conclusions are presented in Sect. 5.

2 Minimizing the makespan

In this section, we consider synchronous open shop problems with the makespan objective. Recall that problem Om\synmv\ Cmax with a fixed number of machines m can be solved in O(n) time (after presorting) by the algorithm from Weiß et al. (2016). In Sect. 2.1 we elaborate further results for the two-machine problem O2\synmv\Cmax, providing a

new structural property of an optimal schedule, which results in an easier solution algorithm. In Sect. 2.2 we study the relaxed problem O\synmv, rel\Cmax and determine a tight bound on the maximum number of cycles in an optimal solution.

2.1 Problem O2\synmv|Cmax

Problem O2\synmv\Cmax can be naturally modeled as an assignment problem. Consider two nonincreasing sequences of processing times of the operations on machines M1 and M2, renumbering the jobs in accordance with the sequence on Mi:

pi1 > pi2 > ... > pin, p2ki > p2k2 > ••• > p2kn.

To simplify the notation, let (ai )ni=1 and (bj )n=1 be the corresponding sequences of processing times in nonincreasing order. The i th operation on Mi with processing time ai and the j th operation on M2 with processing time bj can be paired in a cycle with cycle time max{ai, bj} if these two operations are not associated with the same job. Let F = {(1, ji), (2, j2), ...,(n, jn)} be the set of forbidden pairs: (i, ji) e F if operations O1i and O2ji belong to the same job.

Using binary variables xij to indicate whether the i th operation on M1 and the j th operation on M2 (in the above ordering) are paired in a cycle, the problem can be formulated as the following variant of the assignment problem:

APf: min X Z wijxij i=ij=i n

s.t. X Xij = 1, 1 < j < n,

i = 1 n

X Xij = 1, 1 < i < n, j=1

xij e {0, 1}, 1 < i, j < n,

Xij = 0, (i, j) e F,

with the cost matrix W = (wij), where

= max {ai, bj}, 1 < i, j < n.

Due to the predefined 0-variables Xij = 0 for forbidden pairs of indices (i, j) e F it is prohibited that two operations of the same job are allocated to the same cycle.

In Weiß et al. (2016) a slightly different formulation is used to model synchronous open shop as an assignment problem:

APœ: min X Z CijXij i=1 j=1 n

s.t. X Xij = 1, 1 < j < n,

X Xij = 1, 1 < i < n, j=1

Xij e {0, 1}, 1 < i, j < n, with the cost matrix C = (cij), where for 1 < i, j < n

max {ai, bj} , if (i, j) / F, œ, if (i, j) e F.

Here, for the forbidden pairs (i, j) e F there are ^-entries in the cost matrix, one in every row and every column. A feasible solution of the open shop problem exists if and only if the optimal solution value of AP«, is less than to.

Note that the problem APto in its more general form is the subject of our related paper, Weiß et al. (2016). In the current paper we focus on the formulation AP^, which is equivalent to APto for costs Cij of form (2). Formulation AP^ allows us to produce stronger results, see Theorems 1-2 in the next section. The main advantage of formulation AP^ is the possibility to use finite w-values for all pairs of indices, including wjs defined for forbidden pairs (i, j) e F.

Example 1 Consider an example with n = 4 jobs and the following processing times:

j 1 2 3 4

P1 j 7 5 3 2

P2 j 3 4 6 2

The sequences (ai) and (bj) of processing times are of the form:

i 12 3 4 j 12 3 4

ai 7 5 3 2 bj 6 4 3 2

Job J1 J2 J3 J4 Job J3 J2 J1 J4

The forbidden pairs are F = {(1, 3), (2, 2), (3, 1), (4,4)}, the associated matrices and are

(i \ j 1 2 3 4 (i \ j 1 2 3 4

1 7 7 7 7 1 7 7 œ 7

2 6 5 5 5 , C = 2 6 œ 5 5

3 6 4 3 3 3 œ 4 3 3

4 6 4 3 2 4 6 4 3 œ

The entries in bold font in W and C correspond to the optimal solution illustrated in Fig. 1. Here, x12 = 1 for the pair of jobs J1, J2 assigned to the same cycle, and x23 = X34 = x41 = 1 for the other cycles. The makespan is 7 + 6 + 3 + 3 = 19.

Jl Ja ■ Js Ja h

Jl Jz Ja m Ji

Fig. 1 Gantt chart of an optimal schedule for Example 1

It is known (cf. Bein et al. 1995; Burkard et al. 1996) that matrix W = (wij) defined by (1) satisfies the Monge property, i.e., for all row indices 1 < i < r < n and all column indices 1 < j < s < n we have

Wij + Wrs < Wis + W

Without the additional condition on forbidden pairs F, a greedy algorithm finds an optimal solution X = (xij to the assignment problem and that solution is of the diagonal form:

xii = 1 for i = 1,..., n; xij = 0 for i = j.

Forbidden pairs or, equivalently, œ-entries, may keep the Monge property satisfied so that the greedy algorithm remains applicable, as discussed by Burkard et al. (1996) and Queyranne et al. (1998). However, if at least one of the forbidden pairs from F is a diagonal element, then solution (4) is infeasible for problem AP^-. A similar observation holds for problem APœ if an œ-entry lies on the diagonal. In that case, as demonstrated in Weiß et al. (2016), there exists an optimal solution X which satisfies a so-called corridor property: the 1-entries of X belong to a corridor around the main diagonal of width 2, so that for every xij = 1 of an optimal solution the condition |i - j | <2 holds. Notice that in Example 1 there are two forbidden pairs in F of the diagonal type, (2, 2) and (4, 4); the specified optimal solution satisfies the corridor property. A related term used typically in two-dimensional settings is the bandwidth (see, e.g., Custic et al. 2014).

The corridor property is proved in Weiß et al. (2016) in its generalized form for the case of the m-dimensional assignment problem with a nearly Monge array (this is an array where œ-entries are allowed and the Monge property has to be satisfied by all finite entries). Thus, this property also holds for the m -machine synchronous open shop problem. It appears that for the case of m = 2 the structure of an optimal solution can be characterized in a more precise way, which makes it possible to develop an easier solution algorithm.

In the following, we present an alternative characterization of optimal solutions for m = 2 and develop an efficient algorithm for constructing an optimal solution. Note that the arguments in Weiß et al. (2016) are presented with respect to problem APœ; in this paper our arguments are based on the formulation AP^ and on its relaxation AP^-=0 , with the condition "xij = 0 for (i, j ) e F " dropped.

A block Xh of size s is a square submatrix consisting of s x s elements with exactly one 1-entry in each row and each column of Xh. We call a block large if it is of size s > 4, and small otherwise. Our main result is establishing a blockdiagonal structure of an optimal solution X = (xij),

/Xi 0 0 ... 0 \ 0 X2 0 ... 0

0 Xz-1 0 0 0 Xz/

with blocks Xh , 1 < h < z, of the form

'0 1 0N 0 0 1 1 0 0

around the main diagonal, and 0-entries elsewhere. Note that the submatrix

is excluded from consideration.

Theorem 1 ("Small Block Property"): There exists an optimal solution to problem APf in block-diagonal structure, containing only blocks of type (6).

This theorem is proved in Appendix 1. The small block property leads to an efficient O(n)-time dynamic programing algorithm to find an optimal solution. Here we use formulation APœ rather than APf, as infinite costs can be easily handled by recursive formulae. The algorithm enumerates optimal partial solutions, extending them repeatedly by adding blocks of size 1, 2, or 3.

Let Si denote an optimal partial solution for a subproblem of APœ defined by the submatrix of W with the first i rows and i columns. If an optimal partial solution Si is known, together with solutions Si -1 and Si-2 for smaller subproblems, then by Theorem 1 the next optimal partial solution Si+i can be found by selecting one of the following three options:

- extending Si by adding a block of size 1 with xi+1,i+1 = 1; the cost of the assignment increases by wi+1,i+1;

- extending Si -1 by adding a block of size 2 with xi,i+1 = xi+1,i = 1; the cost of the assignment increases by Wi,i+1 + Wi+1,i ;

- extending Si -2 by adding a block of size 3 with the smallest cost:

(i) Xi-i,i+1 = Xi,i-1 = Xi+1,1 = 1 with the cost w-1,i+1 + W,i-1 + w+1,i, or

(ii) Xi-1,i = Xi,i+1 = Xi+1,i-1 with the cost wi-1,i +

Wi,i + 1 + Wi + 1,i-1.

Let w(Si) denote the cost of Si. Then

w(Si+1) = min {w(Si) + Wi+1,i+1,

w(Si-1) + Wi,i+1 + Wi+1,i,

w(Si-2) + Wi-1,i + Wi,i+1 + Wi+1,i-1,

w(Si-2) + Wi-1,i+1 + Wi,i-1 + Wi+1,i} .

The initial conditions are defined as follows:

w(S0) = 0, w(S1) = W11,

w(S2) = min {W11 + W22, W12 + W21}.

Thus, w(S3), ..., W(Sn) are computed by (7) in O(n) time.

Theorem 2 Problem O2\synmv\Cmax can be solved in O(n) time.

Concluding this subsection, we provide several observations about the presented results. First, the small block property for problem O2\synmv\Cmax has implications for the assignment problem APTO with costs (2) and for more general cost matrices. The proof of the small block property is presented for problem APf. It is easy to verify that the proof is valid for an arbitrary Monge matrix W, not necessarily of type (1); the important property used in the proof requires that the set F has no more than one forbidden pair (i, j) in every row and in every column, and that all entries of the matrix W, including those corresponding to the forbidden pairs F, satisfy the Monge property. Thus, the small blockproperty and the O(n)-time algorithmhold for problem APoo if

(i) there is no more than one TO-entry in every row and every column of the cost matrix C, and

(ii) matrix C can be transformed into a Monge matrix by modifying only the TO-entries, keeping other entries unchanged.

Note that not every nearly Monge matrix satisfying (i) can be completed into a Monge matrix satisfying (ii); see Weiß et al. (2016) for further details. However, the definition (2) of the cost matrix C for the synchronous open shop allows a straightforward completion by replacing every entry cij = to by cij = max {ai, bj} .While completability was not used in the proof of the more general corridor property presented in Weiß et al. (2016), the proof of the small block property depends heavily on the fact that the matrix of the synchronous

open shop problem can be completed into a Monge matrix. In particular, we use completability when we accept potentially infeasible blocks in the proof of Lemma 3 and repair them later on with the help of Lemmas 4 and 5. In the literature, the possibility of completing an incomplete Monge matrix (a matrix with unspecified entries) was explored by Deineko et al. (1996) for the traveling salesman problem. They discuss Supnick matrices, a subclass of incomplete Monge matrices, for which completability is linked with several nice structural and algorithmic properties.

Finally, we observe that while the assignment matrices arising from the multimachine case are completable in the same way as for the two-machine case (see Weiß et al. 2016), it remains open whether this can be used to obtain an improved result for more than two machines as well. The technical difficulties of that case are beyond the scope of this paper.

2.2 Problem O\synmv, rel|Cmax

In this section, we consider the relaxed problem O \synmv, rel\Cmax where more than n cycles are allowed, with unallocated (idle) machines in some cycles. This problem can be transformed to a variant of problem O \synmv\Cmax by introducing dummy jobs, used to model idle intervals on the machines. Dummy jobs have zero-length operations on all machines, and it is allowed to assign several operations of a dummy job to the same cycle. Thus, in a feasible schedule with dummy jobs, all cycles are complete, but some of the m operations in a cycle may belong to dummy jobs.

Similar to the observation of Kouvelis and Karabati (1999) that introducing idle times in a synchronous flow shop may be beneficial, we show that a schedule for the relaxed open shop problem O \synm v, rel \Cmax consisting of more than n cycles may outperform a schedule for the nonrelaxed problem O\synmv\Cmax with n cycles.

EXample 2 Consider an example with m = 3 machines, n = 5 jobs and the following processing times:

j 1 2 3 4 5

P1 j 3 2 4 3 1

P2 j 5 3 2 3 1

P3j 4 5 1 4 1

In the upper part of Fig. 2 an optimal schedule for problem O3\synmv\Cmax with n = 5 cycles and a makespan of 18 is shown. For the relaxed problem O 3\synmv, rel\Cmax adding a single dummy job J6 leads to an improved schedule with 6 cycles and makespan 17 (see the lower part of Fig. 2).

The maximum total number of cycles of nonzero length is nm, which occurs if each of the nm "actual" operations is scheduled in an individual cycle. Then, in each of these nm

Ml Ja Ja Ji Js J2

M2 Ja Ji J2 Js Js

M3 Ji J2 Js Ja Jz

Mi J3 Ja Ji Ji Js Je

M2 Ji Ji J3 J2 Je Js

M3 Jl J2 Jb Ja J3 Je

—►

Fig. 2 An optimal schedule for O3|synmv|Cmax and an improved schedule for O3|synmv, rel|Cmax (with dummy job J6)

cycles one actual operation and m — 1 dummy operations are processed. To achieve a best schedule it is therefore sufficient to include n(m — 1) dummy jobs, each dummy job consisting of m zero-length operations. This implies that problem Om\synm v, rel\Cmax for a fixed number m of machines can be solved in polynomial time by the algorithm from Weiß etal. (2016).

For the two-machine case described in Sect. 2.1, if the actual jobs are numbered as 1,..., n, and the dummy jobs are numbered as n+1,..., 2n, then we apply the algorithm to the extended cost matrix W ' obtained from the n x n matrix W defined by (2), by adding rows and columns n+1,...,nm with entries

üi, i = 1,...,n, j = n + 1,...,2n, bj, i = n + 1,...,2n, j = 1,...,n, 0, i = n + 1,.. .,2n, j = n + 1,..., 2n.

Here combining an operation of an actual job (having processing time üi or bj) with a dummy job incurs a cycle of length üi or bj, while combining two dummy operations incurs an artificial cycle of 0 length, even if both operations belong to the same dummy job. For the case of multiple machines the cost matrix can be adjusted analogously, see Weiß et al. (2016) for details.

Clearly, for algorithmic purposes it is desirable to have the number of added dummy jobs as small as possible. As discussed in Waldherr et al. (2015), for the synchronous flow shop problem F ^ynm v, rel|Cmax, instances exist where for an optimal solution (n - 1)(m - 2) dummy jobs are needed. In the following we show that for the open shop problem O |synmv, rel|Cmax at most m — 1 dummy jobs are needed to obtain an optimal solution.

Theorem 3 There exists an optimal solution to problem O |synmv, rel|Cmax with at most m - 1 dummy jobs, so that the number of cycles is at most n + m - 1.

Proof Let S be an optimal schedule with f dummy jobs, f > m. We construct another schedule S with

Cmax(S) < Cmax(S) and % — 1 dummy jobs. Notice that it is allowed to assign several operations of the same dummy job to any cycle.

Case 1 If there exists a cycle I' which consists solely of dummy operations of the same job Jd e {Jn+1, Jn+2, ■ ■■■ Jn+%}, then that dummy job can be eliminated and S is found.

Case 2 If there exists a cycle I' which consists solely of dummy operations, some of which belong to different dummy jobs, then we can achieve Case 1 by selecting a dummy job Jd arbitrarily and swapping its operations from outside I' with the dummy operations in I'. The resulting schedule is feasible and has the same makespan.

Case 3 Suppose no cycle in S consists purely of dummy operations. Let I' be the shortest cycle and let v be the number of actual operations in I', 1 < v < m. We demonstrate that each actual operation processed in I' can be swapped with a dummy operation from another cycle. Consider an actual operation Oij in cycle I' with machine Mi processing job Jj. Select another cycle I" (its existence is demonstrated below) such that it does not involve an operation of Jj and has a dummy operation on Mi. Swap operations on Mi in I' and I", reducing the number of actual operations in I' by 1. Clearly, after the swap both cycles are feasible, because introducing a dummy operation into I' cannot cause a conflict, and because no operation of Jj was processed in I" before the swap. After the swap, both cycles I' and I" have either the same length as before or cycle I' becomes shorter. Performing the described swaps for each actual operation Oij in cycle I', we arrive at Case 1 or 2. A cycle I" exists since

- there are at least % cycles with a dummy operation on Mi (% > m) and those cycles are different from I';

- there are exactly m — 1 cycles with Jj processed on a machine that differs from Mi, and those cycles are different from I'. □

We continue by demonstrating that the bound m — 1 is tight.

Example 3 Consider an instance of problem O\synmv, rel|Cmax with m machines, n = m + 1 jobs and processing times pij = 2m for i = 1 ■■■■■ m, j = 1 ■■■■■ n — 1, and pin = 1 for i = 1,---, m.

An optimal schedule consists of m complete cycles of length 2m each, containing operations of the jobs {Ji, J2 ■■■■■ Jm} only, and m incomplete cycles with the single actual job Jm+1 grouped with m — 1 dummy jobs, see Fig. 3. The optimal makespan is C^ax = 2m2 + m. In any schedule with less than m — 1 dummy jobs, at least one operation of job Jm+1 is grouped with another operation of an actual job, the length of such a cycle being 2m. Thus, a schedule with less that m — 1 dummy jobs consists of at

Ml Jl J m J2

M2 J2 Ji J3 1

: : ... : \

Mm.-J Jm — 1 Jm — 2 •Jm

Mm Jm Jm — 1 Ji 1,

2m 2771^ + m

Fig. 3 An optimal schedule with 2m cycles, m of which are complete and m are incomplete

least m + 1 cycles of length 2m, so that the makespan is at least 2m (m + 1) > Cmax.

Notice that since our paper focuses on scheduling aspects, we have presented Theorem 3 in the scheduling language for the sake of consistency and self-containment. Knowing that O\synmv, rel\Cmax is equivalent to the max-weight edge coloring problem on the complete bipartite graph Km, n, we conclude this section by linking Theorem 3 to the results known in the area of max-weight coloring. It is known that an optimal max-weight edge coloring in an edge-weighted graph G can always be obtained using at most 2 A — 1 colors, where A is the maximum vertex degree of G, see for example Demange et al. (2002); de Werra et al. (2009). This bound is worse than the bound given in Theorem 3, as for a complete bipartite graph G = Km,n with m < n we have A = n, and therefore 2A — 1 = n + n — 1 > n + m — 1. However, for the vertex coloring version of max-weight coloring on a vertex-weighted graph G, Demange et al. (2002) show that an optimal max-weight vertex coloring can be obtained using at most A +1 colors. Note that the max-weight edge coloring problem on a graph H can be seen viewed as the max-weight vertex coloring problem on the line graph G = L (H ) of H. Then, since the line graph of Km,n has maximum degree A = n + m — 2, the bound A + 1 on the number of colors needed yields n + m — 1, which is equal to the maximum number of cycles stated in Theorem 3.

3 Scheduling with deadlines

In this section, we consider problem O\synmv, Cj < Dj |—, where each job Jj, 1 < j < n, has a given deadline Dj by which it has to be completed. We prove that finding a feasible schedule with all jobs meeting their deadlines is NP-complete in the strong sense even if there are only two machines and each job has only one nonzero processing time. Furthermore, we show that problem O2\synmv, Cj < Dj, Dj e {D', D"}\-, where the set of all deadlines is limited to two values, is at least NP-complete in the ordinary sense. The proofs presented below are based on the ideas of Brucker

et al. (1998) who established the complexity status of the parallel batching problem with deadlines.

Consider the 3-PARTITION problem (3-PART) known to be strongly NP-complete, cf. Garey and Johnson (1979). Givenaset Q = {1,..., 3q}, abound E and natural numbers ei for every i e Q, satisfying £ieQ ei = qE and E < ei < -f, can Q be partitioned into q subsets Qk, 1 < k < q, such

that X

ei = E ?

Based on an instance of 3-PART, we construct an instance I (q) of the two-machine synchronous open shop problem O2\synmv, Cj < Dj\— with n = 6q2 jobs, q deadlines and two machines, denoted by A and B. Each job Jjj has two indices j and l to distinguish between jobs of different types, j = 1, 2,...,2q and l = 1, 2,...,3q. We introduce

constants

T = Xu Tj = Xu w = q3 E ■

For each l, 1 < l < 3q, the processing times aj,l and bj,l of the jobs Jjl on machines A and B are defined as follows:

ajj = IW + (q - j)ei, aq+1,l = 0,

aj,i = 0,

bjj = 0 for 1 < j < q ;

bq+i,i = IW + qei ;

bji = IW for q + 2 < j < 2q.

The deadlines D j,l are set to

Dj,l = jTW + (jq2 - Tjq + Tj)E for 1 < j < q; Djl = qTW + (q3 - Tqq + Tq)E for q + 1 < j < 2q■

Throughout the proof we use the following terms for different classes of jobs. Parameter l, 1 < l < 3q, characterizes jobs of type l . For each value of l there are 2q jobs of type l, q of which have nonzero A-operations (we call these Ajobs) and the remaining q jobs have nonzero B-operations (we call these B-jobs). Among the q B-jobs of type l, there is one long B-job of type l, namely Jq+i,l with processing time lW + qel, and there are q - 1 short B-jobs of type l, namely Jq+2,l, Jq+3,l,..., J2q,l, each with processing time lW. Overall, there are 3q long B-jobs, one of each type l, 1 < l < 3q, and 3q (q - 1) short B-jobs, with q - 1 short jobs of each type l. Note that, independent of l,job Jj,l is an A-job if 1 < j < q, and a B-job if q + 1 < j < 2q.

With respect to the deadlines, the jobs with nonzero B-operations are indistinguishable. The jobs with nonzero A-operations have deadlines Djl depending on j; we refer to those jobs as component j A-jobs. For each j, there are 3q jobs of that type.

Lemma 1 If there exists a solution Qi, Q2,..., Qq to an instance of 3-PART, then there exists a feasible schedule for the instance I (q) of the two-machine synchronous open shop problem with q deadlines.

lW + (q-l)ei ) I1 lW + {q-l)ei )

I IW+qei IW

f IW + (q—2)ei ) I1 IW + (q—2)ei )

[ IW+qei AeQ2 V IW

component 1

component 2

(\ IW + (q-k)ei ) ( IW + (q-k)ei )

\ IW+qei IW > l€Q\Qk

component fe

Fig. 4 Schedule derived from a solution to 3-PART

f\ iw |\ /fWl\

!6Q\Q9

component <j

Proof We construct a schedule S* consisting of q components r1, r2,rq, each of which consists of 3q cycles, not counting zero-length cycles. In component rk, 1 < k < q, machine A processes 3q componentk A-jobs, one job of each type l, l = 1, 2,..., 3q. Machine B processes 3 long B -jobs and 3 (q — 1) short B-jobs, also one job of each type l, l = 1, 2,...,3q.

Within one component, every cycle combines an A-job and a B-job of the same type l, 1 < l < 3q. The ordering of cycles in each component is immaterial, but component rk precedes component rk+1, 1 < k < q — 1. If Qk = {li, l2, l3} is one of the sets of the solution to 3-PART, then the three long B-jobs Jq+1,;1, Jq+1,l2, Jq+1,;3 are assigned to cycle rk.

Finally, there are 3q2 cycles of length zero. We assume that each zero-length operation is scheduled immediately after the nonzero operation of the same job.

The resulting schedule S* is shown in Fig. 4.

It is easy to verify that if Q1, Q2,..., Qq define a solution to the instance of 3-PART, then the constructed schedule S* is feasible with all jobs meeting their deadlines. □

We now prove the reverse statement. The proof is structured into a series of properties where the last one is the main result of the lemma.

Lemma 2 If there exists a feasible schedule S for the instance I (q) of the synchronous open shop problem with q deadlines, then the following properties hold:

(1) each cycle of nonzero length contains an A-job of type l anda B-job of the same typel, l = 1, 2,..., 3q; without loss of generality we can assume that each zero-length operation is scheduled in the cycle immediately after the nonzero-length operation of the same job;

(2) no componentj A-job is scheduled on machine A before any componenti A-job, with 1 < i < j — 1 ; hence S is splittable into components r1,r2,...,rq in accordance with A-jobs;

(3) each component rj, 1 < j < q, defines a set Qj of indices that correspond to long B-jobs scheduled in rj; the resulting sets Q1, Q2,..., Qq define a solution to the instance of 3-PART.

Proof (1) In a feasible schedule S satisfying the first property, all cycles have a balanced workload on machines A and B: in any component rk, 1 < k < q, the cycle lengths are W, 2W, ..., 3qW, with the value qei or (q — k)ei added. Thus, the total length of such a schedule is at least q ■ TW. For a schedule that does not satisfy the first property, the machine load is not balanced in at least two cycles, so that the lW-part of the processing time does not coincide in these cycles. Thus, the total length of such a schedule is at least qTW + W = qTW + q3E. Since q > 1, the latter value exceeds the largest possible deadline

max {DjÀ = qTW + (q3 - Tqq + Tq)E,

1< j <2q,1</<3q * *

a contradiction.

Note that the above especially shows that zero-length operations are only paired in cycles with other zero-length operations. Therefore, we can assume without loss of generality that zero-length operations are scheduled immediately after the nonzero-length operations of the same job. Indeed, if this is not the case, we can change the order of cycles, and possibly the assignment of zero-length operations to the zero-length cycles in order to achieve the assumed structure, without changing the feasibility of the schedule.

(2) Consider a schedule S in which all component« A-jobs precede component«+1 A-jobs for u = 1, 2,...,i - 1, but after that a sequence of component A-jobs is interrupted by at least one component j A-job with j > i. Let the very last component A-job scheduled in S be Jiv for some 1 < v < 3q. Then the completion time of the cycle associated with Ji,v is at least iTW + W, where TW is a lower bound on the total length of all component« A-jobs, u = 1, 2,...,i, and W is the smallest length of a cycle that contains the violating componentj A-job. Since W is large, job Ji,v does not meet its deadline

D,v = iTW + (iq2 - Ttq + T)E,

a contradiction.

The second property implies that on machine A all componenti A-jobs are scheduled first, followed by all component2 A-jobs, etc. Thus, the sequence of jobs on

machine A defines a splitting of the schedule S into components r1, r2,...,rq.

(3) Given a schedule S satisfying the first two properties, we first define sets Q1, Q2,..., Qq and then show that they provide a solution to 3-PART.

Schedule S consists of components rj, 1 < j < q. In each component rj machine A processes all componentj A-jobs Jjj (1 < l < 3q), each of which is paired with a B-job of the same type l. Recall that a B-job Jq+1,l of type l is long, with processing time IW + qel. All other B-jobs Jjl, q+2 < j < 2q ,oftype l are short, with processing time lW. Considering the long B-jobs of component rj, define a set Qj of the associated indices, i.e., l e Qj if and only if the long B-job Jq+1,l is scheduled in component rj .Denote the sum of the associated numbers in Qj by e( Qj) := X le Qj el.

The length of any cycle in component rj is either aj,l = lW + (q - j)el if the componentj A-job of type l is paired with a short B-job of type l, or bq+1j = lW + qel if it is paired with the long B-job Jq+1,l. Then the completion time Crj of component rj, 1 < j < q, can be calculated as

Cpj = X(X[lw+qeiS [lw+(q-h)ei]

h=1 \leQh leQ\Qh

= £(TW + (q - h)qE + he(Qh)),

which for a feasible schedule S does not exceed the common deadline Djj of A-jobs in component rj, Djj = jTW + jq2E - TjqE + TjE = ZJh=1 (TW + (q - h)qE + hE). Notice that the deadline of any B-job in component Ej is not less than Djl.

Thus, for any j, 1 < j < q we get

Djj - Crj = X (TW + (q - h)qE + hE) h=1

(TW + (q - h)qE + he(Qh))

= h (E - e(Qh)) > 0.

If all inequalities in (8) hold as equalities, i.e.,

¿h (E - e(Qh)) = 0, j = 1, 2,...,q, h=1

then it is easy to prove by induction that E - e(Qh) = 0 for each h = 1,...,q and therefore the partition Q1, Q2,..., Qq of Q defines a solution to 3-PART.

Assume the contrary, i.e., there is at least one strict inequality in (8). Then a linear combination L of inequalities (8) with strictly positive coefficients has to be strictly positive. Using coefficients j - j+j for j = 1, 2,...,q - 1

and j for j = q we obtain:

(j - T+r) ±

h (E - e(Qh))

+-T h (E - e(Qh))> 0. q

It follows that q-1

0 < L = z h=1

h (E - e(Qh))

+-T h (E - e(Qh)) q

h (E - e(Qh)) T-hq

(1 - 1) \h q)

+-Y h (E - e( Qh )) q

= X (E - e(Qh)) = 0, h=1

where the last equality follows from the definition of E for an instance of 3-PART. The obtained contradiction proves the third property of the lemma. □

Lemmas 1 and 2 together imply the following result.

Theorem 4 Problem O2\synmv, Cj < Dj \- is NP-complete in the strong sense, even if each job has only one nonzero operation.

Similar arguments can be used to formulate a reduction from the PARTITION problem (PART) to the two-machine synchronous open shop problem, instead of the reduction from 3-PART. Notice that in the presented reduction from 3-PART all B-jobs have the same deadline, while A-jobs have q different deadlines, one for each component rj defining a set Qj . In the reduction from PART we only require two different deadlines D, D', one for each of the two sets corresponding to the solution to PART. Similar to the reduction from 3-PART, we define component A-jobs with deadline D and component2 A-jobs with deadline D' which define a splitting of the schedule into two components A, r2. For each of the natural numbers of PART we define one long B-job and one short B-job and show that the distribution of

the long jobs within the two components of the open shop schedule corresponds to a solution of PART. Omitting the details of the reduction, we state the following result.

Theorem 5 Problem O2\synmv, Cj < Dj, Dj e {D', D"}\ — with only two different deadlines is at least ordinary NP-complete, even if each job has only one nonzero operation.

At the end of this section we note that the complexity of the relaxed versions of the problems, which allow incomplete cycles modeled via dummy jobs, remains the same as stated in Theorems 4 and 5. Indeed, Property 1 of Lemma 2 stating that each nonzero operation of some job is paired with a nonzero operation of another job, still holds for the version with dummy jobs. Therefore, in the presence of dummy jobs a schedule meeting the deadlines has the same component structure as in Lemmas 1 and 2, so that the same reduction from 3-PART (PART) works for proving that O2\synmv, rel, Cj < Dj \— is strongly NP-complete and O2\synmv, rel, Cj < Dj, Dj e {D', D")\— is at least ordinary NP-complete.

Fig. 5 Constructing the graph G for problem AUX

vertices constitute a Hamiltonian path, ending at 0. As shown in Appendix 2, the two problems HAMILTONIAN PATH and AUX have the same complexity status. An example that illustrates graphs G', G and G is shown in Fig. 5; a possible Eulerian tour in ~G is e = (0, 1, 0, 2, 0, 3, 0,4, 2,4, 3, 2,

1,2,3,4,0 ), where the last n = 5 vertices form a Hamiltonian

Given an instance of AUX with n vertices V = {0, 1,..., n — 1} and arcs E, we introduce an instance of the synchronous open shop problem SO using the constants

4 Minimizing the total completion time

In this section, we prove that the synchronous open shop problem with the total completion time objective is strongly NP-hard even in the case of m = 2 machines. The proof uses some ideas by Rock (1984) who proved NP-hardness of problem F2\no — wait\X Cj. Note that the latter problem is equivalent to the synchronous flow shop problem F2\synmv\ ^ Cj.

For our problem O2\synmv\ £ Cj we construct a reduction from the auxiliary problem AUX, which can be treated as a modification of the HAMILTONIAN PATH problem known to be NP-hard in the strong sense (Garey and Johnson 1979).

Consider the HAMILTONIAN PATH problem defined for an arbitrary connected graph G' = (V', E') with n — 1 vertices V' = {1, 2,...,n — 1} and edge set E'. It has to be decided whether a path exists which visits every vertex exactly once. To define the auxiliary problem AUX, we introduce a directed graph G obtained from G' in two stages:

- first add to G' a universal vertex 0, i.e., a vertex connected by an edge with every other vertex; denote the resulting graph by G = (V, E);

- then replace each edge of graph G by two directed arcs in opposite directions; denote the resulting directed graph by ~G = (V, ~E).

For problem AUX it has to be decided whether an Eulerian tour e in G starting and ending at 0 exists where the last n

a = \E \/2, K = 8n, f = 4Ka2, L = 2n9f.

Furthermore, for each vertex v e V let d(v) = deg— (v) =

deg+ (v) be the in-degree deg^ (v) (the number of arcs enterG

ing v), which here equals its out-degree degi (v) (the number

of arcs leaving v). Note that a = £veV> d(v)/2.

In a possible solution to AUX, if one exists, every vertex v e V\{0} has to be visited d(v) times and each arc (v, w) e E has to be traversed exactly once. We introduce instance SO for problem O2\synmv\ £ Cj. For each vertex v we create d(v) vertex-jobs VeJ, Ve2,..., Vedv(v), one for each visit of vertex v in an Eulerian tour e, and for each arc (v, w) we create an arc-job Arvw. For vertex v = 0 we create d(0) vertex-jobs, as described, and additionally one more vertex-job Ve00 that corresponds to the origin of the Eulerian tour e. In addition to these 2a + 1 vertex-jobs and 2a arc-jobs, we create 2n9 + 1 "forcing" jobs F0, F1,..., F2n9 to achieve a special structure of a target schedule. We denote the set of jobs N. Their processing times are given in Table 1.

We call each operation with a processing time of L a "long operation" and each operation with a processing time of less than L a "short operation." Further, we refer to a job as a long job if at least one of its operations is long and as a short job if both of its operations are short.

The threshold value of the objective function is defined as 0 = 01 + 02, where

&1 = (8a2 + 2a)f + 4a2 K — 2^ vd (v) + n2,

Table 1 Processing times of the jobs in instance SO

d(O) + 1 jobs for vertex v = 0 d(v) jobs for each vertex I>e{i,2,...,n-1} one job for each arc (v,w) £ ~E forcing jobs

job 00 £ VeJ-.-Ve^-1 Vei---Ve^-1 VeT} Ar^n; Fo F1--F2n 9

time on Mi 0 Î + X" t + K+1 Ç + K- 2v Ç + K-2V + 1 £ + 2v L L

time on M2 i 4 L (: + 2v t + 2v Ç + K- 2w 0 L

02 = 2(n9 + 1) ((n9 + l) L + 4af + 2aK + n) .

As we show later, in a schedule with £ Cj < 0, the total completion time of the short jobs is 01 and the total completion time of the long jobs is 02.

Theorem 6 Problem O 2\synmv\£ Cj is strongly NP-hard.

Proof Consider an instance AUX and the corresponding scheduling instance SO. We prove that an instance of problem AUX has a solution, if and only if the instance SO has a solution with £ Cj < 0.

Let the solution to AUX be given by an Eulerian tour e = (v0, v1,...,v2a) starting at v0 = 0 and ending at v2a = 0 such that the last n vertices form a Hamiltonian path. The solution to problem SO consists of two parts and it is constructed as follows:

- In Part 1, machine M\ processes 2a + 1 vertex-jobs and 2a arc-jobs in the order that corresponds to traversing e. Machine M2 starts with processing the forcing job F0 in cycle 1 and then proceeds in cycles 2, 3,..., 4a +1 with the same sequence of vertex-jobs and arc-jobs as they appear in cycles 1, 2,..., 4a on machine Mi. Notice that in Part 1 all vertex- and arc-jobs are fully processed on both machines except for job Ve0(v) which is processed only on M1 in the last cycle 4a + 1.

- In Part 2, machine M1 processes the forcing jobs F0, F1,..., F2n9 in the order of their numbering. Machine M2 processes in the first cycle of Part 2 (cycle 4a + 2 ) the vertex-job Ved(v) which is left from Part 1. Then in the remaining cycles 4a + 3,..., 4a + 2 + 2n9, every job Fi (i = 1,..., 2n9) on M1 is paired with job Fi+1 on M2 if i is odd, and with job Fi-1, otherwise.

In Fig. 6 we present an example of the described schedule based on graph G of Fig. 5. Notice that there are n = 5 vertices in "G, and parameter a equals 8. Traversing the Eulerian tour e = (0, 1, 0, 2, 0, 3, 0,4, 2,4, 3, 2,

1,2,3,4,0 ) incurs the sequence of vertex-jobs and arc-jobs

(Ve0, Ar01, Ve1, Arw, Ve£, Ar02,..., Ve2, Ar^, Ve2, Ar23, Ve3, Ar34, Ve4, Ar40, Ve4). There are 2a + 1 = 17 vertex-jobs, 2a = 16 arc-jobs, and 2n9 + 1 = 2 x 59 + 1 jobs Fi, so

that all jobs are allocated in 34 + 2 x 59 cycles. The schedule is represented as a sequence of cycles, where the operations on machines M1 and M2 are enframed and the lengths of the corresponding operations are shown above or below. Operations of equal length in one cycle are shown as two boxes of the same length; the sizes of the boxes of different cycles are not to scale.

We demonstrate that the constructed schedule satisfies X Cj = 0. Observe that most cycles have equal workload on both machines, except for the n cycles that correspond to the vertex-jobs of the Hamiltonian path; in each such cycle the operation on M1 is one unit longer than the operation on M2.

First consider the short jobs. The initial vertex-job Ve0 that corresponds to the origin v0 = 0 of e = (v0, v1,..., v2a) completes at time f. Each subsequent vertex-job that corresponds to vi, 1 < i < 2a - n, where we exclude the last n vertices of the Hamiltonian path, completes at time (2i + 1)f + iK. Consider the next n - 1 vertex-jobs vt with 2a - n + 1 < i < 2a - 1 (excluding the very last vertex-job Ved(0) as it is a long job); every such job vi completes at time (2i + 1)f + iK + (n + i - 2a).

The remaining short jobs correspond to arc-jobs. The completion time of the i-th arc-job Arvi-1vi is 2if + iK - 2vt for 1 < i < 2a - n and 2if + iK - 2vi + (n + i - 2a) for 2a - n + 1 < i < 2a.

Thus, the total completion time of all short jobs sums up

2a - n

f + X [(2i + 1)£ + iK] i = 1

+ £ [(2i + 1)f + iK + (n + i - 2a)]

i =2a-n+1 2a —n

+ [2if + iK — 2vt] i=1

+ ^ [2i f + iK — 2vi + (n + i — 2a)]

i =2a —n+1

2a — 1 2a

f + X (2i + 1)f + X 2i f

Part 1:

Cycle 1 Cycle 2

Cycle 3

S + K-2

Cycle 4

Cycle 5

Cycle Í

Cycle 7

Í + K-4

Cycle 8

Cycle 9

Ç + K

Cycle 10

Cycle 11

Í + K- 6

Cycle 12 € + 6

oo Ar0i Veî Ar10 Ve¿ Ar02 Ve¿ Ar20 Veg Ar03

F0 Vefj Ar01 Ve\ Ar10 Ve¿ Ar02 Ve¿ Ar20 Veg

Í + K- 2

C + Jf

Ve¿ Ar30

Ar03 Ve¿

Í+K-6 €+6

Cycle 13

Cycle 14

2Î+JC

Cycle 15

S + iC-8

Cycle 16

Cycle 17

Í+JC-4

Cycle 18

Cycle 19

Í + JC-8

2 Í+K

Cycle 20 Í + 8

Cycle 21

Í+JC-6

Cycle 22 « + 6

Veg Ar04 Ve¡ Ar42

Ar30 Veg Ar04

Í+K-8

2Z+K Cycle 23 Cycle 24

t + K-A Í+4

Ve2 Ar24

Ar42 Ve2

$+K-4 «+4

Ve4 Ar43

Ar24 Ve4

Í+JC-8 «+8

Ve3 Ar32

Ar43 Vei

Í+X-6 Í+6

2 Í+K

Ve2 Ar21

Ar32 Ve2

2£+K Cycle 25

Z + K- 1

Cycle 26

Cycle 27

í+if-3

Cycle 28

Cycle 29

Ç + K- 5

Cycle 30

Cycle 31

Cycle 32 € + 8

Cycle 33=4(7 + 1

e+jf+i

Veï | Ar12 Ve2 | Ar23 Veg | Ar34 Vei 1 Ar40 Veg

Ar21 Ve{ Ar12 Ve| Ar23 Ve| Ar34 Ve4 Ar40 |

Z + K-2

Í+K-4

i+iC-6

Part 2:

4er + 2 Cycle 34

2Í+X+1

Cycle 35

Cycle 36

2Ç+K+1

Cycle 35

Cycle 36

fi f2 f3 fa

Veg f2 fi f4 f3

L -v-' l l l L

/•'], I'.j pair of length 2L /-'-j, pair of length 2L

Fig. 6 An optimal solution to SO

24+Jf+l

Cycle 34+2*5 -1

2Í+X+1

4u + 2 + 2 • n Cycle 34+2-51 L

F2n*-1 F^

F1 „9 F2n«-1

F'2n9_1,F2ng pair of length 2L

■2a -1

TiK + ZiK

Zi + Zi i=1 i=1

= (8a2 + 2a)l; + 4a2 K + n2 - 2 ^ vd (v) = 0

i=1 1 •

Here we have used the equality

vi = vd(v)

which holds for theEulerian tour e = (v0, vi,..., v2a) with vi e V.

Next, consider the completion times of the long jobs. The second operations of jobs Ve0(0) and F0 appear in cycle 4a + 2; all other long operations are scheduled in cycles 4a + 3,..., 4a + 2 + 2n9. There is a common part of the schedule, with cycles 1, 2,..., 4a + 1 that contributes to the completion time of every long job; the length of that common part is

A = 4a$ + 2a K + n.

Then the first two long jobs, F0 and Ve^(0), are both completed at time A + L and for i = 1,..., n9 the completion time of each pair of jobs F2i-1 and F2i is A + (2i + 1)L. Thus, the total completion time of the long jobs sums up to

2 (A + L) + 2 ^ [A + (2i + 1)L] i=1

= 2A(n9 + 1) + 2(n9 + 1)2 L = 2(n9 + 1)[(4af + 2a K + n) + (n9 + 1)L ] = 02

(9) (10)

and therefore the total completion time sums up to 0 = 0i + 02.

Now we prove that if an instance of AUX does not have a solution, then also SO does not have a solution with £ Cj < 0. Suppose to the contrary that there exists a schedule with £ Cj < 0 and let S be an optimal schedule.

Part 1:

Cycle 1 0

Cycle 2 £

Fo * oc

Cycle 3

i + Jf-2«!(+l)

Z+K-2V!

Cycle 4 «+2«i

2£+ii(+l)

Cycle 5 £ + iC-2u2( + l)

(+K-2v2

Cycle 6 £

2e+K(+i)

Cycle 4ct — 1

Cycle 4<r

2£+X(+l)

Cycle 4ct + 1

S+JC+i

Ve* U2.T-1 Arî>2„-l0

Ar Ve*

Ç+K-2V2„_1

Î + K

£+iC+l

Fig. 7 Structure of schedule S

Such a schedule satisfies the following structural properties, see Appendix 2 for a proof.

1. In each cycle in S, both operations are either short or long.

2. All long operations are scheduled in the last 2n9 + 1 cycles. This defines the splitting of schedule S into Parts 1 and 2, with cycles 1, 2,..., 4a +1 and 4a + 2, ...,4a + 2 + 2n9.

3. The sum of completion times of all long jobs is at least

4. In S, machine M1 operates without idle times.

5. In Part 1 of S, job Ve0 is processed in the first two cycles

which are of the form

eo oo *

Fo eo oo

represents a short operation. While the order of these two cycles is immaterial, without loss of generality we

assume that

precedes

; otherwise the

cycles can be swapped without changing the value of

6. The two operations of each vertex-job and the two operations of each arc-job are processed in two consecutive cycles, first on Mi and then on M2.

7. In Part 1 of S, machine M1 alternates between processing arc-jobs and vertex-jobs. Moreover, an operation of a vertex-job corresponding to v is followed by an operation of an arc-job corresponding to an arc leaving v. Similarly, an operation of an arc-job for arc (v, w) is followed by an operation of a vertex-job for vertex w.

By Property 6, the same is true for machine M2 in Part 1 and in the first cycle that follows it.

8. The first arc-job that appears in S corresponds to an arc

leaving 0. Among the vertex-jobs, the last one is Ve0

Properties 1-2 allow the splitting of S into two parts. Part 2 plays an auxiliary role. Part 1 is closely linked to problem AUX.

The sequence of arc- and vertex-jobs in Part 1 of S defines an Eulerian tour in G. Indeed, all arc-jobs appear in S and by Property 7 the order of the arc- and vertex-jobs in S defines an Eulerian trail in G. Since for every vertex v, its in-degree equals its out-degree, an Eulerian trail must be an Eulerian tour. Denote it by e = (v0,v1, ...,v2a). Due to Property 8 and by the assumption of Property 5 the Eulerian tour e starts and ends at v0 = 0.

In Fig. 7 we present the structure of Part 1 of schedule S, where Ve* represents one of the vertex-jobs Vev, Ve2,..., Ve„(v), with processing time f + K — 2v + 1or f + K — 2v on machine M1, depending on whether the upper index is d(v) or a smaller number. Part 2 is as in the proof of "

Notice that all operations of the short jobs appear only in Part 1 of the above schedule, with one short job completing in each cycle 2, 3,...,j + 1. In each cycle of Part 1, both operations are of the same length, except for the n — 1 cycles where the vertex-jobs Ved<v), v e {1, 2,...,n — 1}, are scheduled on machine M1, and the final cycle of Part 1 where Ved0(0) is scheduled. In these cycles the operation on M1 is one unit longer than the operation on M2. Let

ft := \Vedv(v) | v = 1, 2,

,n - 1

be the set of the n — 1 jobs with one extra unit of processing. JobVef is not included in this set as its precise location is known by Property 8.

We show that for any Eulerian tour e = (v0, v1,...,v2a), the value of Xlj=1 Cj does not depend on the order of the vertices in e; it only depends on the positions of the n — 1 jobs from ft. In particular, we demonstrate that

Using the above properties we demonstrate that if problem AUX does not have a solution, then the value of X Cj in the optimal schedule S exceeds 0. Due to Property 3 it is sufficient to show that the total completion time Xjj=1 Cj of all short jobs exceeds 01. Let us assume that {1, 2,...,j} with j = 4a are the short jobs of the instance SO. This set consists of 2a short vertex-jobs (the long vertex-job Ve0(o) is excluded) and 2a arc-jobs.

jx ß+1

Y^Cj = Y + (j - £ + 2)x,, j=1 £=2

where Y = 01 — n2 is a constant, and xi e {0, 1} indicates whether some job from ft is allocated to cycle I or not.

The constant term Y is a lower bound estimate for ZjU Cj obtained under the assumption that one additional

Table 2 Summary of the results

Problem Complexity References

O\synmv\Cmax str. NP-h. Weiß et al. (2016)

Om\synmv\Cmax O(n)* Weiß et al. (2016)

O 2\synmv\Cmax O(n) Section 2

O2\synmv, Cj < Dj\- str. NP-c. Section 3

O2\synmv, Cj < Dj, Dj s {D', D"}\- NP-c. Section 3

O 2\synmv\Cj str. NP-h. Section 4

with a constant bounded by (m )

time unit for each job from & and also for job Ve0 is ignored. If we drop "+1" from the input data of the instance SO, then both machines have equal workload in every cycle. Job Ve0 contributes $ to Y. The job corresponding to vi, except for job Ve0(0) (which is a long job) contributes (2i + 1)$ + iK. The arc-job corresponding to (vi, vi+1) contributes 2i$ + iK — 2vi+i. Thus,

Y = f + ^ [(2i + 1)f + iK] + [2if + iK - 2vi+i] i=1 i=1

= (8a2 + 2a) f + 4a2 K - 2 ^ vd (v) = 01 - n2.

Consider now the effect of the additional time unit on machine M1 for each job from û and for job VeQ(0). If some û-job is allocated to a cycle t, then the additional unit of processing increases by one the completion time of every short job finishing in cycles t,t + 1,...,x + 1, and thus contributes (x + 1) - t + 1 to XX=1 Cj. This justifies formula (12).

As shown in the above template, each of the n — 1 jobs j e û can be scheduled in any odd-numbered cycle t e {3, 5,. .., x — 1}. Also, by Property 8, an additional time unit appears in cycle x + 1 due to the allocation of Ve 0(0) to machine M1, which affects the completion time of a short job in that cycle. Thus, the minimum value of ~Y!j=i Cj is achieved if all n — 1 jobs from û are allocated to the latest possible odd-numbered positions, i.e., to positions t = (x — 1) — 2i for i = 0, 1,...,n — 2. Together with an extra "1 " related to the allocation of Ve0(0) to cycle x + 1, this results in

^(x - I + 2) xe = 1 + Y ix - (X - 1 - 2i ) + 2]

= 1 + 3 + ••• + (2n — 1) = n2,

so that X lj=1 Cj is equal to 01 if jobs û are allocated to the latest feasible positions. Due to (12), any other allocation of jobs û, which does not involve the last n — 1 odd-numbered positions, results in a larger value of Xlj=1 Cj.

By the main assumption of the part AUX does not have a solution where the last n vertices form a Hamiltonian path. Therefore, the last n vertices of any Eulerian tour e = (v0, v1,..., v2a) have at least two occurrences of the same vertex v and therefore in the associated schedule, among the last n vertex-jobs there are at least two vertex-jobs Veiv, Vevj associated with v. Thus, it is impossible to have n — 1 jobs from & allocated to the last n — 1 odd-numbered cycles and to achieve the required threshold value &1. □

At the end of this section we observe that the proof of Properties 1-8 can be adjusted to handle the case with dummy jobs. Indeed, in an optimal solution of the instance, even if we allow dummy jobs, dummy operations are not allowed to be paired with actual operations of nonzero length (see Property 4). We conclude therefore that the complexity status of the relaxed problem is the same as that for the standard one.

Theorem 7 Problem O2\synmv, rel\ X Cj is strongly NP-hard.

5 Conclusions

In this paper we studied synchronous open shop scheduling problems. The results are summarized in Table 2. Note that the polynomial time results in lines 2 and 3 do not include presorting of all jobs.

All results from Table 2 also hold for the relaxed versions of the scheduling problems, in which cycles may consist of less than m jobs.

For problem O2\synmv\Cmax we proved a new structural property, namely the small block property. Using it, we formulated a much easier solution algorithm than previously known. Unfortunately, we were unable to prove an improved structural property for any fixed m > 2. In Table 2 we quote a previously known algorithm, which is based on the corridor property. Our result for two machines gives hope that this general result for fixed m may also be improved and highlights possible approaches for such an improvement.

The NP-completeness results of Sect. 3 imply that if instead of hard deadlines Dj soft due dates dj are given (which are desirable to be met, but can be violated), then the corresponding problems O \synmv\ f with the traditional regular due date-related objectives f such as the maximum lateness L max = max1< j <n {Cj —dj}, the number of late jobs 'YTj=1 Uj, or the total tardiness Z"j=1 Tj are NP-hard, even if there are only two values of the due dates, dj e {d, d'}. The corresponding problems become strongly NP-hard in the case of arbitrary due dates dj .

Finally, due to the symmetry known for problems with due dates dj and those with release dates rj, we conclude that problem O2\synmv, rj\Cmax is also strongly NP-hard and remains at least ordinary NP-hard if there are only two different values of release dates for the jobs.

In Sect. 4 we show that O2\synmv\ X Cj and its relaxed version are strongly NP-hard. Thus, due to the reducibil-ity between scheduling problems with different objectives, the open shop problem with synchronization is NP-hard for any traditional scheduling objective function, except for Cmax.

Overall the synchronized version of the open shop problem appears to be no harder than the classical version, with two additional positive results for it: 1) Om\synmv\Cmax is polynomially solvable for any fixed m while Om\\Cmax is NP-hard for m > 3 (Gonzalez and Sahni 1976); 2) O\synmv, n = n'\Cmax is polynomially solvable for any fixed number of jobs n' (due to the symmetry of jobs and machines), while O\n = n/\Cmax is NP-hard for n' > 3. Moreover, in a solution to O\synmv\Cmax with n < m all jobs have the same completion time, so that an optimal schedule for Cmax is also optimal for any other nonde-creasing objective f. It follows that we can solve problem O\synmv, n = n'\f, with a fixed number of jobs n', for any such objective f.

Finally, comparing the open shop and flow shop models with synchronization, we also observe that the open shop problem is no harder, with a positive result for Om\synmv\ Cmax with an arbitrary fixed number of machines m, while its flow shop counterpart Fm\synm v \ Cmax is NP-hard for m > 3, see Waldherr and Knust (2015).

Acknowledgments The work of S. Knust and S. Waldherr was supported by the Deutsche Forschungsgemeinschaft, KN 512/7-1. The work of N.V. Shakhlevich was supported by the EPSRC grant EP/K041274/1. We are very grateful for the comments of two anonymous reviewers who helped us to improve the presentation of the paper.

Open Access This article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecomm ons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.

6 Appendix 1: The proof of the small block

property (Theorem 1)

The general idea of the proof can be described as follows. Starting with an arbitrary optimal solution which does not satisfy the small block property, replace repeatedly each block of size s > 4 by two blocks of cumulative size s, one of which is small. The replacement is performed for the relaxed problem AP^=0, ignoring forbidden pairs F, but making sure that the cost of the new solution (possibly infeasible in terms of F) is not larger than that of its predecessor. Additionally, we keep 0-entries on the main diagonal unchanged, so that no new blocks of size 1 are created. As a result a new solution is constructed, feasible for AP^=0 , of no higher cost than the original one, consisting of small blocks only. If the constructed solution is infeasible for AP^, then at the next stage infeasible blocks of size 2 and 3 are replaced by feasible blocks, also without increasing the cost, achieving an optimal solution consisting of small blocks.

First we prove the possibility of block splitting (Lemma 3), and then explain how infeasible blocks can be converted into feasible ones (Lemmas 4,5 for blocks of size 2 and 3, respectively). It leads to the main result (Theorem 1) - the existence of an optimal solution consisting of small blocks of type (6).

For a block consisting of 1-entries in rows and columns {j1, j1 + 1,..., j1 + s — 1}, renumber those rows and columns as {j1, j2,..., js} with jt = j1 + i — 1, 1 < i < s. The cost associated with block Xh is defined as

) = ZZ'

,jujv Xjujv

u=1v=1

so that the total cost of solution X with blocks (5) is

(X) = £ w(Xh).

Lemma 3 If an optimal solution to problem AP^ contains a block Xy of size s > 3, defined over rows and columns {j1, j2, .., js}, then without increasing the cost it can be replaced by two blocks, one block of size 2 or 3 defined over rows and columns {j1, j2} or {j1, j2, j3}, and one block defined over the remaining rows and columns. Furthermore, if a diagonal entry xjk jk in the initial solution is 0, then in the modified solution Xjkjk is 0 as well.

Proof Given a solution, we identify the nonzero entries in columns j1, j2, and j3, and denote the corresponding rows by ja , jb, jc. For these indices we have

Xj, h 32 •■■ jt • • • js

Ji 0 0 ••■ 1 ... o

h 0 0 - 0 ... o

33 * 0 *

3s * 0 *

jl 32 ... jt . • js

jl 0 1 ... 0 ■ ■ 0

32 0 0 ... 0 . • 0

33 * 0 *

js * 0 *

Fig. 8 Transformation of block Xy into Xy

Furthermore, for nonzero entries in rows j1, j2, and j3, we denote the corresponding columns by jt, ju, jv and have

The proof is presented for the case

X j 1 j 1 = X j j = X

v so that w (x^ < w (Xy) by the

Notice that the case xj1, j1 = 1 contradicts the assumption that block Xy is large. In the case of xj2 j2 = 1 we replace block Xy by block Xy as shown in Fig. 8. Here the 1-entries which are subject to change are enclosed in boxes and * denotes an arbitrary entry, 0 or 1. This transformation involves 4 entries in rows {ji, j2} and columns {j2, jt}. Notice that the marked 1-entries in the initial block Xy belong to a diagonal of type /, while the marked 1-entries in the resulting block Xy belong

to a diagonal of type Monge property.

In the case of xj1 j1 = xj2j2 = 0, xj3j3 = 1, at least one of the values, a or t, is larger than 3 (a = 3 or t = 3 is not possible for xj3j3 = 1; a < 2 and t < 2 is not possible since block Xy is large). If t > 3, then the transformation is similar to that in Fig. 8: it involves 4 entries in rows {j1, j3} and columns {j3, jt}. Alternatively, if a > 3, then the transformation involves 4 entries in rows {j3, ja} and columns {j1, j3}. In either case, the 1-entries in the initial solution belong to a diagonal of type / and to a diagonal of type \ after the transformation, so that the cost does not increase by the Monge property.

Thus, in the following we assume that condition (15) holds.

Case t = 2, or equivalently Xj1 j2 = 1. This implies b = 1. If a = u, then the transformation from Xy to Xy shown in Fig. 9 creates a small block of size 2 without increasing the cost.

jb,j 1 h

Ji 0 0

Jt. j->.

3s 0 0

ja H 0 ■ 0 0

js 0 0 • 0 *

ji Jt. ii • ju js

jb, jl 0 1 ■ 0 0

32 0 0 0 0

ja 0 0 ■ 0 0

js 0 0 • 0 *

Fig. 9 Transformation of block Xy into Xy

(a) 3-u 7l jt io (b) jl

ja 5 jl 1 1 Jl 0

J2 1 0 a, 32 1

(c) jl it i?. ju ■Is

jl 0 1 0

j2 0 0 1

ja 1 0 0

Fig. 10 Cases where t = 2 and a= u < 3: (a) a u=

u = 2, (c) a = u= 3

J t.Ju _¿2_

Consider the case a = u and notice that we can assume a = u > 3. Indeed, cases a = u = 1 and a = u = 2 cannot happen as the corresponding assignment is infeasible (see Fig. 10a, b), and in case a = u = 3 the block is already small (see Fig. 10c). For a = u > 3 the transformation illustrated in Fig. 9 is not applicable as it results in a new diagonal entry Xjaja = 1. Instead, we perform the two transformations from Xy to Xy and then to Xy shown in Figs. 11 and 12, creating eventually a small block of size 3.

Observe that both of the values, c and v, are different from a = u. Note further that we have c = 1 as t = 2, c = 2 as u > 3, and c = 3 due to (15). Similarly v = 1 as a > 3, v = 2ast = 2, and v = 3 due to (15). Thus c > 3and v > 3. The relationship between a = u and c is immaterial, as the above transformations work in both cases, a = u < c and a = u > c. Similarly, the relationship between a = u and v is immaterial as well. Moreover, the presented transformation works for either case, c = v or c = v.

Case a = 2 is similar to the case of t = 2 since the X-matrices for these two cases are transposes of each other. Recall that whenever the swaps are done in the case of t = 2, the 1-entries on a diagonal of type / become 0-entries, while

xy jl jt, .72 33 ■ .7 • jv

jb, jl 0 1 0 • • 0 • ■ 0

h 0 0 0 • ■ M • • 0

33 0 0 0 ■ • 0 ■ • 1

3u i 3a. 1 0 0 • • 0 • • 0

jc 0 0 0 • • 0 • ■ 0

xa jl jt, jl 33 ■ ,7\. • jv

jb,jl 0 1 0 • • 0 • • 0

32 0 0 M • • 0 • • 0

33 0 0 0 • • 0 • • 1

3u;3a 1 0 0 • • 0 • ■ 0

jc 0 0 0 • • 0 • • 0

Fig. 11 Transformation from Xy to Xy

xy jl 3t, .72 j3 ... 3a< . ■ ■ jv

jb, jl 0 1 0 ... 0 • ■■ 0

32 0 0 1 ... 0 • •• 0

33 0 0 0 ... 0 ■ ■■ 0

3u,3a 0 0 0 ... 0 • 0

jc 0 0 0 ... 1 . •• 0

xy jl jt, .72 j3 ... j"' . ■ ■ jv

jb, jl 0 1 0 ... 0 • ■■ 0

j2 0 0 1 ... 0 • •• 0

j3 1 0 0 ... 0 ■ ■ ■ 0

3u,3a 0 0 0 ... 0 • •• 0

jo 0 0 0 ... 1 . •• 0

12 Transformation from Xy to Xy

Xy jl j2 ... jt ■ • • ju

jl 0 0 ■ • 1 ... o

j2 0 0 ■•• 0 ... 0

ja 0 0 ••• 0 ... 0

jb 0 0 - 0 ... 0

Xy jl j2 ... jt . • ju

jl 0 1 ... 0 • •• 0

j2 1 0 ... 0 • ■• 0

Fig. 13 Transformation from Xy to Xy

Fig. 14 Transformation from Xy to Xy

Xy jl j2 ... jt . ■ ju

jl 0 1 ... o ■ ■ 0

j2 1 0 ... o ■ • 0

ja 0 0 ... 0 • • 0

jb 0 0 ... 0 . 0

Xy jl j2 ... jt . • ju

jl 0 1 ... o • ■ 0

j2 1 0 ... o ■ • 0

ja 0 0 ... 0 . • 0

jb 0 0 ... 0 ■ ■ 0

the 0-entries on a diagonal of type \ become 1 -entries, so that the Monge inequality (3) is applicable. In the case of a = 2, the initial 1-entries in the transpose matrix also belong to a diagonal of type /, while the new 1-entries are created on a diagonal of type \.

Case a > 2 and t > 2 with a < b and t < u. Consider the transformation from Xy to Xy shown in Fig. 13. It uses the Monge property two times, once for the entries in rows {j2, ja} and columns {j1, ju}, and another time for the entries in rows {ji, jb} and columns {j2, jt}.

If a = u and b = t, then the resulting matrix Xy satisfies the conditions of the lemma and a matrix without changed diagonal entries and with a small block of size 2 is obtained.

Consider the case a = u or b = t. By the definition of the indices a, b, t, u, according to (13)—(14), we have a = b and t = u. The latter two conditions, combined with either a = u or b = t, imply a = t and b = u.

Then, after Xy is transformed into Xy, we perform one more transformation from Xy to Xy shown in Fig. 14. Then, the resulting matrix Xy satisfies the conditions of the lemma.

Xy j 1 h ■ • ju ■■■ jt

jl 0 0 • .. 0 ••■ 1

h 0 0 • .. 0 ... 0

Ja 1 0 • .. 0 ... 0

jb 0 1 ■ .. 0 ... 0

x; jl 32 ■■■ ju ■ ■ ■ jt

jl 0 0 ... 1 ... 0

ji 0 0 •■■ 0 ... 0

ja 1 0 ... 0 ... 0

jb 0 1 ... 0 ... 0

Fig. 15 Transformation from Xy to X*

Case a > 2 and t > 2 with a < b and t > u. We start with an additional preprocessing step shown in Fig. 15 replacing xit = X2u = 1 by 0-entries and xiu = X2t = 0 by 1-entries without increasing the cost.

In the resulting matrix X*, we interchange the notation of the columns jt and ju in accordance with definition (14) and proceed as described above for the case t < u. Since a > 2 and therefore u = 1, no new diagonal entry is produced in the preprocessing.

Case a > 2 and t > 2 with a > b. This case corresponds to the transposed of the picture in the previous case. We undertake a similar preprocessing step as before, to transform this case into one with a < b. □

Lemma 4 If a solution X contains an infeasible block of size 2, i.e., Xj1, j2 = xj2, j1 = 1 with at least one of the entries (ji, j2) or (j2, ji) belonging to F, then without increasing the cost it can be replaced by two feasible blocks of size 1, given by Xju j1 = 1 andxj2t j2 = 1.

Proof For the above transformation the cost does not increase due to the Monge property. As far as feasibility is concerned, by the definition of set F, there is exactly one forbidden entry in each row and each column. Thus, if (j1, j2) e F, then neither (j1, j1) nor (j2, j2) are forbidden. Similar arguments hold for (j2, j1) e F. □

Lemma 5 If a solution X contains an infeasible block of size 3, then that block can be replaced, without increasing the cost, by three feasible blocks of size 1, or by two feasible blocks, one of size 1 and another one of size 2.

Proof Let Xy be an infeasible block consisting of rows and columns j1 j2 and j3. The proof is presented for the case

Xj1 j1 = XJ3 j3 = 0; Springer

jl 32 jz ^(.11) jl 32 jz

jl 0 0 1 jl 0 1 0

h 1 0 0 32 0 0 1

j3 0 1 0 jz 1 0 0

Tr(III) jl 32 jz

jl 0 0 1

h 0 1 0

jz 1 0 0

Fig. 16 Blocks Xyr), Xylr) and Xy111}

Y(a) A-y jl J2 J3 x(b) jl J2 J3

jl 1 0 0 jl 0 1 0

32 0 0 1 J2 1 0 0

33 0 1 0 J3 0 0 1

x(c) jl 32 ja

jl 1 0 0

32 0 1 0

33 0 0 1

Fig. 17 Blocks Xya), Xyb) and Xyc)

otherwise Xy can be decomposed into smaller blocks. Under the above assumption, Xy is of one of the three types Xy1\ X(yf) or X(yn), shown in Fig. 16.

Notice that Xiy111 can be replaced by X(yI1 ^ without increasing the cost, using the Monge property, and so we only have to deal with Xy1 ^ and X(yII'), which are symmetric. We first demonstrate that each block, Xy1 ^ or X(yir), can be replaced by blocks X(f ), X^ or Xyc) shown in Fig. 17, without increasing the cost. Then we proof that at least one of those blocks is feasible.

The transformation of X(yI ) into X(ya) or X(yb) involves a quadruple of 1-entries, so that the cost does not increase due to the Monge property. Transforming X(yI ) into the diagonal (c)

solution Xy we achieve a minimum cost assignment for the Monge submatrix given by rows and columns {j1, j2, j3} (see, e.g., Burkard et al. 1996). The same arguments hold for the transformation of X(yI1 ^ into X(y\ Xyb), or Xyc).

In the following, we deal with feasibility. If the initial infeasible block is of type Xy1 then at least one of the pairs (j1, j3), (j2, j1), or (j3, j2) is forbidden. Therefore, at least one pair (j1, j1) or (j3, j3) is feasible. If (j]_, j1) is feasible, then block Xya) or Xy ) is feasible. Similarly, if (j3, j'3) is feasible, then block Xyb) or Xyc) is feasible.

Similar arguments can be used if the initial infeasible block is of type Xy1 ^. □

Combining Lemmas 3-5 and using them repeatedly we arrive at the main result of Theorem 1. Below we present the formal proof.

Proof of Theorem 1: Consider any optimal solution. Apply Lemma 3 repeatedly until all blocks are of size 1, 2, or 3. Since all diagonal 1-entries of the new solution are also present in the original solution, those entries are feasible. Therefore, all blocks of size 1 are feasible. By Lemmas 4-5 all blocks of size 2 or 3 are either feasible or can be converted into feasible blocks without increasing the cost. Thus, the resulting solution has blocks of size 1, 2, and 3, it is feasible, and its cost is not larger than the cost of the original optimal solution.

Finally, the only small blocks that are not of type (6), have three 1 's on the secondary diagonal, since other configurations of 0's and 1's combine blocks of type (6). Due to the arguments used in the proof of Lemma 5 with respect to block Xy//7), such blocks can also be eliminated, which concludes the proof.

7 Appendix 2: The proofs of the key statements from Section 4

We start Appendix 2 by summarizing the notions from graph theory required for Sect. 4. In an undirected graph G = (V, E) we define a trail of length k as a sequence of vertices (v0, v1,..., vk) with {vt, vt+1} e E for i = 0,...,k — 1. A path of length k is a trail of length k in which the vertices v0,...,vk are pairwise different. In a directed graph ~G = (V, ~E), a directed trail of length k is a sequence of vertices (v0, v1,..., vk) with v, vi+1) e E for i = 0,...,k — 1. A directed path is then defined similar to an undirected path. A Hamiltonian path (either directed or undirected) is a path of length | V | such that each v e V is contained in the path. An Eulerian trail (either directed or undirected) is a trail which uses every edge exactly once; it may use vertices multiple times if needed. An Eulerian tour is an Eulerian trail which starts and ends in the same vertex.

A graph G = (V, E) is connected if for any two different vertices v,w e V there exists a path from v to w in G. A directed graph G = (V, E) is strongly connected if for each pair of different vertices (v,w) e V x V there is a directed path from v to w in G .

In a graph G = (V, E) the number of edges incident with a vertex v e V is also called the degree of v, denoted by degG(v). For a directed graph lG, we distinguish between the out-degree degE (v) of a vertex v (the number of arcs

leaving v) and the in-degree degE (v) (the number of arcs

entering v).

In Sect. 4 we are given a connected graph G' = (V', E') with V' = {1, 2,...,n — 1}. To construct the graph G for problem AUX, we first construct the graph G = (V, E) by adding a universal vertex 0 which is connected by an edge with every vertex. In a second step, we construct a directed

graph E = (V, ~E) by replacing each edge {v, w}e E by two directed edges (v, w) and (w, v), one in each direction. Note that in G we have degE (v) = degE (v) for all v e V

by construction.

Lemma 6 The following statements are equivalent.

(1) There exists a Hamiltonian path in G'.

(2) There exists a Hamiltonian path in G ending in 0.

(3) There exists a directed Hamiltonian path in G ending in 0.

(4) There exists an Eulerian tour in G, starting and ending in 0, such that the last n vertices form a Hamiltonian path.

Proof The implications (1) ^ (2) ^ (3) are obvious. We prove that (3) ^ (4). Suppose there exists a Hamiltonian path h = (v0, v1,..., vn—1) in G with vn—1 = 0. Then create a graph G* by removing from —G all arcs that appear in h. By the properties of vertex 0, graph G* is still strongly connected. Furthermore, for each inner vertex v1 ,v2,..., vn—2 of h, its in-degree in G* still equals its out-degree, as one entering and one leaving edge is removed for each of them. Lastly note that for vn—1 = 0 we have deg+>(0) =

degE (0) + 1, as an arc entering 0 is removed, but not a leaving one. Similarly, for v0, deg-E (v0) = deg-E (v0) + 1, as an

arc leaving v0 is removed, but not the one entering v0.

We conclude that G* contains an Eulerian trail e*, that starts in 0 and ends in v0. Then the concatenation e = e * o h starts and ends in 0 and its last n vertices form a Hamiltonian path h.

It remains to prove (4) ^ (1). Let e be an Eulerian tour in E, starting and ending in 0, such that the last n vertices form a Hamiltonian path, and let that path be h = (v0, v1,..., vn—1) with vn—1 = 0. Notice that the vertex 0 appears only once in h. Then h* = (v0, v1,..., vn—2) is a path in G. Since h* consists of all n — 1 vertices of G, h* is a Hamiltonian path in G□

The remainder of the appendix deals with Properties 1-8 from the proof of Theorem 6. These properties characterize the structure of an optimal schedule S for instance SO, under the assumption that X Cj < & for that schedule.

Lemma 7 An optimal schedule S for instance SO with ZC} < & satisfies Properties 1-8.

Proof Property 1 In each cycle in S, both operations are either short or long.

Assume the opposite and let s be the first cycle that contains a short and a long operation. Since the number of long operations is even, there is at least one further cycle t which

< (i - s - 1)L t

<Ç+K+1

Fig. 18 Creating a cycle of long operations and a cycle of short operations if Js = Jt and js = jt

contains operations of both types and in which the long operation is on a different machine than in cycle s. In the following, assume that long operations are on machine M2 in cycle s and on machine Mi in cycle t ; the alternative case is similar. Let Js and js be the jobs in cycle s, with the operation of Js being long and the operation of js being short. Let Jt and jt be the jobs in cycle t, with the operation of Jt being long and the operation of jt being short.

Assume first that Js = Jt and js = jt. Construct a new schedule S' by swapping the operations on M2, see Fig. 18. Then, the length of cycle s in S' decreases by at least L - (Ç + K + 1) while all other cycles keep their lengths unchanged. The completion time of job Js either decreases, if its second operation is in cycle after t, or it increases by at most (Ç + K + 1) plus the total length of cycles s + 1,...,t. Thus, C J - Cjs < (t - s - 1)L + (Ç + K + 1). For all other jobs that finish in cycle s or later, the completion times decrease by at least L - (Ç + K + 1). As there are at least t - s + 1 cycles in the tail part of the schedule, starting from cycle s, this affects at least t - s +1 jobs. Thus, the difference in total completion time is

Y^(Cj-Cj) < (t-s- 1)L + + K +1)

+ X (Cj - cj )

j S N\{ Js }

< (t - s - 1)L + (Ç + K + 1) -(t - s + 1)(L - (Ç + K + 1))

< -2L + |N|(f + K + 1),

where |N| is the the number of jobs in the instance SO or equivalently the number of cycles. To show that we get an improved solution Sj, we prove that

-2L + |(f + K + 1) < 0 using the estimate on a = \ E |/2, n < a < n2 (for n > 2),

< (s-r-lKi + Jf + l)

js J.

jt Jr

S t U

js Js 1 ... Ju

Js it *

<(u-t- -1 )L

8 t u

j. Ju Js

jt Js *

Fig. 19 Creating a cycle of long operations and a cycle of short operations if Js = Jt, js = jt and (a) there is a long operation in cycle r, r < s, (b) there is no long operation in any cycle r, r < s, but there is a long operation in cycle u, u > s

combined with the definitions of \N, L and K: K = 8n,

N |= 2n9 + 4a + 2 < 2n9 + 4n2 + 2, f = 4Ka2 = 32na2 < 32n5,

L = 2n9f = 2n9 ■ 32na2 > 64n12 > 576n10 (for n > 3).

Indeed,

-2L + |N|(f + K + 1) < < —2n9f + 2n9(K + 1) + (4a + 2)(f + K + 1)

< —576n10 + 2n9(8n + (4n2 + 4)(32n5 +

< —576n10 + 18n10 + 8n2 ■ 41n5 < 0.

+ 1) 8n + 1)

Thus, swapping the operations leads to a smaller total completion time, contradicting that S has minimal total completion time.

Consider the case Js = Jt, js = jt and assume first that there are other long operations scheduled before s. The case where there is no other long operation scheduled prior to cycle s is discussed afterwards. Let r be the last cycle before s in which a long operation is scheduled, r < s. Since s is the first cycle that contains a short as well as a long operation, both operations in cycle r are long. In this case construct S' by exchanging in cycles r, s, and t the three operations on machine M2, as shown in Fig. 19a. As a result, the completion time of job Jr either decreases, if the last operation of that job is in a cycle after cycle t, or it increases by at most (s — r)(% + K +1) + (t—s)L, where the first term represents the estimate

on the length of short cycles r +1,..., s in S' and the second term estimates the length of cycles s+1,...,t, which may be short or long. For all other jobs, including job Js, that finish in cycle s or later, their completion times decrease by at least L — (Ç+K +1 ). Note that there are at least t - s+2 such jobs. Thus,

J^iC'j — Cj) < [(s — r+ K + 1) + (t — s)L]

— (t — s + 2)( L — (Ç + K + 1)) = —2L + (t — r + 2)(f + K + 1) < 0,

r 3

Ml in js

M2 jr* J,

r r + 1 s + 1

Ml ir, js Jt

M2 J. jr2 J.

jr, j»

j. jrz

S 8 + 1

t+1 Jt J.

T — 1

Ml js ... Jt 1 ... X jr,

M2 J, js V jr,

where the last inequality can be proved as a slight modification of (16).

Assume now that there is no long operation scheduled prior to cycle s and let u > s be the first cycle that contains a long operation of some job Ju on the same machine as the long operation in cycle t. Construct S' by swapping the M1-operations in cycles t and u and the M2-operations in cycles s and t, see Fig. 19b for an example with u > t. The completion time of job Js (or job Ju if s < u < t) increases by at most |u - 11L. For the remaining jobs scheduled in the tail part of the schedule, starting from cycle s, their completion times reduce by at least L -(f+K+1). Again, using the evaluation from above, this leads to a decrease in the total completion time,

^(Cj - Cj) <|u - t|L - (max {u, t} - s + 1)

x (L - + K + 1)) = - (min {u, t} - s + 1) L

+ (max {u, t} - s + 1) + K + 1)

< -2L +|N| (% + K + 1)(1<) 0.

In all previous cases a better schedule S' is constructed by grouping two short operations js and jt in one cycle. Next, consider js = jt and first assume that there are other short operations scheduled in some cycle r < s. Since s is the first cycle that contains a short as well as a long operation, both operations in cycle r are short. Construct a schedule Sj as illustrated in Fig. 20a. Then, the completion time of job js decreases by at least 2(L - (% + K + 1)), as both its operations were paired with long operations before and are now paired with short ones. Further, the completion times of all jobs that were completed in cycles r, r + 1, ..., t - 1 in S, increase by at most (^ + K + 1) and the completion times of all jobs that are completed in cycle t or later decrease by at least L - (£ + K + 1). Thus,

Fig. 20 Creating a cycle of long operations and a cycle of short operations if Js = Jt, js = jt and there is a cycle r with two short operations, (a) r < s, (b) r > s

Y.(Cj - Cj) < -2(L - (^ + K + 1))

+ (t - r)($ + K + 1) - (L - ($ + K + 1)) < -3L + (t - r + 3)(M + K + 1) < 0,

where the last inequality can be proved similar to (16).

Consider now the case where r > s and assume additionally that both operations in cycle r are short (see Fig. 20(b) for an example of r > t > s). In this case, the completion times of job js and all jobs that finish in cycle s or later, except for job Js, decrease by at least L - 2(% + K + 1). The completion time of job js decreases further by the total length A of cycles s + 1, ..., t - 1, while the completion timeofjob Js may increase by at most 2 (f + K + 1) plus A, again leading to a decrease in the total completion time:

Z(Cj - CJ)

< -((max{t, r}- s) ■ (L - 2(f + K + 1)) - A +2(f + K + 1) + A

< -2(L - 2(f + K + 1)) + 2(f + K + 1)

= -2L + 6(f + K + 1) < 0,

where the last inequality follows from (16) since 6 < |N | = 2n9 + 4a + 2.

The only remaining case with js = jt is where no cycle r exists such that both operations in r are short, i.e., all short operations are paired with long operations. In this case, for cycle s with a short operation on M1 and a long operation on M2, we select a cycle t' similar to t, with a short operation on M2 and a long operation on M1, t' = t (such a cycle always exists for n > 2). Then the two short operations in cycles s

s s + 1

Ml Js, J(>+l)i

s t-1 t

Mi J(.S+i)l Jt, Js,

M2 Jt, Jss

Fig. 21 Moving long cycle s after a sequence of short cycles U {s + 1.....i}

and t' belong to different jobs, and the case reduces to one of the cases with js = jt considered before.

In case that js = jt and Js = Jt we can first swap one of the long operations with a long operation in another cycle, as described for Js = Jt, and afterwards continue with moving the two short operations to the front of the schedule, as described for js = jt, again leading to a decrease in the total completion time. Therefore, in an optimal schedule there is no cycle consisting of a long and a short operation.

Property 1 is proved. From now on we refer to cycles as short or long assuming that there are no "mixed cycles" in an optimal schedule.

Property 2 All long operations are scheduled in the last 2n9 + 1 cycles. This defines the splitting of schedule S into Parts 1 and 2, with cycles 1, 2,...,4a + 1 and 4a + 2,..., 4a + 2 + 2n9.

Let U = (s +1,..., t ) be the last sequence of short cycles and let s be a long cycle that precedes U . Assume first that | U | > 2. Then, as cycles in U are the last short cycles, at least |U| — 1 jobs finish within U (U may contain the two short operations of jobs Ve0(0) and F0 for which their respective second, long operations may be scheduled in later cycles). Construct a schedule S' by moving the long cycle s after U, see Fig. 21. Then the completion times of at least |U | — 1 jobs decrease by L while the completion times of the two jobs scheduled in cycle s in S increase by at most | U | (M + K +1 ),

— Cl) <— (|U| — 1) L + 2 |U| (M + K + 1)

= L — |U| (L — 2(M + K + 1)).

Using conditions |U | >2 and L — 2(M + K + 1)> 0 (which can be proved in the same way as (16)) we deduce

Y^(Cj — Cj) < L — 2 (L — 2(M + K + 1))

= — L + 4(M + K + 1).

The last expression is negative, again by the same arguments as (16). Thus, we get a contradiction to the optimality of S.

If |U| = 1 and the short cycle in U is different from M + K + 1

Ve Ve0

M+K +1

then at least one job, different from Vep(0) and F0, finishes in U. In this case the previous transformation reduces the completion time of at least one job by L, while the completion times of the two jobs scheduled in cycle s in S increase by at most + K + 1),

Y^iC'j - Cj) — —L + 2(f + K + 1) < 0,

where the last inequality can be proved in the same way as (16).

Consider now the case with U consisting of only one short cycle of the form (22). Notice that such a cycle is avoided in the optimal solution presented in Fig. 6.

Let U be the last sequence of short cycles before U and assume first that U is preceded by some long cycles. Clearly U does not contain short operations of jobs F0 and Ve0(0), as they appear in U. Since no other job consists of both, long and short operations, at least |U| short jobs finish within U. Then the arguments presented in the beginning of the proof of Property 2 are applicable for the set of cycles U used instead of U.

Lastly, consider the remaining case with U consisting of only one short cycle of the form (22) and there are no other short cycles in the preceding part of the schedule that follow a long cycle. Then, the first 4a cycles are short and the cycle (22) appears among the last 2(n9 + 1) cycles. Using pair-wise interchange arguments it is easy to make sure that in an optimal schedule, the latter cycles are of the form shown in Fig. 22, where without loss of generality jobs Fi, except for F0, are renumbered in the order they appear in schedule S on machine M\.

In Fig. 22, t is the number of jobs from the set {Fx, F2,.... F2n9} completed before cycle (22), 1 — t — 2n9. Let A be the total length of the first 4a short cycles. If the length of cycle (22) was L, then the total completion time of all long jobs would be

+ 1)^ + 2L Y 2i = 2(n9 + 1) + (n9 + 2)L) .

In reality, the length of cycle (22) is less than L by the amount L — (^ + K + 1), so that completion times of the jobs that appear after Ft—1, Ft should be adjusted. The number of

Fr+1 Fr+2

Ft+2 Fr + 1

F2n<>-1 F2ti»

F2 F2n9 — 1

Fi.Fq pair of length 2L

F3'F4 Pair of length 2L

Ft-!,FT P»ir of length 2L

VefV0 pair of length ($+.ff+l)+.L

iV+l>iV+2 Pair of length 2L

2n® —1 2»® pa,r of length 2£<

Fig. 22 A special short cycle appearing among the last 2(n + 1) cycles

jobs completed in the corresponding tail part of the schedule is 2(n9 + 1) - t, so that

£ Cj = 2(n9 + 1) (A + (n9 + 2)l)

long jobs

- (2(n9 + 1) - t)(L - f - K - 1) = 2(n9 + 1) ((n9 + 1)L + A + f + K + l) + t(L - f - K - 1).

We demonstrate that the objective value for schedule S exceeds the given threshold &, using the estimate (17) together with the following conditions:

A > 4a f + 2a K, L - f - K - 1 > 0,

where the first one is a lower bound on A calculated as the sum of processing times on the second machine of the short operations in the first 4a cycles (which includes every operation except the zero-length operation of job F0), while the second one can be proved in a similar way as (16). We have

long jobs

2(n9 + 1) ((n9 + 1)L + (4af + 2aK) + f + K + l) . Recall that

&1 < (8a2 + 2a) f + 4a 2K + n2,

02 = 2(n9 + 1) ( (n9 + 1) L + 4af + 2a K + n) ,

Z Cj - 0 > £ Cj - 01 - 02

j eN long jobs

> 2n9 (f + K + 1 - n) -

> 2n9 (f + K + 1 - n) -

(8a2 + 2a) f + 4a 2 K + n2] 10n4f + 4n4K + n4] > 0,

where the last inequality holds as n > 2. Thus, to achieve £Cj < 0 cycle (22) should not appear among the last 2n9 + 1 cycles. With the exchange arguments from above all other cycles containing short operations have to be scheduled prior to the long operations while the last 2n9 +1 cycles only contain long operations.

Property 3 The sum of completion times of all long jobs is at least 02.

Due to Property 2, all long operations are scheduled in the last 2n9 +1 cycles. Again by interchange arguments, the long

should be the first one among all long cycles,

while other long cycles should be grouped in pairs, as shown in Fig. 22. Following the arguments used in the proof of part " for calculating the sum of completion times of the long jobs, it is easy to verify that calculations (9)-(10) hold in the current case as well. Instead of the precise value of A that leads to (11), now we can only substitute an estimate of A,

A > 4af + 2aK + n,

which corresponds to the total length of short operations on machine M\ . Thus, we obtain:

X Cj (=0) 2A(n9 + 1) + 2 (n9 + 1)2

long jobs

2 (4af + 2a K + n) (n9 + 1) + 2 (n9 + 1) L = 02

Property 4 In S, machine M1 operates without idle times. If there is an idle time on machine M1, then A > 4af + 2a K + n + 1 in Property 3 and thus

X Cj > X Cj {2=] 2A(n9 + 1) + 2 (n9 + 1)2 L

j eN long jobs

> 2 (4a f + 2a K + n + 1) (n9 + 1) + 2 ( n9 +

= &2 + 2(n9 + 1) > &2 + &1 = &.

Therefore, there should be no idle time on machine M1 to achieve Xj sn Cj < &.

Property 5 In Part 1 of S, job Ve0 is processed in the first

two cycles which are of the form

, where

represents a short operation. While the order of these two cycles is immaterial, without loss of generality

precedes

we assume that

; otherwise the

cycles can be swapped without changing the value of X Cj.

Since the sum of completion times of all long jobs is at least &2 , the remaining 4a short jobs may only contribute a total completion time of at most &1 to obtain a schedule with total completion time X Cj < & .For all of these jobs, their operations on machine M2 have length of at least f. Thus, it is not possible for i + 1 short jobs to be completed at time if and we can use the lower bound i f for the completion time C[i] of the i-th job:

C[i] > i f for 1 < i < 4a. This implies that

X Cj > Πi = 2a(4a + 1)f.

short jobs

Notice that for i = 1 there is only one job that can be completed at time f, namely Ve0, and this happens only if the first two cycles satisfy the statement of Property 5.

Suppose the statement of Property 5 does not hold for S. Then the above estimate needs to be adjusted by f since in that case the completion time of the first completed job is at least 2f rather than f. It follows that

X Cj - 01 > [2a (4a + 1)f + f ]

short jobs

(8a2 + 2a) f + 4a2K - 2 ^

vd (v) + n

= f - 4a2K + 2£vgV vd(v) - n

= 2Zvey vd(v) - n2

Notice that n > 2 and by construction d (v) > 2 for each vertex v (G' is connected). This leads to 2 £vey vd(v) -n2 > 2n(n — 1) — n2 = n2 — 2n > 0 for n > 2. Thus, the total completion time of all jobs is greater than &, a contradiction.

Property 6 The two operations of each vertex-job and the two operations of each arc-job are processed in two consecutive cycles, first on M1 and then on M2.

We have demonstrated in the proof of Property 5 that C[1] < 2f (with job Ve0 defining C[1]); otherwise the lower bound &1 is violated. Similar arguments can be used to prove (by induction) that the lower bound &1 is achievable only if C[i] < (i + 1)f for 1 < i < 4a. Combining this with (24) we can limit our consideration to schedules satisfying

i f < C[i ] < (i + 1) f for 1 < i < 4a.

Property 6 holds for the first job Ve0 due to Property 5.

Let job j be the short job that is processed on machine M1

in cycle 2. Then, as f < p1 j < 2f, for Ve0 (25) is satisfied.

Suppose j does not satisfy the conditions of Property 6. Then cycle 3 consists of two short jobs k and I that have not been processed yet in the preceding cycles. The situation is illustrated below.

Cycle 1 0

Cycle 2

Cycle 3

Cycle 4

oo j k *

oo I *

In that case no job other than Ve0 can be finished in the first three cycles, so C[2], corresponding to some job finishing no earlier than cycle 4, is at least as big as the finishing time of cycle 4. As the processing time of any short operation other than Ve0 is at least f, cycles 2, 3, and 4 have a combined length of at least 3f as illustrated above. Thus, we have C[2] > 3f in violation of (25).

Therefore j should be processed in cycles 2 and 3, first on Mi and then on M2. The proof of Property 6 can be done by induction using the above arguments.

Property 7 In Part 1 of S, machine M1 alternates between processing arc-jobs and vertex-jobs. Moreover, an operation of a vertex-job corresponding to v is followed by an operation of an arc-job corresponding to an arc leaving v. Similarly, an operation of an arc-job for arc (v, w) is followed by an operation of a vertex-job for vertex w. By Property 6, the same is true for machine M2 in Part 1 and in the first cycle that follows it.

Note that due to the numbers and distributions of vertex-and arc-jobs, if two vertex-jobs are scheduled consecutively, then there should also be two arc-jobs scheduled consecutively. Hence we can restrict our proof to the latter case. So assume there are cycles s, s + 1, s + 2 in which two operations of arc-jobs are scheduled consecutively on the first machine in cycles s, s + 1 (and thus their second operations are scheduled in cycles s + 1, s + 2 by Property 6). Then, because the processing times of the arc-jobs are chosen such that they are no larger than f + 2n on machine M1 and no smaller than f + 6n on machine M2, there is an idle time on machine M1 in cycle s + 1, as illustrated below. However, this is a contradiction to Property 4 as Machine M1 has to operate without idle time. Therefore this situation cannot happen, which proves the first part of Property 7.

Cycle s Cycle s + 1 Cycle s + 2

< £ + 2 n < £ + 2 n

Ar ij Aluv *

* Ar ij A Tuv

> £ + 6 n

>£ + 6 n

We now show that an operation of a vertex-job corresponding to v is followed by an operation of an arc-job corresponding to an arc leaving v. Note that due to Property 6 a vertex- or arc-job processed on machine M1 in some cycle s is processed on machine M2 in cycle s + 1. Assume there is an operation of vertex-job Vei that is succeeded by

an operation of an arc-job Arjk for some i = j in cycles s, s + 1 on machine M1 and s + 1, s + 2 on machine M2.

Cycle S Cycle s + 1 Cycle S + 2

Ç + K-2i g + 2 j _

Ve, Arjk | *

* Ve, ArJk

£ + 2i £ + K - 2k

Among all such pairs (Vei, Ar jk) select the one with i > j (notice that the case that i < j for all pairs is not possible). Then there is an idle time on machine M1 in cycle s + 1, contradicting Property 4.

In a similar fashion it can be shown that an operation of an arc-job corresponding to an arc entering a vertex w is followed by a vertex-job corresponding to vertex w.

Property 8 The first arc-job that appears in S corresponds to an arc leaving 0. Among the vertex-jobs, the last one is Ve 0(0).

Due to Property 5, the first two cycles contain the two operations of job Ve0. Thus, according to Property 7, both operations of this job have to be succeeded by operations of an arc-job leaving vertex 0. Further, as shown in the proof of Property 6, the last vertex-job to be completed is Ve0(0). □

References

Bein, W. W., Brucker, P., Park, J. K., & Pathak, P. K. (1995). A Monge property for the d-dimensional transportation problem. Discrete Applied Mathematics, 58, 97-109.

Boysen, N., Fliedner, M., & Scholl, A. (2008). Assembly line balancing: Which model to use when? International Journal of Production Economics, 111, 509-528.

Brucker, P., Gladky, A., Hoogeveen, H., Kovalyov, M. Y., Potts, C. N.. & Tautenhahn, T. (1998). Scheduling a batching machine. Journal of Scheduling, 1, 31-54.

Burkard, R. E., Klinz, B., & Rudolf, R. (1996). Perspectives of Monge properties in optimization. Discrete Applied Mathematics, 70, 95161.

Chiang, W.-C., Urban, T. L., & Xu, X. (2012). A bi-objective metaheuristic approach to unpaced synchronous production line-balancing problems. International Journal of Production Research, 50, 293-306.

Custic, A., Klinz, B., & Woeginger, G. J. (2014). Planar 3-dimensional assignment problems with Monge-like cost arrays. E-print. arXiv:1405.5210.

de Werra, D., Demange, M., Escoffier, B., Monnot, J., & Paschos, V. T. (2009). Weighted coloring on planar, bipartite and split graphs: Complexity and approximation. Discrete Applied Mathematics, 157, 819-832.

Deineko, V. G., Rudolf, R., & Woeginger, G. J. (1996). On the recognition of permuted Supnick and incomplete Monge matrices. Acta Informatica, 33, 559-569.

Demange, M., de Werra, D., Monnot, J., & Paschos, V. T. (2002). Weighted node coloring: When stable sets are expensive. Lecture Notes in Computer Science, 2573, 114-125.

Doerr, K. H., Klastorin, T. D., & Magazine, M. J. (2000). Synchronous unpaced flow lines with worker differences and overtime cost. Management Science, 46, 421-435.

Escoffier, B., Monnot, J., & Pashos, V. T. (2006). Weighted coloring: Further complexity and approximability results. Information Processing Letters, 97, 98-103.

Garey, M. R., & Johnson, D. S. (1979). Computers and intractability: A guide to the theory ofNP-completeness.New York: W. H. Freeman.

Gonzalez, T., & Sahni, S. (1976). Open shop scheduling to minimize finish time. Journal of the ACM, 23, 665-679.

Gopal, I. S., & Wong, C. K. (1985). Minimising the number of switchings in an SS/TDMA system. IEEE Transactions on Communications, 33, 497-501.

Huang, K.-L. (2008). Flow shop scheduling with synchronous andasyn-chronous transportation times. Ph.D. Thesis, The Pennsylvania State University

Kesselman, A., & Kogan, K. (2007). Nonpreemtive scheduling of optical switches. IEEE Transactions on Communications, 55, 1212-1219.

Kouvelis, P., & Karabati, S. (1999). Cyclic scheduling in synchronous production lines. IIE Transactions, 31, 709-719.

Mestre, J., & Raman, R. (2013). Max-Coloring. In P. M. Pardalos, D.-Z. Du, & R. L. Graham (Eds.), Handbook of Combinatorial Optimization (pp. 1871-1911). New York: Springer.

Queyranne, M., Spieksma, F., & Tardella, F. (1998). A general class of greedily solvable linear programs. Mathematics of Operations Research, 23, 892-908.

Rendl, F. (1985). On the complexity of decomposing matrices arising in satellite communication. Operations Research Letters, 4, 5-8.

Röck, H. (1984). Some new results in flow shop scheduling. Mathematical Methods of Operations Research, 28, 1-16.

Soylu, B., Kirca, Ö., & Azizoglu, M. (2007). Flow shop-sequencing problem with synchronous transfers and makespan minimization. International Journal of Production Research, 45, 3311-3331.

Urban, T. L., & Chiang, W.-C. (2016). Designing energy-efficient serial production lines: The unpaced synchronous line-balancing problem. European Journal of Operational research, 248, 789-801.

Waldherr, S., & Knust, S. (2014). Two-stage scheduling in shelf-board production: a case study. International Journal of Production Research, 52, 4078-4092.

Waldherr, S., & Knust, S. (2015). Complexity results for flow shop problems with synchronous movement. European Journal of Operational Research, 242, 34-44.

Waldherr, S., Knust, S., & Briskorn, D. (2015). Synchronous flow shop probles: How much can we gain by leaving machines idle? (under submission).

Weiß, C., Knust, S., Shakhlevich, N. V., & Waldherr, S. (2016). The assignment problem with nearly Monge arrays and incompatible partner indices. Discrete Applied Mathematics, 211, 183-203.