A computational study of the permutation flow shop problem based on a tight lower bound

Abstract

We consider the classical permutation flow shop problem which requires scheduling n jobs through m machines which are placed in series so as to minimize the makespan. This problem is known to be $\text{NP}$-hard. We describe a branch-and-bound algorithm with a lower bounding procedure based on the so-called two-machine flow shop problem with time lags, ready times, and delivery times. We present extensive computational results on both random instances, with up to 8000 operations, and well-known benchmarks, with up to 2000 operations, which show that the proposed algorithm solves large-scale instances in moderate CPU time. In particular, we report proven optimal solutions for benchmark problems which have been open for some time.

Introduction

In this paper, we address the Permutation Flow Shop Problem which can be defined as follows. Each of n jobs from the job set J={1,2,…,n} has to be processed nonpreemptively on m machines M₁,M₂,…,M_m in that order. The processing time of job j on machine M_i is p_ij. At any time, each machine can process at most one job and each job can be processed on at most one machine. The problem is to find a processing order of the n jobs, the same for each machine (i.e. passing is not allowed), such that the time C_max at which all the jobs are completed (makespan) is minimized. Using the notation specified in Pinedo [1], this problem is denoted $\text{F}\text{|}\text{prmu}\text{|}\text{C}{}_{\mathrm{<mtext>max</mtext>}}$.

It is noteworthy that if m⩾4, then there might exist nonpermutation schedules (i.e. with a specific job sequence for each machine) which dominate permutation ones. For instance, Potts et al. [2] exhibit a family of instances for which the value of the optimal permutation schedule is worse than that of the optimal nonpermutation schedule by a factor of more than $\text{1}\text{2}\text{m}$. However, for the sake of simplicity, we will adhere to a well-established tradition in scheduling theory and restrict our attention solely to permutation schedules.

Since the publication of the seminal paper of Johnson [3], the flow shop problem has become one of the most intensively investigated topics in scheduling theory. This interest is not only motivated by its practical relevance, but also by its deceptive simplicity and challenging hardness. Though, the flow shop problem is still considered as a very hard nut to crack. Indeed, up to the mid of the 1990s, the best available branch-and-bound algorithms experience difficulty in solving instances with 15 jobs and 4 machines [4, p. 393]. It is interesting to observe that at about the same time, instances of the celebrated traveling salesman problem with few hundreds of vertices could be solved quite routinely.

It is well-known that the case of two machines (m=2), could be easily solved using Johnson's rule which generates an optimal schedule in $\text{O(n}\text{log}\text{n)}$ time. For m⩾3, however, the problem is shown to be strongly $\text{NP}$-hard [5]. Interestingly, one can note that the quest for optimization strategies for the $\text{F}\text{|}\text{prmu}\text{|}\text{C}{}_{\mathrm{<mtext>max</mtext>}}$ started about 40 years ago, shortly after the discovery by Land and Doig [6] of the branch-and-bound technique. Indeed, the first branch-and-bound algorithms for the $\text{F}\text{|}\text{prmu}\text{|}\text{C}{}_{\mathrm{<mtext>max</mtext>}}$ were developed simultaneously, but independently, by Ignall and Schrage [7] and Lomnicki [8]. Following this pioneering work, several additional branch-and-bound algorithms have been published. The most significant contributions include Brown and Lomnicki [9], McMahon and Burton [10], Ashour [11], Lageweg et al. [12], Potts [13], Grabowski [14], Carlier and Rebai [15], and Cheng et al. [16]. All these algorithms, except the latter, can solve only instances of very limited size.

In addition to optimization methods, the intractability of the $\text{F}\text{|}\text{prmu}\text{|}\text{C}{}_{\mathrm{<mtext>max</mtext>}}$ motivated several authors to focus on the development of heuristic solution strategies. These heuristics are traditionally divided into two broad classes: constructive methods and local search methods. A nonexhaustive list of constructive methods include Campbell et al. [17], Dannenbring [18], and Nawaz et al. [19], to quote just a few. These methods are simple and fast, but perform rather poorly. The only significant exception being the heuristic of Nawaz et al., which is currently considered as the champion among constructive heuristics. On the other hand, most local search methods are based on modern metaheuristics. The papers include the simulated annealing algorithm of Osman and Potts [20], the tabu search algorithm of Nowicki and Smutnicki [21], and the genetic algorithm of Reeves [22]. Recently, a new local search paradigm based on a truncated branch-and-bound strategy, and called branch-and-bound-based local search, has been implemented for the $\text{F}\text{|}\text{prmu}\text{|}\text{C}{}_{\mathrm{<mtext>max</mtext>}}$ by Haouari and Ladhari [23] and shown to yield approximate solutions of excellent quality.

Moreover, during the last decade, an increased effort has been devoted to the design of approximation algorithms with guaranteed worst case bounds for the $\text{F}\text{|}\text{prmu}\text{|}\text{C}{}_{\mathrm{<mtext>max</mtext>}}$. The best known approximation algorithm has performance guarantee $\text{⌈}\text{m}\text{2}\text{⌉}$. The reader is referred to Smutnicki [24] for a survey. Recently, Sviridenko [25] proposed a new approximation algorithm which delivers a permutation schedule with makespan at most $\text{O}\text{m}\text{log}\text{m}$ times of the optimal nonpermutation schedule.

In this paper, we develop an effective branch-and-bound algorithm for the $\text{F}\text{|}\text{prmu}\text{|}\text{C}{}_{\mathrm{<mtext>max</mtext>}}$. Many of the features of our algorithm, such as the upper bounding and branching strategies, were previously implemented by many authors. However, the most innovative aspect of our work lies in the implementation of a (new) tight lower bound that dominates all other previously used ones. Our algorithm has produced proven optimal solutions for a number of (hard) well-known instances with up to 2000 operations (n=200 and m=10) that have been open for 10 years, and randomly generated instances with up to 8000 operations (n=2000 and m=4). To the best of our knowledge, the solution of such large instances has never been previously reported in the literature.

The rest of the paper is structured as follows. Section 2 provides a detailed description of most of the lower bounds that have been used so far. Section 3 describes the proposed branch-and-bound algorithm, including the branching rule, the search strategy, as well as the lower bounding strategy. Computational results are given in Section 4. Finally, some concluding remarks are provided.