Discrete Optimization
A branch and bound algorithm to minimize the total tardiness for m-machine permutation flowshop problems

https://doi.org/10.1016/j.ejor.2004.12.023Get rights and content

Abstract

The m-machine permutation flowshop problem with the total tardiness objective is a common scheduling problem, which is known to be NP-hard. Here, we develop a branch and bound algorithm to solve this problem. Our algorithm incorporates a machine-based lower bound and a dominance test for pruning nodes. We undertake a numerical study that evaluates our algorithm and compares it with the best alternative existing algorithm. Extensive computational experiments indicate that our algorithm performs better and can handle test problems with n  20.

Introduction

In the permutation flowshop problem, each of n jobs has to be processed on machines 1, …, m in that order. The processing times of each job on each machine are known. At any time, each machine can process at most one job and each job can be processed on at most one machine. Once the processing of a job on a machine has started, it must be completed without interruption. Also, each job must be processed in the same order at every machine. The usual objectives are the minimization of the make-span, flow-time, tardiness, lateness, and the number of jobs late (see Pinedo [13] for a review of the general flowshop problem). Here, the objective is to minimize the total tardiness. Tardiness equals the amount by which a job’s completion time exceeds its due date.

Schedules where each job must be processed in the same order at every machine are called permutation schedules. When m  2, the restriction to such schedules is harmless; however, when m > 3, there may exist a general schedule whose total tardiness is strictly less than the total tardiness of any permutation schedule (see [13]). Finding such a schedule is often computationally impractical; moreover, as discussed in Kim [8] there are many real situations where only permutation schedules are feasible. Most approaches to the m machine flowshop problem restrict attention to permutation schedules.

The general m machine flow time problem with the total tardiness time objective is NP-hard in the ordinary sense for m = 1 and NP-hard in the strong sense for m  2 (the special case where the due dates are equal to 0 is NP-hard in the strong sense for m  2): see Appendix D of [13]. Consequently, there has been great interest in developing heuristic solutions [5], [6], [7], [16], [22]. See [10] for more details on heuristic approaches and other general issues.

Most optimal algorithms for single machine problems combine dynamic programming or branch and bound with decomposition properties developed by Lawler [12], Potts and Wassenhove [15] and Szwarc [18]. Harikawa [4] proposes an effective algorithm, based on Lawler’s decomposition theorem. Szwarc and Mukhopadhyay [20] and Tansel [21] develop branch and bound algorithms incorporating decomposition properties, which can handle problem with over 100 jobs. Recently, Szwarc et al. [19] employ an improved decomposition rule, which allows them to solve problems with 300 jobs.

Only a few articles deal with optimal algorithms for multiple machine problems. Kim [7] and Sen et al. [17] apply branch and bound to two machine problems. Kim [8] applies branch and bound algorithm to general m machine problems using a special branching scheme, which he calls “backward branching”. In his scheme, a node corresponds to a partial sequence of jobs placed at the end of a whole job sequence. When a node branches, one or more nodes are defined by placing one more job in front of the partial sequence associated with the current branch node. After characterizing properties of nodes, Kim derives lower bounds for the branch and bound algorithm together with a dominance rule. The dominance rule leads to a problem size reduction procedure, which sometimes yields a problem with a smaller n.

In Section 2, we briefly describe the problem and derive a new machine based lower bound. Our bound employs estimates of the earliest start time for jobs assigned to each position in the job sequence. (These estimates were derived in Chung et al. [1], which dealt with the flow-time objective.) Section 3 presents a dominance test, which helps to prune nodes. An outline of the algorithm appears in Section 4. Section 5 reports on a numerical study that evaluates our algorithm and compares it with Kim [8]—the best alternative existing algorithm. Extensive computational experiments involving over 40,000 test problems suggest that our algorithm performs better and can handle problems with n  20. Section 6 states our conclusions.

Section snippets

The problem description and a lower bound

Branch and bound algorithms are commonly applied to the permutation flowshop problem, which is known to be NP hard. The effectiveness of a branch and bound algorithm is heavily influenced by its lower bounds. Such bounds are more useful when they are tighter and easier to compute. In this section, we develop a useful machine-based lower bound.

Consider the search tree for our algorithm [11]. The root node ∅ represents the null schedule. Every other node represents a partial schedule σ = (σ(1), …, σ(s

Dominance criteria

Here, we define a dominance relation between partial schedules, which can help us to prune nodes. Specifically, let σ1 and σ2 be two partial schedules for the same set of jobs S. We say that σ1 dominates σ2, if G(σ1σ)  G(σ2σ) for every permutation σ of the jobs in N  S. If the previous inequality is strict, we say that σ1 strictly dominates σ2. Extending results in Section 3 of [1], the next theorem and its corollary develop conditions for one partial schedule to dominate another.

Theorem 3.1 Node dominance

Let σ1 and σ2 be

The algorithm

Branch and bound is commonly applied to scheduling problems. Following [1], our algorithm employs an adaptive depth-first plus backtracking search strategy and uses a dominance test and lower bound to fathom nodes. The advantages of a depth-first strategy are: (1) the number of active nodes is always less than or equal to n, (2) the bottom of the tree is reached faster so good upper bounds can be found earlier, (3) a stack can be used to reduce computations. Our current algorithm differs from

Computational experiments

This section reports on computational experiments that evaluate the effectiveness of our branch and bound algorithm (CFK) and compare its performance with Kim’s branch and bound algorithm (KIM)—the best alternative algorithm for the multiple machine case. The results suggest that CFK outperforms KIM and can handle test problems with n  20.

CFK and KIM were coded in C and run under Borland C++ version 5.0 on a 1700 MHz Pentium 4 under Windows 2000. Our implementations of these algorithms use data

Conclusions

The m-machine permutation flowshop problem with the total tardiness objective is a common scheduling problem, which is known to be NP-hard for all m. Here, we develop a branch and bound algorithm to solve this problem. Our algorithm incorporates a machine-based lower bound and a dominance test for pruning nodes. Extensive computational experiments suggest that the algorithm can handle test problems with n  20 and dramatically outperforms Kim [8]—the best alternative algorithm for the multiple

References (22)

  • C. Chu

    A branch and bound algorithm to minimize total tardiness with different release dates

    Naval Research Logistics

    (1992)
  • Cited by (50)

    • A comprehensive review of Branch-and-Bound algorithms: Guidelines and directions for further research on the flowshop scheduling problem

      2020, Expert Systems with Applications
      Citation Excerpt :

      Consequently, a vast array of constraints were explored: PFSPs with blocking (Ronconi & Armentano, 2001); sequence-dependant setup times (Rios-Mercado & Bard, 1999); due dates and release dates (Grabowski, Skubalska, & Smutnicki, 1983; Tadei et al., 1998). Furthermore, different performance criteria were studied: Total Flow Time (Bansal, 1977); Total Tardiness (Chung, Flynn, & Kirca, 2006) and the weighted sum of different objectives (Nagar, Heragu, & Haddock, 1995). A B&B for scheduling consists of an implicit enumeration of the solutions by creating partial sequences job per job and creating a tree that branches into the complete solutions.

    • A branch-and-bound approach to schedule a no-wait flow shop to minimize the CVaR of the residual work content

      2019, Computers and Industrial Engineering
      Citation Excerpt :

      A depth-first strategy is pursued, prioritizing nodes with longer partial sequences to find a first complete solution as soon as possible. The same problem has been addressed in Chung, Flynn, and Kirca (2006) developing new bounds able to cope with a number of jobs to schedule greater than 20. In Samarghandi and Behroozi (2017), the special case of the no-wait flow shop problem with due dates is considered and a mixed integer programming model, two quadratic mixed integer programming models, two constraint programming models and a novel graph representation are provided.

    • A hybrid iterated greedy algorithm for total tardiness minimization in permutation flowshops

      2016, Computers and Industrial Engineering
      Citation Excerpt :

      Branch-and-bound algorithms are proposed for the single machine case (Della Croce, Tadei, Baracco, & Grosso, 1998) as well as the two machine case (Kim, 1993; Pan, Chen, & Chao, 2002; Pan & Fan, 1997; Schaller, 2005; Sen, Dileepan, & Gupta, 1989). Chung, Flynn, and Kirca (2006) was able to solve problems up to 15 jobs and 2 machines, and 20 jobs and 8 machines. Most recently, Baker (2013) reports the results of a comparison with Chung et al.’s branch-and-bound algorithm and a commercial Excel add-in (RSP), where RSP was able to solve all the generated problems having 16 jobs with 4 and 8 machines, all of the 8-machine problems with 18 jobs except for one, and all of the 4-machine problems with 22 jobs except for two; within an hour of CPU time on a computer that has an Intel Core2 2.7 GHz processor with 8 GB of RAM.

    View all citing articles on Scopus
    View full text