Routing open shop and flow shop scheduling problems

European Journal of Operational Research 213 (2011) 24–36

Contents lists available at ScienceDirect

European Journal of Operational Research

journal homepage: www.elsevier .com/locate /e jor

Discrete Optimization

Routing open shop and flow shop scheduling problems

Wei Yu a, Zhaohui Liu a,⇑, Leiyang Wang a, Tijun Fan b

a Department of Mathematics, East China University of Science and Technology, Shanghai 200237, Chinab Institute of Operations and Supply Chain Management, East China University of Science and Technology, Shanghai 200237, China

a r t i c l e i n f o

Article history:Received 13 September 2010Accepted 24 February 2011Available online 4 March 2011

Keywords:SchedulingRoutingOpen shopFlow shopComplexityApproximation algorithm

0377-2217/$ - see front matter � 2011 Elsevier B.V. Adoi:10.1016/j.ejor.2011.02.028

⇑ Corresponding author.Tel.: +86 21 64252308; faxE-mail address: [email protected] (Z. Liu).

a b s t r a c t

We consider a generalization of the classical open shop and flow shop scheduling problems where thejobs are located at the vertices of an undirected graph and the machines, initially located at the same ver-tex, have to travel along the graph to process the jobs. The objective is to minimize the makespan. In thetour-version the makespan means the time by which each machine has processed all jobs and returned tothe initial location. While in the path-version the makespan represents the maximum completion time ofthe jobs. We present improved approximation algorithms for various cases of the open shop problem on ageneral graph, and the tour-version of the two-machine flow shop problem on a tree. Also, we prove thatboth versions of the latter problem are NP-hard, which answers an open question posed in the literature.

� 2011 Elsevier B.V. All rights reserved.

1. Introduction

In the classical scheduling problems, it is assumed that the machines and jobs are located at the same site, and hence there are no timelags between the processing of two successive jobs or operations. However, this assumption does not justify for some cases in practice. Inthe Flexible Manufacturing Systems, the machines are located at different sites of a workshop and the jobs to be processed must be trans-ported to the sites. In the Traveling Repairmen Problem, the repairmen (machines) must travel on a transportation network to providerepairing service for the customers (jobs) located at the nodes of the network (see Afrati et al., 1986). Another example comes from thescheduling of robots which provide daily maintenance for some equipments distributed at different locations (see Averbakh and Berman,1996, 1999).

In this paper we consider a generalization of the classical scheduling problem where the jobs are located at the vertices of an undirectedgraph and the machines travel along the graph to process the jobs. Since this problem involves deciding both the routing and scheduling ofthe machines, we call it routing-scheduling problem. For convenience we denote a particular routing-scheduling problem by adding ‘‘R’’to the standard three-field notation for the corresponding classical scheduling problem (see Lawler et al., 1993). We consider three typesof the underlying graphs, i.e., the general graph, tree and line. Except when specified the underlying graph is assumed to be a general graph.It should be noted that the routing-scheduling problems can also be seen as the corresponding scheduling problems with machine-inde-pendent and sequence-dependent setup times. To illustrate the representation of the routing-scheduling problems we give two examples.One is ROkCmax which denotes the problem of assigning machines traveling on a general graph to process jobs in the open shop mode tominimize the makespan. Another example is tree–RF2kCmax which refers to the problem of assigning two machines traveling on a tree toprocess jobs in the flow shop mode to minimize the makespan. From the latter example, we see that a prefix added to ‘‘R’’ specifies theunderlying graph. For the routing-scheduling problems with the makespan criterion, we distinguish two versions. In the tour-versionthe makespan means the time by which each machine has processed the jobs assigned to it and returned to its initial location. While inthe path-version the makespan represents the maximum completion time of all jobs.

Closely related to the routing-scheduling problems are two classical routing problems, i.e., the well-known Traveling Salesman Problem(TSP for short) and the Shortest Hamiltonian Path Problem (SHPP for short) on a graph satisfying the triangle inequality. Currently, Chris-tofides (1976)’s 3/2-approximation algorithm is the best available for TSP. For SHPP, which requires to find a shortest path going through allvertices, Hoogeveen (1991) showed that a modified version of Christofides’ algorithm achieves the same approximation factor 3/2 even

ll rights reserved.

: +86 21 64252018.

http://dx.doi.org/10.1016/j.ejor.2011.02.028

mailto:[email protected]

http://dx.doi.org/10.1016/j.ejor.2011.02.028

http://www.sciencedirect.com/science/journal/03772217

http://www.elsevier.com/locate/ejor

W. Yu et al. / European Journal of Operational Research 213 (2011) 24–36 25

when one end of the path is fixed. Throughout the paper, we always refer to q as the approximation factor for TSP and r as the approx-imation factor for SHPP with one fixed end vertex if algorithms for the two problems are requested.

A number of results on the single-stage routing-scheduling problems have been reported in the literature. Tsitsiklis (1992) discussed thecomplexity of various single-machine problems on a graph with a constant number of vertices or a line. Karuno et al. (1997, 2002), Gaur etal. (2003), Bhattacharya et al. (2008) and Yu and Liu (2010) presented approximation algorithms for different single-machine makespanproblems with job release time constraints on a line, a tree or a cycle. Karuno and Nagamochi (2003, 2004) and Augustine and Seiden(2004) developed approximate solutions for some parallel-machine makespan problems on a line or a tree with a constant number ofleaves.

The multi-stage routing-scheduling problems have been studied in Averbakh and Berman (1996, 1999) and Averbakh et al. (2005, 2006).Averbakh and Berman (1996) dealt with the two-machine flow shop problem RF2kCmax on a tree or a cactus, and obtained polynomial timeoptimization algorithms under the restriction that each machine must travel along a shortest tour. However, the complexity of tree–RF2kCmax is left as an open problem, and we will tackle it in this paper. Averbakh and Berman (1999) considered the tour-version of them-machine flow shop problem RFkCmax, and proposed an approximation algorithm with the performance ratio maxfmþ1

2 ;qg, provided witha q-approximate solution for TSP on the underlying graph. Averbakh et al. (2006) dealt with the tour-version of the m-machine open shopproblem ROkCmax, and obtained an mþ1

2 þ q� �

-approximation algorithm. For m = 2 and q 6 2, they presented an improved 1þ q2

� �-approx-

imation algorithm. Averbakh et al. (2005) gave a 6/5-approximation algorithm for a special case of line–RO2kCmax which is proven NP-hardin Averbakh et al. (2006).

In this paper we also focus on the routing open shop and flow shop problems with the makespan criterion. We treat both versions of

ROkCmax. For the tour-version, we present a max 4qþ32qþ3 ;

2qþ23

n o-approximation algorithm for the two-machine case and a max m

2

� �; 4

3 q� �

þ 13

� �-

approximation algorithm for the m-machine case. Note that q 6 2 in the former algorithm. Our algorithms do better than those in Averbakhet al. (2006). For the path-version, we propose an 8�3r

5�2r-approximation algorithm for the two-machine case, where r 6 2, and an r-approx-imation algorithm for the m-machine case, where

r ¼max m

2

� �;2

� �þ 1

2 ; m 6 6;m2

� �þ 1

3 ; m > 6:

(
We also treat the problem tree–RF2kCmax. First, we prove the problem is NP-hard no matter the tour-version or the path-version, and henceanswer the open question posed in Averbakh and Berman (1996). Then, we give a 10/7-approximation algorithm for the tour-version. Also,we prove that the tour-version of RF2kCmax has an optimal schedule which is a permutation schedule.
The rest of the paper is organized as follows. Section 2 gives the formal description of the problem and some notations. In Section 3 westudy the approximation algorithms for RO2kCmax as well as ROkCmax. In Section 4 we discuss the problem tree–RF2kCmax. Finally, someconcluding remarks are given in Section 5.

2. Problem formulation and notations

The problem studied in the paper is described formally as follows. Given an undirected graph G = (V,E) with the vertex setV = {0,1,2, . . .,n} and the edge set E, there are m machines M1,M2, . . . ,Mm located at vertex 0, and a job j located at vertex j forj = 1,2, . . . ,n. Job j consists of m operations O1,j,O2,j, . . . ,Om,j, and operation Oi,j must be processed nonpreemptively by machine Mi for pi,j timeunits. To process the jobs, all machines travel along the graph at the same speed. The travel time between vertices j and k is given by tj,k. For(j,k) 2 E, tj,k can be viewed as the length of the edge. In general, tj,k is the length of the shortest path between vertices j and k. Clearly, tj,kssatisfy the triangle inequality. Note that a machine may pass a vertex without processing the job located there, or wait there to process thejob.

A schedule S specifies a starting time si,j(S) for each operation Oi,j such that each machine processes at most one job and each job is pro-cessed by at most one machine at any time. In a schedule for the flow shop problem, the operations O1,j,O2,j, . . . ,Om,j must be processed inthis order. However, for the open shop problem, the operations of a job may be processed in any order. The completion time of job j inschedule S is given by Cj(S) = max16i6mCi,j(S), where Ci,j(S) = si,j(S) + pi,j is the completion time of operation Oi,j. Obviously, Cj(S) = Cm,j(S) holdsfor the flow shop problem. Let Cmax(S) be the makespan of S. Then, in the path-version Cmax(S) = max16j6nCj(S), while in the tour-versionCmax(S) = max16j6n{Cj(S) + tj,0}. Our task is to find a schedule that minimizes the makespan. As illustrated in Section 1, we denote the openshop problem by ROkCmax and the flow shop problem by RFkCmax.

With respect to the makespan criterion, it is reasonable to assume that each machine always travels towards the next job to be pro-cessed by it. Thus, m sequences a1,a2, . . . ,am on the job set {1,2, . . . ,n} suffice to specify a schedule for RFkCmax, where ai specifies the rout-ing of Mi. After processing ai(j � 1), Mi travels towards ai(j). On arriving at ai(j), Mi processes it immediately if Mi�1 has processed the job;else, waits there. A flow shop schedule S = (a1,a2, . . . ,am) is called permutation schedule if a1 = a2 = � � � = am.

Only the machine routings are insufficient to specify a schedule for the open shop problem ROkCmax since the processing order of theoperations of each job is also unknown. However, we mainly consider the so-called normal schedules for ROkCmax specified by the machineroutings. Let S = (a1,a2, . . . ,am) be a normal schedule for ROkCmax. Then, Mi travels towards ai(j) after processing ai(j � 1). On arriving at ai(j),Mi processes it immediately if it is not being processed by another machine; else, waits there. If several machines are available for the samejob, we make a choice arbitrarily, and the non-chosen machines continue to wait.

We now introduce some notations to be used throughout the paper. For any V0 # Vn{0}, let T(V0) (resp. Tq(V0)) denote the shortest (resp.q-approximate) tour on V0 [ {0} as well as its length, and H(V0) (resp. Hr(V0)) denote the shortest (resp. r-approximate) Hamiltonian pathon V0 [ {0} starting from vertex 0 as well as its length. For notational compactness, when V0 [ {0} = V we denote T(V0), Tq(V0), H(V0), Hr(V0) asT, Tq, H, Hr respectively.

Each Hamiltonian path on V0 [ {0} starting from vertex 0 indicates a processing order of jobs in V0. However, each tour on V0 [ {0} impliestwo opposite processing orders of jobs in V0. Given a sequence p on V0 and some U # V0, let pR denote the reverse sequence of p, and pnUthe sequence on V0nU obtained by deleting the jobs in U from p without changing the order of the other jobs.

26 W. Yu et al. / European Journal of Operational Research 213 (2011) 24–36

Let Li ¼Pn

j¼1pi;j and pj ¼Pm

i¼1pi;j be the load of machine Mi and the processing time of job j respectively. Define the maximum load andthe maximum processing time as L = max16i6mLi and pmax = max16j6npj respectively.

Let STOm and CTOmmax be the optimal schedule and its makespan for the tour-version of the m-machine open shop problem. SPOm and CPOm

max forthe path-version of the problem, and STF2 and CTF2

max for the tour-version of the two-machine flow shop problem are defined similarly.

3. Open shop problem on a general graph

In this section we treat the open shop problem ROkCmax. Note that line–RO2kCmax has been proven NP-hard in Averbakh et al. (2006). Wepresent two approximation algorithms for RO2kCmax in Sections 3.1 and 3.2, where one is for the tour-version, and the other is for the path-version. Then we show how the algorithms can be used to deal with the m-machine cases in Section 3.3.

3.1. Tour-version of two-machine case

Averbakh et al. (2006) gave a 1þ q2

� �-approximation algorithm for the tour-version of RO2kCmax, provided that q 6 2. Here we give a

better maxf4qþ32qþ3 ;

2qþ23 g-approximation algorithm. For example, when q ¼ 3

2, i.e., the underlying TSP is solved by Christofides’ Algorithm,

the performance ratios of our and Averbakh et al.’s algorithms are 5/3 and 7/4 respectively.Our algorithm first generates two candidate schedules, where one is obtained by running Averbakh et al.’s algorithm, and the other is

obtained by solving the corresponding zero travel time problem to optimality. Then, it takes the better one as the approximate solution.Averbakh et al.’s algorithm is described as follows.

Algorithm H1 (Averbakh et al., 2006)

Step 1. Find a q-approximate tour Tq for TSP on V, which defines two opposite machine routings, denoted by Tq and TRq.

Step 2. Construct a normal schedule SA ¼ ðTq; TRqÞ, i.e., M1 travels along Tq and M2 along TR

q. If neither machine waits during the travel, out-put SA as the approximate solution. Otherwise, let c be the vertex where some machine waits. We construct another schedule SB byexchanging the processing order of two operations O1,c and O2,c in SA, and choose the best one among SA, SB as the approximatesolution.

The classical zero travel time problem O2kCmax is solved by Gonzalez and Sahni (1976)’s algorithm. Yu and Liu (1999) gave an improvedexecution for the algorithm, and we here use it to produce a candidate schedule for RO2kCmax. Let I1 = {jjp1,j 6 p2,j} and I2 = {jjp1,j > p2,j}. Let kbe a job such that min{p1,k,p2,k} = max16j6nmin{p1,j,p2,j}. Without loss of generality, we suppose that p1,k = min{p1,k,p2,k}, i.e., k 2 I1. LetI01 ¼ I1 n fkg. Yu and Liu showed that ððI01; I2; kÞ; ðk; I01; I2ÞÞ is an optimal schedule for O2kCmax, and its makespan is max{L,pmax}.

Algorithm Tour-O2(q)

Step 1. Run Algorithm H1 to generate a schedule S1.Step 2. Construct a normal schedule S2 = (a1,a2) as follows:

if pmax 6 L, set

a1 ¼ ðTqðI01Þ; TqðI2Þ; kÞ; a2 ¼ ðk; TqðI01Þ; TqðI2ÞÞ;

if pmax > L, which implies pk = pmax, set

a1 ¼ ðTq n fkg; kÞ; a2 ¼ ðk; Tq n fkgÞ:

Step 3. Choose the best one among S1, S2 as the approximate solution.

Before proving the performance ratio of Algorithm Tour-O2(q), we give two lower bounds on the optimal makespan. Note that thebounds hold even for the m-machine case.

Lemma 3.1. (i) CTOmmax P Lþ T; (ii) CTOm

max P pj þ 2t0;j for any j 2 {1,2, . . . ,n}.

The following upper bound on Cmax(S1) have been proved in Lemma 1 of Averbakh et al. (2006).

Lemma 3.2. CmaxðS1Þ 6 pc2 þ Lþ qT 6 pmax

2 þ Lþ qT.

In Lemmas 3.3 and 3.4, we prove some upper bounds on Cmax(S2).

Lemma 3.3. If pmax 6 L, then Cmax(S2) 6 L + 2t0,k + 2qT.

Proof. When all the travel times are ignored, S2 is a schedule of length max{L,pmax} = L as shown in Gonzalez and Sahni (1976) and Yu andLiu (1999). When the travel times are taken into consideration, the total travel time of each machine is 2t0;k þ Tq I01

� �þ TqðI2Þ, and the delay

of each operation is no more than it. Thus,

CmaxðS2Þ 6 Lþ 2t0;k þ Tq I01� �þ TqðI2Þ 6 Lþ 2t0;k þ 2qT: �

Lemma 3.4. If L < pmax < L + qT, then Cmax(S2) 6 L + 2t0,k + q T.


Proof. When all the travel times are ignored, S2 is a schedule of length max{L,pmax} = pmax, and there are at least pmax � L units of idle timeon each machine before the time pmax. When the travel times are taken into consideration, the total travel time of each machine is 2t0,k + Tq.Thus,

CmaxðS2Þ 6 pmax þ 2t0;k þ Tq � ðpmax � LÞ 6 Lþ 2t0;k þ qT: �

Based on the above lemmas, we can prove the performance ratio of Algorithm Tour-O2(q).

Theorem 3.1. Algorithm Tour-O2(q), where q 6 2, is a max 4qþ32qþ3 ;

2qþ23

n o-approximation algorithm for the tour-version of RO2kCmax. Particularly,

its performance ratio does not exceed 5/3 when q = 3/2.

Proof. We distinguish two cases.

Case 1. pmax 6 L. By Lemmas 3.2 and 3.3, we have

CmaxðS1Þ 6pmax

2þ Lþ qT 6

32

Lþ qT 632 Lþ qT

Lþ TCTO2

max; ð1Þ

and

CmaxðS2Þ 6 Lþ 2t0;k þ 2qT 6 Lþ ð1þ 2qÞT 6 Lþ ð1þ 2qÞTLþ T

CTO2max: ð2Þ

Hence

minfCmaxðS1Þ;CmaxðS2ÞgCTO2

max

6 min32 Lþ qT

Lþ T;Lþ ð1þ 2qÞT

Lþ T

� 6

4qþ32qþ3 ; if q 6 3

2 ;

q 6 2qþ23 ; if 3

2 < q 6 2:

(

Case 2. pmax > L. If pmax P L + qT, then

CmaxðS2Þ ¼ pmax þ 2t0;k; ð3Þ

and S2 is an optimal schedule according to Lemma 3.1(ii). Next we assume pmax < L + qT. By Lemmas 3.2 and 3.4, we have

minfCmaxðS1Þ;CmaxðS2Þg 623

CmaxðS1Þ þ13

CmaxðS2Þ 623

pmax

2þ Lþ qT

�þ 1

3ðLþ 2t0;k þ qTÞ

¼ Lþ qT þ 13ðpmax þ 2t0;kÞ 6 Lþ qT þ 1

3CTO2

max 6Lþ qTLþ T

þ 13

� CTO2

max: ð4Þ

In addition, we have pmax 6 2L by definition. Thus,

CmaxðS1Þ 6pmax

2þ Lþ qT 6 2Lþ qT 6

2Lþ qTLþ T

CTO2max;

and


max

6 minLþ qTLþ T

þ 13;2Lþ qT

Lþ T

� 6

2qþ 23

;

where the last inequality holds for q 6 2. h

The following two examples show that the bound in Theorem 3.1 is tight for q 6 32.

Example 1. The underlying graph is given in Fig. 1(a), where only edges (0,8) and (7,8) have nonzero travel times. The processing times ofthe jobs are defined below:

p1;j ¼ 0; p2;j ¼ �; j 2 f1;2;3;4;5g;p1;6 ¼ 0; p2;6 ¼ 4qþ 4� 5�;

p1;j ¼ �; p2;j ¼ 0; j 2 f7;8;9;10;11g;p1;12 ¼ 4qþ 4� 5�; p2;12 ¼ 0;

p1;13 ¼ p2;13 ¼ 4qþ 4;

where � is a sufficiently small positive number. The optimal schedule is STO2 = (T,TR) with T = (6,12,2,4,8,10,1,3,5,7,9,11,13), andCTO2

max ¼ 8qþ 12 (see Fig. 2). By definition, k = 13 and pmax = L = 8q + 8. Suppose that

Tq ¼ ð6;1;3;5;2;4;13;8;10;7;9;11;12Þ;TqðI01Þ ¼ ð1;2;3;4;5;6Þ;TqðI2Þ ¼ ð7;8;9;10;11;12Þ

Fig. 2. The schedules constructed in Example 1.

Fig. 1. The underlying graphs in Examples 1 and 2.


are the q-approximate tours chosen in Algorithm Tour-O2(q). Then, S1 and S2 can be constructed as in Fig. 2, where Cmax(S1) =Cmax(S2) = 16q + 12. Thus we have


max

¼ 4qþ 32qþ 3

:

Example 2. Suppose that q 6 32. The underlying graph is given in Fig. 1(b), where the edges (0,1) and (2,3) have zero travel time. The job

located at vertex 2 is the only job with nonzero processing time, and p1,2 = p2,2 = 2. The optimal schedule is STO2 = (T,TR), whereT = (1,2,3,4,5), and CTO2

max ¼ 6. By definition, k = 2 and pmax = 4 > L = 2. Given a q-approximate tour Tq = (1,4,2,3,5), Algorithm Tour-O2(q)produces S1 = ((1,4,2,3,5), (5,3,2,4,1)) and S2 = ((1,4,3,5,2), (2,1,4,3,5)). It can be verified that Cmax(S1) = Cmax(S2) = 4q + 4. Thus we have


max

¼ 2qþ 23

:

3.2. Path-version of two-machine case

We now turn to the path-version of RO2kCmax, and present a 8�3r5�2r-approximation algorithm, where r 6 2 is the performance ratio of an

algorithm for SHPP on graph G. Let k be defined as in Section 3.1.

Algorithm Path-O2(r)

Step 1. Find the minimum spanning tree eT of graph G and then double all the edges to obtain an Eulerian graph. Construct a tour bT suchthat k is adjacent to 0. Run Algorithm H1 with the tour bT instead of Tq to generate a schedule S1.


Step 2. Choose a r-approximate Hamiltonian path Hr starting from the vertex 0, and construct a normal schedule S2 = (Hr,Hr).Step 3. Choose the best one among S1, S2 as the approximate solution.

Obviously, the following lower bounds on the optimal makespan CPOmmax hold.

Lemma 3.5. (i) CPOmmax P Lþ H; (ii) CPOm

max P pj þ t0;j for any j 2 {1,2, . . . ,n}.

The following lemmas give the upper bounds on the makespan of S1 and S2.

Lemma 3.6. CmaxðS1Þ 6 pc2 þ Lþ 2H 6 pmax

2 þ Lþ 2H.

Proof. According to Lemma 3.2, it holds that CmaxðS1Þ 6 pc2 þ Lþ bT 6 pmax

2 þ Lþ bT . Since bT 6 2eT 6 2H, where eT represents the total length ofthe edges in the spanning tree eT , the conclusion holds. h

Lemma 3.7. Cmax(S2) 6 2L + rH.

Proof. S2 is a permutation schedule. Without loss of generality, we suppose that each job is first processed by M1 and then by M2. Then, itsmakespan is equal to the completion time of the last job processed by M2. Since the waiting time of M2 does not exceed L1 and the traveltime is Hr, it holds that Cmax(S2) 6 L1 + L2 + Hr 6 2L + rH. h

Combining Lemmas 3.5, 3.6, 3.7, we can prove the following theorem.

Theorem 3.2. Algorithm Path-O2(r), where r 6 2, is a 8�3r5�2r-approximation algorithm for the path-version of RO2kCmax. Particularly, its

performance ratio does not exceed 7/4 if r = 3/2.

Proof. We first prove CmaxðS1Þ 6 32 Lþ 2H. If pmax 6 L, then by Lemma 3.6, we have CmaxðS1Þ 6 Lþ pmax

2 þ 2H 6 32 Lþ 2H. Consider the case of

pmax > L. It holds that pk = pmax. If k = c, then since k is adjacent to 0 in the tour bT , we have

CmaxðS1Þ 6 maxfLþ 2H; t0;k þ pkg;

which implies Cmax(S1) 6 L + 2H; otherwise, Cmax(S1) 6 t0,k + pk and S1 is optimal. If k – c, then by Lemma 3.6, we have

CmaxðS1Þ 6pc

2þ Lþ 2H 6

pc þ pk

4þ Lþ 2H 6

12

Lþ Lþ 2H ¼ 32

Lþ 2H:

Combining CmaxðS1Þ 6 32 Lþ 2H with Lemmas 3.7, 3.5(i), we have

minfCmaxðS1Þ;CmaxðS2ÞgCPO2

max

6 min32 Lþ 2H

Lþ H;2Lþ rH

Lþ H

� 6

8� 3r5� 2r

:

where the last inequality holds for r 6 2. h

3.3. m-Machine case

In this subsection, we deal with the general m-machine case of ROkCmax. Given an instance I of ROmkCmax, we first construct an instanceI0 of RO2kCmax on the same underlying graph. I0 still consists of n jobs. The processing times of two operations of the job located at vertex jare given by

p01;j ¼Xdm=2e

i¼1

pi;j; p02;j ¼Xm

i¼dm=2eþ1

pi;j:

Let L0 and p0max be the maximum load and the maximum processing time of I0. It is obvious that p0max ¼ pmax and

L0 ¼ maxXdm=2e

i¼1

Li;Xm

i¼dm=2eþ1

Li

( )6

m2

l mL:

Then, we apply Algorithm Tour-O2(q) or Algorithm Path-O2(r) to I0 to obtain several two-machine schedules. Each two-machine schedule Sfor I0 can be converted into an m-machine schedule for I without increasing the makespan, where the first dm/2emachines travel as M1 in S,and the other machines travel as M2 in S.

Algorithm Tour-Om (q)

Step 1. Construct the two-machine instance I0, and apply Algorithm Tour-O2(q) to it to generate two two-machine schedules S1 and S2.Step 2. Convert S1 and S2 into two m-machine schedules, denoted as S1 and S2 still.Step 3. Choose the best one among S1, S2 as the approximate solution.


Theorem 3.3. Algorithm Tour-Om (q) produces a max m2

� �; 4

3 q� �

þ 13-approximate solution for any q P 1 for the tour-version of ROmkCmax.

Proof. Note that the relations (1)–(4) in the proof of Theorem 3.1 hold for any q P 1 for the two-machine instance I0 if L is replaced by L0,and the makespan of S1 and S2 for I is no more than the makespan of S1 and S2 for I0.

If pmax 6 L0, then by (1) and (2), we have


CmaxðS1Þ þ13

CmaxðS2Þ 623

pmax

2þ L0 þ qT

�þ 1

3ðL0 þ 2t0;k þ 2qTÞ ¼ L0 þ 4

3qT þ 1

3ðpmax þ 2t0;kÞ:

If pmax P L0 + qT, then by (3), it holds that Cmax(S2) = pmax + 2t0,k = pk + 2t0,k. Thus, by Lemma 3.1(ii), S2 is optimal. If L0 + q T > pmax > L0, then by(4), we have

minfCmaxðS1Þ;CmaxðS2Þg 6 L0 þ qT þ 13ðpmax þ 2t0;kÞ:

In sum, we have

minfCmaxðS1Þ;CmaxðS2Þg 6 L0 þ 43qT þ 1

3ðpmax þ 2t0;kÞ 6 d

m2eLþ 4

3qT þ 1

3CTOm

max 6 maxm2

l m;43q

� ðLþ TÞ þ 1

3CTOm

max

6 maxm2

l m;43q

� þ 1

3

� CTOm

max :

This completes the proof. h

Now we turn to the path-version. When the two-machine schedule S2 constructed in Step 2 of Algorithm Path-O2(r) is converted into anm-machine schedule, its performance is bad, so we do not employ it, and construct a new schedule instead.

Algorithm Path-Om

Step 1. Construct the two-machine instance I0, and apply Step 1 of Algorithm Path-O2(r) to it to generate a schedule S1.Step 2. Construct another schedule S2 = (a1,a2) for I0 as follows:

if pmax 6 L0, set

a1 ¼ ðbT n ðI2 [ fkgÞ; bT R n I01Þ;a2 ¼ ðbT n I2; bT R n I1Þ;if pmax > L0, which implies pk = pmax, set

a1 ¼ ðbT n fkg; kÞ;a2 ¼ bT ;where k; I1; I

01 and I2 are defined as in Section 3.1 and bT is the tour generated in Step 1 of Algorithm Path-O2(r).

Step 3. Convert S1 and S2 into two m-machine schedules, denoted as S1 and S2 still.Step 4. Choose the best one among S1, S2 as the approximate solution.

The following two lemmas are proved for the two-machine instance I0. Certainly, they hold for the original m-machine instance I .

Lemma 3.8. If pmax 6 L0, then Cmax(S2) 6 L0 + 4H.

Proof. When all the travel times are ignored, S2 is a schedule of length max{L0,pmax} = L0. When the travel times are taken into consider-ation, the makespan of S2 increases by at most 2bT , an upper bound on the total travel time of each machine. Thus,CmaxðS2Þ 6 L0 þ 2bT 6 L0 þ 4H. h

Lemma 3.9. If pmax > L0, then CmaxðS2Þ 6 L0 þ t0;k þ bT 6 L0 þ t0;k þ 2H.

Proof. Analogous to Lemma 3.4. h

Theorem 3.4. Algorithm Path-Om produces an r-approximate solution for the path-version of ROmkCmax, where

r ¼max m

2

� �;2

� �þ 1

2 ; m 6 6;m2

� �þ 1

3 ; m > 6:

(

Proof. Note that Lemma 3.6 holds after substituting L0 for L. We distinguish two cases.

Case 1. pmax 6 L0. By Lemma 3.6, we have

CmaxðS1Þ 6pmax

2þ L0 þ 2H 6

12

CPOmmax þ

m2

l mLþ 2H 6 maxfdm

2e;2g þ 1

2

� CPOm

max :

By Lemmas 3.8 and 3.5(i), we have

CmaxðS2Þ 6 L0 þ 4H 6m2

l mLþ 4H 6 maxf m

2

l m;4gCPOm

max :

Thus, the conclusion holds.


Case 2. pmax > L0. By Lemmas 3.6, 3.9 and 3.5, we have


CmaxðS1Þ þ13

CmaxðS2Þ 6 L0 þ 2H þ 13ðpmax þ t0;kÞ 6

m2

l mLþ 2H þ 1

3CPOm

max 6 max dm2e;2

n oþ 1

3

� CPOm

max :


4. Two-machine flow shop problem on a tree

In this section we prove that both versions of tree–RF2kCmax are NP-hard and give a 10/7-approximation algorithm for the tour-version.Also, we will show that the tour-version of RF2kCmax has an optimal schedule which is a permutation schedule.

4.1. NP-hardness proof

The proof is done by a reduction from the well-known NP-hard problem PARTITION described below.PARTITION: Given n positive integers a1,a2, . . . ,an with

Pnj¼1aj ¼ 2B and amax = max16j6naj < B, is there an index set J � {1,2, . . . ,n} such

thatP

j2Jaj ¼P

jRJaj ¼ B?

Theorem 4.1. Both the tour-version and the path-version of tree–RF2kCmax are NP-hard.

Proof. Given an instance I of PARTITION, we construct a decision instance I0 of tree–RF2kCmax as follows.As showed in Fig. 3, the tree consists of n + 1 branches originating from vertex 0. For j = 1,2, . . . ,n, the edges (0,n + j) and (n + j, j) each

require the travel time aj. The edge (0,2n + 1) requires zero travel time. The processing times of the operations of jobs 1,2, . . . ,2n + 1 aregiven by

p1;j ¼ 0; p2;j ¼ 7Baj; j ¼ 1;2; . . . ;n;

p1;nþj ¼ p2;nþj ¼ 7B2 þ 7Baj; j ¼ 1;2; . . . ; n;

p1;2nþ1 ¼ 14B2; p2;2nþ1 ¼ 0:

Define L ¼P2nþ1

j¼1 p1;j ¼P2nþ1

j¼1 p2;j ¼ ð7nþ 28ÞB2. The decision instance asks if there is a feasible schedule S with Cmax(S) 6 L + 10B, no matterthe tour-version or the path-version.

Suppose that there is a desired schedule S for I0. Let n + u be the first job in {n + 1,n + 2, . . . ,2n} processed by M1, and Anþu1 the set of jobs

processed before n + u by M1, in schedule S. Set J ¼ Anþu1 n fug. Let Ti (i = 1,2) be the total travel time of Mi, and W2 the total waiting time of

M2 in S. We claim

(i) both M1 and M2 process job 2n + 1 lastly in S;(ii) W2 6 2B;

(iii) J � {1,2, . . . ,n} andP

j2Jaj ¼ B.

(i) Suppose that the last job processed by M1 is q, not 2n + 1 in S. It can be observed that in any schedule the total travel time of eachmachine is at least 8B � 2amax before the processing of the last job. Thus, T1 > 6B and the completion time Cq(S) satisfies

CqðSÞPX2nþ1

j¼1

p1;j þ T1 þ p2;q > Lþ 6Bþ 7B ¼ Lþ 13B;

which contradicts Cmax(S) 6 L + 10B. Then, 2n + 1 is the last job processed by M1, and T1 P 8B, and the completion time of 2n + 1 satisfies

C2nþ1ðSÞPX2nþ1

j¼1

p1;j þ T1 þ p2;2nþ1 P Lþ 8B:

If the last job processed by M2 is not job 2n + 1, we have Cmax(S) P C2n+1(S) + 7B P L + 15B, also a contradiction.

Fig. 3. The tree in the proof of Theorem 4.1.


(ii) Since M2 processes 2n + 1 lastly, it holds that T2 P 8B. Then,

CmaxðSÞ ¼X2nþ1

j¼1

p2;j þ T2 þW2 P Lþ 8BþW2:

By Cmax(S) 6 L + 10B, we obtain W2 6 2B.(iii) By (i), 2n + 1 R J. Thus, J � {1,2, . . . ,n}. For j 2 J, the processing of j and n + j by M1 is separated by n + u, so T1 P 8Bþ 2

Pj2Jaj. Then,

CmaxðSÞP Lþ 8Bþ 2P

j2Jaj. Combining it with Cmax(S) 6 L + 10B, we obtainP

j2Jaj 6 B. Next we proveP

j2Jaj ¼ B.Let v be the first job inf1;2; . . . ;2ng n Anþu

1 processed by M2 in schedule S. Then, v = n + u or v is processed after n + u by M1. Let Av2 be the set of jobs processed

before v by M2. Then, Av2 # Anþu

1 . Let Tvi ði ¼ 1;2Þ denote the travel time of Mi before it processes job v. We have s2;v P Tv

1 þ p1;nþu and

W2 P s2;v � Tv2 �

Xj2Av

2

p2;j P p1;nþu þ Tv1 � Tv

2 �Xj2Av

2

p2;j:

Since

Tv1 P 2

Xj2J

t0;j þ t0;nþu P 4Xj2J

aj þ au

and

Tv2 6 4

Xj2Av

2

aj þ t0;v 6 4X

j2Anþu1

aj þ t0;v 6 4Xj2J

aj þ 4au þ 2av ;

we have

W2 P p1;nþu �Xj2Av

2

p2;j � 3au � 2av P 7B2 þ 7Bau �X

j2Anþu1

p2;j � 5amax P 7B2 þ 7Bau �Xj2J

p2;j � p2;u � 5amax ¼ 7B2 �Xj2J

7Baj � 5amax:

If B >P

j2Jaj, i.e., B PP

j2Jaj þ 1, then W2 P 7B � 5amax > 2B. Thus,P

j2Jaj ¼ B, which implies J is a solution for I .Conversely, suppose that the PARTITION instance I has a solution J = {j1, . . . , jk}. Let {jk+1, . . . , jn} = {1, . . . ,n}n{j1, . . . , jk}. We construct a per-

mutation schedule S for I0 according to the job sequence

ðj1; . . . ; jk; jkþ1;nþ jkþ1; . . . ; jn;nþ jn;nþ j1; . . . ; nþ jk;2nþ 1Þ:

It is easy to verify that in S the total travel time of each machine is 4Pn

j¼1aj þ 2P

j2Jaj ¼ 10B, no matter the tour-version or the path-version.To prove Cmax(S) 6 L + 10B, it suffices to prove that no wait occurs for M2 in S.

Since p1;ji¼ 0 for i = 1,2, . . . ,n, M2 does not wait before processing jk+1 in S. Moreover, since M2 requiresPkþ1

i¼1 p2;ji ¼ p1;nþjkþ1¼ 7B2 þ 7Bajkþ1

units of time more than M1 in order to complete the first k + 1 jobs, it does not wait before n + jk+1. Sincep2;nþju

¼ p1;nþjuand

Pvi¼1p2;ji

¼ 7B2 þ 7BPv

i¼kþ1aji P p1;nþjvfor k + 1 6 u < v 6 n, M2 does not wait before n + jv. Further, since p2;nþju

¼ p1;nþjuand

Pni¼1p2;ji ¼ 14B2 P p1;nþju

for 1 6 u 6 k, M2 does not wait until the end. This completes the proof. h

Remark 1. Since when there is a solution for I in the proof of Theorem 4.1, the schedule constructed for I0 is a permutation schedule, weconclude that finding an optimal permutation schedule for tree–RF2kCmax is also NP-hard.

4.2. 10/7-Approximation algorithm for the tour-version

In this subsection, we present a 10/7-approximation algorithm for the tour-version of tree–RF2kCmax. First we show that the optimalschedule can be found in permutation schedules even for the tour-version of RF2kCmax. Although Averbakh and Berman (1996) have provedthat there is a permutation schedule which is optimal if each machine must travel along a shortest tour, our result is better.

Lemma 4.1. For the tour-version of RF2kCmax, there is an optimal schedule such that the jobs first processed by two machines are the same, and soare the jobs finally processed.

Proof. Let S = (a1,a2) be an optimal schedule. Without loss of generality we assume that a2 = (1,2, . . . ,n) and a1(1) = i. If i = 1, then the jobsfirst processed by two machines are the same. If i > 1, we consider the schedule S0 ¼ ða1;a02Þ, where a02 ¼ ði;1;2; . . . ; i� 1; iþ 1; . . . ;nÞ, andshow that Cmax(S0) 6 Cmax(S).

Note that C1,j(S0) = C1,j(S) for j = 1,2, . . . ,n, and a02ðjÞ ¼ a2ðjÞ for j = i + 1, . . . ,n. In order to prove Cmax(S0) 6 Cmax(S), we need only to proves2,i+1(S0) 6 s2,i+1(S).

Since s2,1(S) = C1,1(S) P t0,i + p1,i + ti,1 + p1,1 and s2,i(S0) = t0,i + p1,i, it holds that

s2;1ðS0Þ ¼ maxfC1;1ðS0Þ; s2;iðS0Þ þ p2;i þ ti;1g ¼ maxfC1;1ðSÞ; t0;i þ p1;i þ ti;1 þ p2;ig 6 C1;1ðSÞ þ p2;i ¼ s2;1ðSÞ þ p2;i:

Further,

s2;2ðS0Þ ¼ maxfC1;2ðS0Þ; s2;1ðS0Þ þ p2;1 þ t1;2g 6 maxfC1;2ðSÞ; s2;1ðSÞ þ p2;i þ p2;1 þ t1;2g 6 s2;2ðSÞ þ p2;i;


and by induction, we can obtain s2,i�1(S0) 6 s2,i�1(S) + p2,i. So

s2;iþ1ðS0Þ ¼ maxfC1;iþ1ðS0Þ; s2;i�1ðS0Þ þ p2;i�1 þ ti�1;iþ1g 6 maxfC1;iþ1ðSÞ; s2;i�1ðSÞ þ p2;i þ p2;i�1 þ ti�1;i þ ti;iþ1g6 maxfC1;iþ1ðSÞ; s2;iðSÞ þ p2;i þ ti;iþ1g ¼ s2;iþ1ðSÞ:

Owing to the symmetry of the roles of M1 and M2 in the two-machine flow shop, a similar argument can prove that the jobs finally pro-cessed by two machines are the same too. h

Theorem 4.2. For the tour-version of RF2kCmax, there is an optimal schedule which is a permutation schedule.

Proof. By Lemma 4.1, there exists an optimal schedule S1 = (a1,a2) such that a1(1) = a2(1) and a1(n) = a2(n). Without loss of generality weassume that a1 = (1,2, . . . ,n). Then, a2(1) = 1, a2(n) = n.

For i = 2,3, . . . ,n � 2, let Si be a schedule obtained by shifting O2,i to immediately follow O2,i�1 in Si�1. Obviously, Sn�2 = (a1,a1) is apermutation schedule, and we need to prove Sn�2 is optimal. Assume that Cmax(Sn�2) > Cmax(S1). Then there exists some i P 1 such that

CmaxðSiÞ ¼ CmaxðS1Þ;dl ¼ CmaxðSlÞ � CmaxðS1Þ > 0; l ¼ iþ 1; . . . ;n� 2:

Suppose that the total travel time T1 of M1 is not greater than the total travel time T2 of M2 in Si; otherwise, we exchange the roles of M1 andM2, and consider the symmetric problem, for which the initial optimal schedule is given by Si with the reversed machine routings.

For each operation O1,j (j = 1,2, . . . ,n), its starting times and completion times in S1,S2, . . . ,Sn�2 do not change, so we simply denote themby s1,j and C1,j in the following discussion. For l = i, i + 1, . . . ,n � 2, let Wl denote the total waiting time of M2 in Sl. We will show that forl = i + 1, i + 2, . . . ,n � 2, Sl possesses the following properties:

(i) s2,j(Sl) P C1,j + dl for j = l + 1, l + 2, . . . ,n;(ii) M2 does not wait after processing job i + 1;

(iii) Wl 6Wi.

We first show that Si+1 possesses the above properties. Since Si+1 is obtained by shifting O2,i+1 to follow O2,i in Si, andCmax(Si+1) = Cmax(Si) + di+1, we have

s2;jðSiþ1ÞP s2;jðSiÞ þ diþ1 P C1;j þ diþ1; j ¼ iþ 2; . . . ;n;

i.e., Si+1 satisfies property (i). Property (ii) follows from property (i). Before processing job i, the waiting times of M2 in Si and Si+1 are equal. IfM2 does not wait after processing job i in Si+1, then Wi+1 6Wi, and property (iii) holds. Otherwise, due to property (ii), the waiting only hap-pens before processing job i + 1 (see Fig. 4, where r is the job processed immediately after i by M2 in Si), and

C1;iþ1 � C2;iðSiþ1Þ � ti;iþ1 6 C1;r � tiþ1;r � C2;iðSiþ1Þ � ti;iþ1 6 C1;r � C2;iðSiÞ � ti;r ;

i.e., the waiting time of M2 after job i in Si+1 is no more than that in Si. Property (iii) holds too.Suppose that properties (i), (ii) and (iii) hold for Sl. We next show they hold for Sl+1. Let u and v denote respectively the jobs processed

immediately after l and l + 1 by M2 in Sl (see Fig. 4). Since Sl satisfies property (ii), the waiting of M2 after job i + 1 in Sl+1 can only happen justbefore l + 1 and v are processed. If the waiting happens before processing l + 1, then C1,l+1 � C2,l(Sl) > tl,l+1, and hence

tl;u ¼ ðC1;lþ1 � C2;lðSlÞÞ þ ðs2;uðSlÞ � C1;lþ1Þ > tl;lþ1 þ ðC1;u � C1;lþ1ÞP tl;lþ1 þ tlþ1;u;

Fig. 4. The schedules in the proof of Theorem 4.2.


which contradicts the triangle inequality. If the waiting happens just before processing v, then since Sl satisfies property (i), we haveCmax(Sl+1) = Cmax(S1), a contradiction again. So we conclude that Sl+1 satisfies property (ii), which leads to Wl+1 = Wl 6Wi, i.e., Sl+1 satisfiesproperty (iii) too.

Because Sl possesses properties (i) and (ii), and Sl+1 satisfies property (ii), we have

s2;jðSlþ1ÞP C1;j þ dl þ CmaxðSlþ1Þ � CmaxðSlÞ ¼ C1;j þ dlþ1; j ¼ lþ 2; lþ 3; . . . ;n;

i.e. Sl+1 possesses property (i). By property (iii), we have Wn�2 6Wi. Combining the inequality with T1 6 T2, we obtain

CmaxðSn�2Þ ¼Wn�2 þXn

j¼1

p2;j þ T1 6Wi þXn

j¼1

p2;j þ T2 ¼ CmaxðSiÞ ¼ CmaxðS1Þ;

a contradiction with the assumption Cmax(Sn�2) > Cmax(S1). This completes the proof. h

Let S be a permutation schedule for the tour-version of RFkCmax. We let t(S) denote the travel time of a machine in S, and C0maxðSÞ denote

the makespan for the corresponding zero travel time problem given that the job sequence is the same as in S. The following lemma hasbeen proved in Averbakh and Berman (1999).

Lemma 4.2. CmaxðSÞ ¼ C0maxðSÞ þ tðSÞ.

In what follows, we study the tour-version of tree–RF2kCmax. Averbakh and Berman (1996, 1999) have developed several 3/2-approximationalgorithms for it. We here present an improved 10/7-approximation algorithm. Define k; I1; I

01 and I2 as in Section 3.1, where

p1,k = min{p1,k,p2,k}. Note that any depth-first tour is optimal for TSP on a tree.

Algorithm Tour-F2-Tree

Step 1. Choose a depth-first tour bT such that k is adjacent to 0.Step 2. Construct two permutation schedules based on bT and bT R. Let S1 denote the better one.Step 3. Construct a permutation schedule S2 based on the sequence a ¼ ðbT n ðI2 [ fkgÞ; bT n I01Þ. If pmax 6 L, generate another permutation

schedule S3 based on the sequence ðbT n I2; bT n I1Þ. Note that k is the first job in the sequence defined by bT .Step 4. Choose the best one among S1, S2 and S3 (if available) as the approximate solution.

Lemma 4.3. Let A = max{pmax,L} and piðJÞ ¼P

j2Jpi;j for J � {1,2, . . . ,n} and i = 1, 2. Then it holds that (i) CTF2max P Aþ T; (ii)

CTF2max P p1ðI01Þ þ p1;k þ p2;k þ p2ðI2Þ þ T.

Proof. Running Johnson (1954)’s Algorithm to solve the corresponding zero travel time problem to optimality will give a permutationschedule with the job sequence ðI01; k; I2Þ. So, we have

C0maxðS

TF2ÞP max A; p1 I01� �þ p1;k þ p2;k þ p2ðI2Þ

� �:

By Lemma 4.2, it holds that CTF2max P C0

maxðSTF2Þ þ T . Thus, the desired conclusions hold. h

From Theorem 1 in Averbakh and Berman (1999), we know that C0maxðS1Þ 6 3

2 A. Combining it with Lemma 4.2, we have the followinglemma.

Lemma 4.4. CmaxðS1Þ 6 32 Aþ T.

Several bounds on the makespan of S2 and S3 are given in the following two lemmas.

Lemma 4.5. CmaxðS2Þ 6 CTF2max þmaxf0; p2ðI01Þ � p1;k; p1ðI2Þ � p2;kg þ T: Specially, if pmax > L, then CmaxðS2Þ 6 CTF2

max þ T.

Proof. Since each machine travels the tour bT at most twice in S2, we have t(S2) 6 2T. Since S2 is a permutation schedule based on thesequence a, there is an index l such that

C0maxðS2Þ ¼

Xl

j¼1

p1;aðjÞ þXn

j¼l

p2;aðjÞ;

where a(j) is the jth element of a. If a(l) = k, then

C0maxðS2Þ ¼ p1 I01

� �þ p1;k þ p2;k þ p2ðI2Þ 6 CTF2

max � T;

where the inequality follows from Lemma 4.3(ii). Similarly, if aðlÞ 2 I01, then

C0maxðS2Þ 6 p1 I01

� �þ p2 I01

� �þ p2;k þ p2ðI2Þ 6 CTF2

max � T þ p2 I01� �� p1;k;

if a(l) 2 I2, then

C0maxðS2Þ 6 p1 I01

� �þ p1;k þ p1ðI2Þ þ p2ðI2Þ 6 CTF2

max � T þ p1ðI2Þ � p2;k:

In addition, if pmax > L, then a(l) = k must hold. Thus, by Lemma 4.2, we obtain the desired conclusions. h

Lemma 4.6. If pmax 6 L, then Cmax(S3) 6 L + p1,k + 2T.


Proof. Since each machine travels the tour bT at most twice in S3, t(S3) 6 2T holds. Thus, by Lemma 4.2, we need only to proveC0

maxðS3Þ 6 Lþ p1;k.Consider the corresponding zero travel time problem. As shown in Yu and Liu (1999), I01; I2; k

� �; k; I01; I2� ��

is an optimal schedule for thecorresponding open shop problem, where its makespan is max{L,pmax} = L. Then, k; I01; I2

� �; ðk; I01; I2Þ

� �is a flow shop schedule with

makespan no more than L + p1,k, i.e., C0maxðS3Þ 6 Lþ p1;k. h

Using Lemmas 4.3, 4.4, 4.5, 4.6, we can prove the performance ratio of Algorithm Tour-F2-Tree.

Theorem 4.3. Algorithm Tour-F2-Tree is a 10/7-approximation algorithm for the tour-version of tree–RF2kCmax.

Proof. If pmax > L, then by Lemmas 4.4, 4.5 and 4.3(i), we have


CmaxðS1Þ þ13

CmaxðS2Þ 613

CTF2max þ Aþ T 6

43

CTF2max:

Next we assume pmax 6 L. Then, A = L holds. Let 14 < b < 1

2 be a parameter whose value will be determined later. We analyze two cases.

Case 1. p1,k 6 bL. By Lemma 4.6, it holds that Cmax(S3) 6 (1 + b)L + 2T. Combining the inequality with Lemma 4.4, we have

minfCmaxðS1Þ;CmaxðS3Þg 62� 2b3� 2b

CmaxðS1Þ þ1

3� 2bCmaxðS3Þ 6

4� 2b3� 2b

ðAþ TÞ 6 4� 2b3� 2b

CTF2max:

Case 2. p1,k > bL. Then, it holds that

p1ðI2Þ � p2;k 6 L� p1;k � p2;k 6 L� 2p1;k 6 ð1� 2bÞL;

and

p2 I01� �� p1;k 6 L� p2;k � p1;k 6 ð1� 2bÞL:

By Lemma 4.5, we have CmaxðS2Þ 6 CTF2max þ ð1� 2bÞLþ T. Further, by Lemma 4.4, we have

minfCmaxðS1Þ;CmaxðS2Þg 64b

4bþ 1CmaxðS1Þ þ

14bþ 1

CmaxðS2Þ 61

4bþ 1CTF2

max þ Aþ T 64bþ 24bþ 1

CTF2max:

Combining Cases 1 and 2, and setting b = 1/3, we obtain

minfCmaxðS1Þ;CmaxðS2Þ;CmaxðS3ÞgCTF2

max

6 max4� 2b3� 2b

;4bþ 24bþ 1

� ¼ 10

7:


5. Conclusions

In this paper we discuss some routing open shop and flow shop scheduling problems in which the jobs are located at the vertices of anundirected graph and the machines move between the vertices to process the jobs. For the open shop problem on a general graph, we pres-ent approximation algorithms for various cases. An obvious direction for further research is to develop better approximation algorithms,especially for the m-machine cases. Also, it is interesting to decide whether the two-machine cases have approximation algorithms withthe performance ratio q or r, i.e., algorithms that do as well as applied to the underlying TSP or SHPP. For the two-machine flow shop prob-lem on a tree whose complexity is left open in the literature, we give the NP-hardness proof. Also, we prove that the tour-version of thetwo-machine flow shop problem on a general graph has a permutation schedule that is optimal. However, it is open whether the path-ver-sion has the property. We present a 10/7-approximation algorithm for the tour-version of the two-machine flow shop problem on a tree.The path-version is still in need of efficient approximation algorithms.

Acknowledgements

The authors are grateful to the anonymous referees for their helpful comments. This research is supported by the National Natural Sci-ence Foundation of China (Grants No. 10771067 and No. 70871038) and the Fundamental Research Funds for the Central Universities ofChina.

References

Afrati, F., Cosmadakis, S., Papadimitriou, C.H., Papageorgiou, G., Papakostantinou, N., 1986. The complexity of the traveling repairman problem. Informatique Theorique etApplications 20 (1), 79–87.

Augustine, J.E., Seiden, S., 2004. Linear time approximation schemes for vehicle scheduling problems. Theoretical Computer Science 324, 147–160.Averbakh, I., Berman, O., 1996. Routing two-machine flowshop problems on networks with special structure. Transportation Science 30, 303–314.Averbakh, I., Berman, O., 1999. A simple heuristic for m-machine flow-shop and its applications in routing-scheduling problems. Operations Research 47, 165–170.Averbakh, I., Berman, O., Chernykh, I.D., 2005. A 6/5-approximation algorithm for the two-machine routing open-shop problem on a 2-node network. European Journal of

Operational Research 166, 3–24.Averbakh, I., Berman, O., Chernykh, I.D., 2006. The routing open-shop problem on a network: Complexity and approximation. European Journal of Operational Research 173,

531–539.


Bhattacharya, B., Carmi, P., Hu, Y., Shi, Q., 2008. Single vehicle scheduling problems on path/tree/cycle networks with release and handling times. Lecture Notes in ComputerScience 5369, 800–811.

Christofides, N., 1976. Worst-case analysis of a new heuristic for the traveling salesman problem. Technical Report. Pittsburgh: Graduate School of Industrial Administration,Carnegie-Mellon University.

Gaur, D.R., Gupta, A., Krishnamurti, R., 2003. A 53-approximation algorithm for scheduling vehicles on a path with release and handling times. Information Processing Letters

86, 87–91.Gonzalez, T., Sahni, S., 1976. Open shop scheduling to minimize finish time. Journal of the Association for Computing Machinery 23, 665–679.Hoogeveen, J.A., 1991. Analysis of Christofide’s heuristic: Some paths are more difficult than cycles. Operations Research Letters 10, 291–295.Johnson, S.M., 1954. Optimal two- and three-stage production schedules with setup times included. Naval Research Logistic Quarterly 1, 61–68.Karuno, Y., Nagamochi, H., 2003. 2-Approximation algorithms for the multi-vehicle scheduling problem on a path with release and handling times. Discrete Applied

Mathematics 129, 433–447.Karuno, Y., Nagamochi, H., 2004. An approximability result of the multi-vehicle scheduling problem on a path with release and handling times. Theoretical Computer Science

312, 267–280.Karuno, Y., Nagamochi, H., Ibaraki, T., 1997. Vehicle scheduling on a tree with release and handling time. Annals of Operations Research 69, 193–207.Karuno, Y., Nagamochi, H., Ibaraki, T., 2002. Better approximation ratios for the single-vehicle scheduling problems on line-shaped networks. Networks 39, 203–209.Lawler, E.L., Lenstra, J.K., Rinnooy Kan, A.H.G., Shmoys, D.B., 1993. Sequencing and scheduling: Algorithms and complexity. In: Handbooks in Operations Research and

Management Science. In: Graves, S.C., Rinnooy Kan, A.H.G., Zipkin, P. (Eds.), . Logistics of Production and Inventory, vol.4. North-Holland, Amsterdam, pp. 445–522.Tsitsiklis, J.N., 1992. Special cases of traveling salesman and repairman problems with time windows. Networks 22, 263–282.Yu, W.-C., Liu, Z., 1999. Bi-directional scheduling algorithms for some two-machine shop problems. Journal of East China University of Science and Technology 25 (6), 629–

633. in Chinese.Yu, W., Liu, Z., 2010. Single-vehicle scheduling problems with release and service times on a line. Networks, DOI: 10.1002/net.20393.

Documents

Routing open shop and flow shop scheduling problems