An exact dynamic programming algorithm for the precedence-constrained class sequencing problem

Highlights

• Dynamic programming algorithm for precedence-constrained class sequencing problem.

• Based on sub-procedures tailored to the structure of the problem.

• New lower bounding technique.

• Algorithm solves large instances to proven optimality.

Abstract

This article discusses the precedence-constrained class sequencing problem (PCCSP). In scheduling terms, this is a single-machine problem with precedence constraints and family setups with the goal of minimizing the number of setups. From a practical perspective, PCCSP covers a wide range of applications such as, for example, scheduling problems in systems with job families where multipurpose processors need retooling to switch from a job of one family to a job of another family. Previous research has shown that PCCSP is NP-hard and that no polynomial-time algorithm with constant worst-case performance exists unless $\mathcal{P}=\mathcal{NP}$. So far, only little research has been conducted on the development of specific computational methods for PCCSP. This article bridges this gap by proposing a dynamic programming algorithm for solving PCCSP exactly. It comprises specialized lower bound computations, node merging and precedence reasoning algorithms, and heuristics that successfully exploit the problem’s structure. Based on extensive numerical experiments, we analyze the algorithm in detail and show that it outperforms mixed-integer programming and constraint programming models.

Introduction

We consider a single-machine scheduling problem in which the operations that need to be executed on this machine are partitioned into classes. A setup is required between the execution of two consecutive operations if they belong to different classes. Furthermore, precedence constraints between pairs of operations are given. The precedence-constrained class sequencing problem, or PCCSP for short, asks for a total order of all operations such that the precedence constraints are respected, and the number of setups is minimized.

More formally, consider a set V of n operations, a set $\mathcal{C}$ of classes, and a set $A\subseteq V\times V$ of precedence constraints. Each operation $v\in V$ belongs to exactly one class $c_v\in \mathcal{C}$. Let $C\in {\mathcal{C}}^V$ be the class assignment vector. An instance of PCCSP will be denoted by $(V,A,\mathcal{C},C)$. Consider the directed graph $G=(V,A)$, where each operation $v\in V$ is represented by a vertex v and each precedence constraint $(v,w)\in A$ is modeled by an arc $(v,w)$. Graph G will be called precedence graph. A solution of PCCSP is a total order of the operations that satisfies all precedence constraints. Equivalently, a solution is a bijection $f:\{1,\dots ,n\}\to V$ such that $\left(f\right(j),f(i\left)\right)\notin A$ for all $1⩽i<j⩽n$, and its objective value –the number of setups– is ${\sum }_{i=1}^{n-1}{s}_i$, where $s_i=1$ if $c_{f\left(i\right)}\ne c_{f(i+1)}$ and 0 otherwise. Clearly, a solution exists if and only if G is acyclic. This property can efficiently be checked, for example, with a depth-first-search-based algorithm taking $\mathcal{O}\left(\right|V|+|A\left|\right)$ time (see, e.g., Sedgewick and Wayne, 2011, pp. 576–577). We assume that G is acyclic.

An illustrative example of a PCCSP instance is given in Fig. 1. It consists of 17 operations, 3 classes (represented by the colors white, gray and black), and 24 precedence constraints. The sequence (9, 8, 12, 1, 2, 6, 10, 13, 3, 14, 4, 5, 11, 15, 17, 7, 16) is an optimal solution with six setups.

Lofgren (1986) and Lofgren et al. (1991) introduce PCCSP. The authors address the problem of routing printed circuit boards through an assembly cell and define PCCSP to capture this practical problem with graph theory. They prove that PCCSP is NP-hard, show that two classes of heuristics have arbitrary bad worst-case performance, develop a set of heuristics, and provide some computational results. Interestingly, the authors prove that the non-repetitive shortest common supersequence problem, which is a restricted but still NP-hard version of the well-known shortest common supersequence problem, is a special case of PCCSP. Altogether, their prolific contributions show that PCCSP is a challenging and practically relevant optimization problem. This view is further supported by Tovey (2004) and Correa et al. (2007) who prove that no polynomial-time algorithm with constant worst-case performance exists for PCCSP unless $\mathcal{P}=\mathcal{NP}$. We remark that PCCSP is trivial to solve if no precedence constraints exist or if there are at most two classes. However, as shown in (Lofgren et al., 1991, Darte, 2000), it becomes NP-hard in the strong sense if there are at least three classes, even if the precedence graph consists only of disjoint paths.

In the scheduling literature, PCCSP may be considered as a batch sequencing problem, in which the classes are typically called (job or operation) families. A batch refers to a maximal set of operations that are contiguously processed on a machine (Potts and Kovalyov, 2000). Clearly, large batches result in a small number of setups. In PCCSP, it may not be possible to execute all operations of a class in one batch due to the precedence constraints. According to the general three-field classification scheme proposed by Graham et al. (1979) and using notation of Potts and Kovalyov (2000), PCCSP can be written as 1$|s$, prec $|\sum s$, where 1 stands for the single-machine environment, s for identical (or common) family setup times and prec for precedence constraints. Single-machine scheduling problems with family setups have regularly been studied, see e.g., (Mason and Anderson, 1991, Schutten et al., 1996, Crauwels et al., 1998). The precedence-constrained single-machine problem has also received considerable attention, see, e.g., (Potts, 1985, Margot et al., 2003, Ambühl et al., 2006, Ambühl and Mastrolilli, 2009, Tanaka and Sato, 2013). Setups and precedence constraints together have been considered in settings that differ considerably from PCCSP. For example, Balas et al. (2008) look at a single-machine problem with setup times and specific precedence constraints that model time window constraints. Gacias et al. (2010) consider a parallel machine scheduling problem with precedence constraints and sequence-dependent setup times. We are not aware of articles specifically treating 1$|s$, prec $|\sum s$.

PCCSP can also be formulated as a sequential ordering problem (SOP). SOP is an asymmetric traveling salesman problem with precedence constraints. A tour is feasible if each city is visited once and the precedence constraints are respected in the tour. The goal is to find a feasible tour with minimum total travel distance. The construction of a SOP instance from PCCSP is straightforward. Each operation is represented by a node and a pseudo node is introduced for the start and end of the tour. The travel distance matrix is 0/1 and symmetric: an entry is 1 if the two involved nodes correspond to different-class operations and 0, otherwise. Extensive research has been conducted on SOP, see e.g., (Escudero, 1988, Ascheuer et al., 1993, Gambardella and Dorigo, 2000, Anghinolfi et al., 2011, Montemanni et al., 2013). Among the best exact methods are those developed by Jamal et al., 2017, Libralesso et al., 2019. In both articles, the algorithms are designed for a substantial amount of precedence constraints and typically give quite unsatisfactory results on the other instances due to weak lower bounds. Typical PCCSP instances are non-dense. Hence, solving PCCSP instances to proven optimality with these methods seems to be unpromising. Preliminary numerical experiments confirmed this. We therefore conclude that it is worthwhile to develop a method tailored to the specific structure of PCCSP.

PCCSP is closely related to a loop fusion problem addressed by Darte (2000). Loop fusion is a standard compiler optimization and loop transformation process in computer science. The loop fusion problem of Darte (2000) can briefly be described as follows. Given is a set of loops, which is the same as the set of operations in PCCSP. Each loop belongs to some type (of loops) and a set of precedence constraints between loops is specified. The goal is to find a total order of the loops so that the number of setups is minimized. A setup must be performed when switching from one type of loop to another, and – this is the difference with PCCSP – one can also specify the need for a setup between loops of the same type. These so-called fusion-preventing constraints make the loop fusion problem more general than PCCSP. Darte (2000) formulates the loop fusion problem with graph theory, establishes a link to the scheduling literature, and develops complexity results for some variants of the loop fusion problem. We refer to his publication for further details.

PCCSP is also related to the following mixed graph coloring problem. Given is a mixed graph $G^{\mathrm{mix}}=(V,A,E)$ where V is a set of vertices, A a set of arcs and E a set of edges. A function $\varphi$ is a coloring of $G^{\mathrm{mix}}$ if it assigns to each vertex $v\in V$ a positive integer $\varphi \left(v\right)$ such that $\varphi \left(v\right)⩽\varphi \left(w\right)$ if $(v,w)\in A$ and $\varphi \left(v\right)\ne \varphi \left(w\right)$ if $\{v,w\}\in E$. The number of colors of a coloring $\varphi$ is given by the largest integer $\varphi \left(v\right)$ assigned to a vertex $v\in V$. The goal is to find a coloring of G with a minimum number of colors. An instance $(V,A,\mathcal{C},C)$ of PCCSP can be formulated as a mixed graph coloring problem as follows. The mixed graph $G^{\mathrm{mix}}=(V,A,E)$ is obtained by simply adding an edge $\{v,w\}\in E$ to the precedence graph $G=(V,A)$ for each pair of vertices $v,w$ of distinct classes, i.e., $c_v\ne c_w$. Observe that the undirected part $(V,E)$ of $G^{\mathrm{mix}}$ has a special structure: it is a complete k-partite graph where k equals the number $\left|\mathcal{C}\right|$ of classes. Given a coloring $\varphi$, a solution of PCCSP can be obtained as follows. According to coloring $\varphi$, we first execute all operations v with $\varphi \left(v\right)=1$, then all operations v with $\varphi \left(v\right)=2$, and continue this process until all operations are executed. Considering a group of operations with the same color, we execute them in an order that respects the precedence constraints A, which can easily be found as the precedence graph G is acyclic. The so-obtained total order of the operations is a solution of PCCSP, and the number of setups is exactly the number of colors of $\varphi$ minus 1 as all operations with the same color $\varphi \left(v\right)$ belong to the same class. As a result, a coloring of $G^{\mathrm{mix}}$ with a minimum number of colors corresponds to a solution of PCCSP with a minimum number of setups. The discussed mixed graph coloring problem is introduced by Sotskov et al. (2002). The most competitive exact algorithm is proposed by Andreev et al. (2000). Based on numerical experiments, the authors conclude that their approach is less suited for mixed graphs where the number of edges is larger than the number of arcs as their lower bounding procedures are not taking into account the edges. In PCCSP instances, the number of edges is typically much larger than the number of arcs. Hence, solving PCCSP instances with their method seems to be unpromising.

From a more practical perspective, PCCSP models various recurring scheduling problems in systems where multipurpose processors, i.e., processors with the flexibility to perform multiple types of operations, need retooling or some other type of setup to switch from one operation to another (Tovey, 2004). Lofgren et al. (1991) describe an application in the semiconductor industry. Darte (2000) mentions a traveling salesman application where the salesman (or another type of worker) must perform a set of tasks in some partial order, each task must be executed in some given city, and the goal is to minimize the number of moves between cities. Camelot (2012) studies an aircraft disassembly process where parts of an end-of-life aircraft are collected for reuse. In this setting, a set of tasks needs to be executed according to a given partial order. Each task is performed in a specific zone of the aircraft, and the objective is to minimize the number of moves from one zone to another.

This paper presents a dynamic programming (DP) algorithm tailored to the structures of PCCSP. It makes it possible to solve large PCCSP instances to optimality within reasonable computation times. The dynamic program is based on a reformulation of the problem and comprises generic dominance rules, and specific lower bound computations, node merging methods, precedence reasoning algorithms and heuristics. A particular contribution is a new bounding method that takes the classes and the precedence constraints simultaneously into account. Consequently, DP does not heavily rely on the density of the precedence graph, and therefore does not fail to solve instances with non-dense precedence graphs.

Note that the general techniques incorporated into our algorithm, such as lower bound computations, have regularly been used in DP methods. Interested readers are referred to (Morin and Marsten, 1976, Easton, 1990, Mingozzi et al., 1997, Sewell and Jacobson, 2012). Similar techniques can be found in branch-and-bound algorithms, see e.g., (Demeulemeester and Herroelen, 1992, Allahverdi and Al-Anzi, 2006, Nessah and Kacem, 2012). In this paper, we exploit the recursive structure of our problem formulation. Therefore, we decide to use the dynamic programming terminology.

The remainder of this article is organized as follows. The next section proposes a DP algorithm for PCCSP. After introducing the general DP structure, the specific sub-procedures incorporated into the method are discussed. Section 3 provides an extensive computational study. The numerical results are used to analyze the sub-procedures of the DP algorithm, to discuss the difficulty of the generated instances, and to compare our algorithm with integer linear programming and constraint programming methods. Concluding remarks are given in Section 4 and detailed computational results are provided in the appendix.