Scheduling Disjoint Setups in a Single-Server Permutation Flow Shop Manufacturing Process

Abstract

In this paper, a manufacturing process for a single-server permutation Flow Shop Scheduling Problem with sequence dependant, disjoint setups and makespan minimization is considered. The full problem is divided into two levels, and the lower level, aimed at finding an optimal order of setups for a given fixed order of jobs, is tackled. The mathematical model of the problem is presented along with a solution representation. Several problem properties pertaining to the problem solution space are formulated. The connection between the number of feasible solutions and the Catalan numbers is demonstrated and a Dynamic Programming-based algorithm for counting feasible solution is proposed. An elimination property is proved, which allows one to disregard up 99.99% of the solution space for instances with 10 jobs and 4 machines. A refinement procedure allowing us to improve the solution in the time required to evaluate it is shown. To illustrate how the properties can be used, two solving methods were proposed: a Mixed-Integer Linear Programming formulation and Tabu Search metaheuristic. The proposed methods were then tested in a computer experiment using a set instance based on Taillard’s benchmark; the results demonstrated their effectiveness even under a short time limit, proving that they could be used to build algorithms for the full problem.

1. Introduction

The permutation Flow Shop Scheduling Problem (or FSSP) with makespan minimization is one of the oldest [1] classic discrete optimization problems. In the problem, there are n jobs processed in a system made up of m machines. and each job is processed on each machine in the same, predefined order. The task is to find an order in which the jobs are fed into the system that minimizes the time required to process them all (makespan). FSSP is commonly used to model and optimize various real-life manufacturing processes in industry or even other non-manufacturing multi-stage processes.

Since its introduction, FSSP have been extended and modified in many ways to model specific restrictions found in real-life production processes [2,3,4]. One of its most popular and earliest (see, e.g., a paper by Johnson [1]) extensions is considering setup times. Setups are meant to model additional activities performed on a machine between processing subsequent jobs. Such activities can include cleaning, re-fueling, inspection, change of machine settings (including different tool tips, etc.) or simply removal of the processed item and insertion of another.

Usually [5,6], it is assumed that setups can be performed independently, i.e., in the m-machine system, and up to m setups can be performed at the same time, provided each is conducted on a different machine. This is generally because either the machines are maintenance-free or there are separate crews for each machine available. However, in some production processes encountered in practice, it is not possible to perform setups simultaneously. This leads to a class of problems referred to as single-server problems [7], where a single server performs all setups in the system.

An example of such a restriction was found in a production process in a company located in Poland. The process involves metal-forming parts for various home appliances with the use of large hydraulic presses. Due to the size of the presses, heavy specialized carts are required to reconfigure them for different product types. The company owns only a single cart (server), due to its costs and the crew required to operate them. As a result, only a single machine can undergo a setup at any given time, i.e., the setups are disjoint.

We consider a special case of FSSP with sequence-dependent setup times, where only one setup crew is available (called hereinafter a full problem), and, at most, one setup can be performed in a system at a time (hence the setups are disjoint, or in other words—there is a single server). The motivation to tackle this problem is that despite the fact that disjoint setups are a practical constraint in the context of FSSP, they have not been adequately researched in the literature. Most of the previous work focused on theoretical complexity analysis, lacking a dedicated solving method or problem properties (see review in Section 2). The full problem can be dissected into two levels: (1) finding the order in which jobs are processed in the system (the upper level); and (2) finding the order of setups (the lower level). Such a decomposition into upper and lower problems is an existing literature practice when tackling complex scheduling problems (see, for example, Pongchairerks [8] or Bożejko et al. [9]). The full problem is relatively complex, as its NP-hardness has been proven even for several simplified cases (refer to the paper by Brucker et al. [10]). Thus, we decided to focus exclusively on the part introducing new constraints compared to relatively well-researched FSSP. Therefore, in this paper, we consider only a second level of the full problem, i.e., the order of jobs is fixed and only the order of setups is to be determined. We aim to identify problem properties and introduce new solving methods that can be used later to tackle the full problem, e.g., using a two-level approach.

The main objectives of this paper are to: (1) introduce a formal model of the researched problem; (2) formulate properties concerning the solution space of the problem: its size and methods of limiting the portion of the space that needs to be examined; (3) use the properties to propose solving methods that can be used in a two-level algorithm for the full problem. We achieved the goals by building a lattice path representation of a solution and identifying problem properties that allow us to explore the solutions space more efficiently. The main contributions of this paper are as follows:

• Proposing a mathematical model for the researched problem, i.e., finding the order of setups in FSSP with a single-server (see Section 1). The model can be easily extended to describe the full problem.
• Showing a relation between the number of feasible solutions and Catalan numbers for $m=2$ machines (see Section 4.2) and providing a method based on Dynamic Programming for counting feasible solutions for any $m>1$.
• Formulating an elimination property that allows us to quickly disregard the majority of the problem solution space (see Section 4.5), without losing optimality (see Section 4.3).
• Formulating a refinement procedure, based on the rearranging of continuous blocks of setups performed on the same machine. Such a procedure can improve some solutions in a time required to calculate an objective function (see Section 4.4).
• Introducing a Mixed Integer Linear Programming (MILP) formulation and a dedicated, heuristic solving method for the researched problem (see Section 5) that can be used in a two-level algorithm for the full problem. The experiments demonstrated that the heuristic algorithm (using the proposed problem properties) outperforms the MILP formulation for larger instances (see Section 6).

The remainder of this paper is structured as follows. In Section 2, we present a related literature, with the main emphasis on the FSSP and setup times. In Section 3, we formally define the researched problem and introduce a compact solution representation. Then, we follow with several problem properties in Section 4. The solving algorithms are described in Section 5 and tested in Section 6. Finally, the concluding remarks are in Section 7.

Notation

Throughout the paper, we will adopt the following notation. Boldfaced lowercase letters ($\mathit{x}$, $\mathit{\sigma }$) denote vectors (or sequences), with the k-th element of $\mathit{x}$ denoted $x_k$, and 0 being the zero vector. Ordinary letters, especially lowercase, usually denote scalars. Sets are generally denoted with calligraphic type ($\mathcal{J},\mathcal{S},\mathcal{X}$) with the exception of $\Sigma$ and $\mathbb{Z}$. Symbols i and j are used to refer to jobs (e.g., when iterating). Similarly, a and b are used to refer to machines, while k and l are used to refer to setups. The most important notation is summarized in

Table 1. Selected notation.

Symbol	Meaning
$\mathcal{J}$, n	Set of jobs, number of jobs
$\mathcal{M}$, m	Set of machines, number of machines
$\mathcal{S}$	Set of numbers from 1 to the number of setups
$p_i^a$	Processing time of job i on machine a
$s_i^a$	Setup time after job i on machine a
${{}^{\pi }S}_i^a,{{}^{\pi }C}_i^a$	Start and completion time of job i on machine a
${{}^{\sigma }S}_i^a,{{}^{\sigma }C}_i^a$	Start and completion time of setup after job i on machine a
$\mathit{\tau }$	Order of setups (explicit representation)
$\mathcal{T}$	Set of all possible $\mathit{\tau }$
$\mathit{\sigma }$	Order of setups (short representation)
$\Sigma$	Set of all possible $\mathit{\sigma }$
${\Sigma }_{\mathrm{feas}}$	Sets of feasible $\mathit{\sigma }$
$C_{\max }(\mathit{\sigma })$	Makespan for setup order $\mathit{\sigma }$
$C_k$	k-th Catalan number

.

2. Related Work

Scheduling problems are of interest to both scientists and practitioners due to their high complexity and a multitude of possible applications. Although many applications are related to typical production lines, scheduling is also used in healthcare for operation rooms’ planning [11], software testing [12], scheduling of heat parallel furnaces [13] or even cryptography [14]. To provide a proper context to the researched problem, we surveyed the vast literature on scheduling from the three perspectives: (1) FSSP and its variants; (2) setups as a scheduling constraint; and (3) disjoint setups.

2.1. Flow Shop Scheduling Problem

FSSP is one of the oldest scheduling problems, dating back to the 1960s. In one of the earliest papers, Johnson [1] tackled FSSP with setup times. The author considered a 2- and a 3-machine systems and proved the optimality of the introduced decision algorithm (called Johnson’s rule) for a 2-machine case. Due to its practical applications and mathematical simplicity, a wide variety of extensions for FSSP have been formulated since its introduction. Despite being around for over 6 decades, FSSP remains an active point of interest for scientists in field of operations research across the world. Below, we will mention several modern approaches to FSSP before moving on onto FSSP with setups.

A FSSP variant with uncertain processing, transport and setup times was considered in a paper by Rudy [15]. The author employed fuzzy sets in order to model the problem and then proposed a fuzzy-aware Simulated Annealing method that was tested against several fuzzy-oblivious variants, demonstrating the superiority of the fuzzy approach. Zeng et al. [16] considered material wastage in flexible FSSP with the batch process. The problem was solved by a hybrid, non-dominated sorting Genetic Algorithm (GA). Yu et al. [17] considered machine eligibility in their GA approach to FSSP, while Dios et al. [18] took the possibility of missing operations into account. The mentioned two papers are also examples of hybrid scheduling problems, where features of more than one problem are combined to model the given problem. A distributed FSSP was tackled by Ruiz et al. [19]. In such a FSSP variant, multiple factories are assumed and jobs have to be assigned to factories in addition to deciding job orders for each factory. The authors proposed an advanced version of a simple non-nature-inspired Iterated Greedy (IG) metaheuristic. The method demonstrated promising results despite the fact that little problem-specific knowledge was built into it. In a paper by Bożejko et al. [20], a Tabu Search (TS) method for a two-machine FSSP with weighted tardiness goal function was proposed. The method employed a variant of the so-called block elimination property in order to accelerate the neighborhood search for the TS method.

2.2. Setups in Scheduling Problems

Due to the real-life need to model retrofitting, cleaning or otherwise preparing the machine between jobs, setups have become a commonly used concept in scheduling, and their importance is emphasized in a review by Allahverdi et al. [21]. Various types of setups exist. Their classification was proposed in several review papers, e.g., on FSSP by Cheng et al. [22] as well as Reza Hejazi and Sghafian [23], a more general Job Shop Scheduling Problem (JSSP) review by Sharma and Jain [24], or lotsizing problems reviewed by Zhu and Wilhelm [25]. We will discuss some of the most common variants below.

The setup time can depend only on the job following the setup on that machine (Sequence-Independent Setup Times, SIST) or on both the next and previous job (Sequence-Dependent Setup Times, SDST). Sequence-independent setups, as less general, were mostly considered in the past. Gupta and Tunc [26] considered flexible FSSP (parallel machines at each stage) with SIST and proposed four simple solving heuristics. Rajendran and Ziegler [27] proposed several heuristics to solve FSSP with SIST. Bożejko et al. [28] considered the FSSP variant with a machine time couplings’ concept, which can be used to model various dependencies between operations starting and completion times, including setup times and their generalizations. In the paper by Belabid et al. [29], permutation FSSP with SIST was solved by MILP and two heuristic based on Johnson’s and NEH algorithms, the iterative local search algorithm and the IG algorithm.

On the other hand, sequence-dependent setups are more commonly researched. One of the first works on FSSP with SDST is the paper by Gupta and Darrow [30], where a 2-machine variant was considered. The authors proved its NP-completeness and proposed some heuristic methods, while also demonstrating that non-permutation approaches are not always optimal. Next, Ruiz and Stützle [31] proposed an IG local search method for both makespan and total weighted tardiness goal functions for FSSP, demonstrating good results. Zandieh and Karimi [32] considered a multi-criteria hybrid FSSP problem with SDST, which they solved using a multi-population GA method. A 2-machine robotic cell was shown in a paper by Fazek Zarandi et al. [33], where the authors considered loading and unloading times, SDST and a total cycle flow time minimization. Similarly, Majumder and Laha [34] proposed a cockoo search solving method for 2-machine robotic cell with SDST. Finally, in a paper by Burcin Ozsoydan and Sağir [35], a case study for hybrid flexible FSSP with SDST was presented. The authors proposed an IG metaheuristics with 4 phases, which includes a descent neighborhood search, a NEH-like starting solution and a destruction mechanism for creating perturbations. The method was then tested against several competitive algorithms with promising results.

It also common to distinguish jobs’ batches, groups or families, which leads to two types of setup times: “small” (between jobs within a job family) and “large” (between jobs from different families). Often “small” setups have a setup time radically different from “large” setups, leading to different dispatching rules or disregarding “small” setups altogether as negligible. In a paper by Cheng et al. [36], a two-machine, flexible FSSP with a single operator was considered, where setups are performed only when the type of operation changes. The authors proposed a heuristic for the problem and analyzed its worst-case performance. A no-wait flowline manufacturing cell scheduling problem with a sequence-dependent family setup times and makespan minimization was tackled in the paper by Lin and Ying [37]. An efficient metaheuristic for solving the problem was proposed and managed to obtain some optimal solutions for the tested instances in a reasonable computational time. Rudy and Smutnicki [12] considered a problem of online scheduling of software tests on parallel machines’ cloud environment. Fixed-time setups occur only when the next operation (test case) comes from a different job (test suite) than the previous one, while also predicting processing times based on system history.

2.3. Disjoint Setups (Single Server)

The literature on scheduling problems with a limited number of simultaneous setups allowed is relatively sparse. Brucker et al. [10] provided some theoretical results for special cases of FSSP with a single-server. In particular, 2-machine, 3-machine and arbitrary number of machines were considered. Specific cases included identical or unit processing and setup times. For 12 cases, the authors proved they are polynomially solvable, while proving or citing NP-hardness for another 9 cases. In a paper by Lim et al. [38], a two-machine FSSP with sequence independent setups and a single server was considered. Authors discussed several special cases (e.g., identical processing times, short operations, etc.), identifying their properties and proposed lower bounds for the problem. A two-machine FSSP with no-wait, separable setups and a single server was considered in paper by Su and Lee [39]. The authors proved the problem can be reduced to a two-machine FSSP with no-wait and setup times if processing times on the first machine are greater than setup times on the second machine. Moreover, several properties were formulated to accelerate the convergence of the proposed methods: dedicated heuristic and Branch and Bound methods. In another paper by Samarghandi [40], the authors analyzed several special cases for the same problem. A hybrid Variable Neighbourhood Search and TS solving methods were proposed for the generic case. Similarly, a single-server 2-machine FSSP was considered in the paper by Cheng and Kovalyov [41]. Machine-dependent setups were assumed, but only when the server switched machines. The authors demonstrated that the problem can be reduced to a single-machine batching problem. For some special cases (minimizing maximum lateness or total completion time) efficient $O(nlogn)$ solving methods were proposed. Several other cases were proved to be NP-hard or strongly NP-hard (with special $O\left(n^3\right)$ and $O\left(n^4\right)$ cases when all operations on the machine have equal processing times). Two pseudopolynomial dynamic programming algorithms were also proposed.

In a paper by Cheng et al. [36], only one of two machines can undergo a setup at the time due to the One-Worker-Multiple-Machine model. The authors considered a cyclic moving pattern of the operator. The worst-case analysis and hard NP-completness proof for the considered FSSP SDST variant were provided. The authors also proposed a few heuristic algorithms. Similarly, Gnatowski et al. [42] considered a FSSP with sequence-dependent disjoint setups, complete with model, several properties and two solving methods: a MILP formulation and a greedy algorithm. The authors restricted themselves to a 2-machine variant only. Bożejko et al. [9,43] tackled FSSP with two-machine robotic cells, where a single robotic arm is used to both perform operations and setups in each cell. It results not only in disjoint setups, but also at most one machine can be active in a cell at any moment. The authors demonstrated, that in a special case, assigning operations and setups to machines can be conducted optimally in polynomial time. However, the paper does not consider more than 2 machines per cell. Moreover, in a paper by Iravani and Teo [44], the server handled both operations and setups, so at most one operation can be processed at a time. The authors demonstrated that for minimization of setup and holding costs, there exists an easily implementable class of asymptotically optimal schedules.

For non-FSSP problems, Vlk et al. [45] considered a Parallel Machines Scheduling Problem variant with disjoint setups and introduced Integer Linear Programming, Constraint Programming and hybrid methods. Okubo and et al. [46] proposed an approach to Resource Constrained Process Scheduling, in which setups require additional resources. This could lead to some setup operations being delayed when said resources are used by another setup. Authors proposed two solving methods, Integer Programming and Constraint Programming formulations, as well as a heuristic mask calculation algorithm for the efficient restriction of modes. Finally, Tempelmeier and Buschkühl [47] considered a “capacitated” lotsizing problem with sequence-dependent setups and a setup operator shared by 5–10 machines. Good results were obtained under a few minutes using a standard CPLEX solver. A parallel identical machines scheduling with sequence-independent setups and a single server was researched in a paper by Glass et al. [48]. Several cases were analyzed and approximate algorithms were proposed.

3. Problem Formulation

In this section, we will formally state the researched problem, and formulate its mathematical model. We will discuss different solution definitions and point to the one that limits the size of a search space.

The problem is based on the classic FSSP with setups. Each job from the set $\mathcal{J}=\{1,2,\cdots ,n\}$ must be processed on each machine from the set $\mathcal{M}=\{1,2,\cdots ,m\}$. We assume that the order of jobs is fixed. The processing of a job $i\in \mathcal{J}$ on a machine $a\in \mathcal{M}$ is called operation and takes $p_i^a>0$ time. Between each two consecutive jobs $i,i+1,i\in \mathcal{J}\backslash \left\{n\right\},$ performed on the same machine $a\in \mathcal{M}$, a setup must be performed. The setup also cannot be interrupted and takes $s_i^a>0$ time. The constraints on the systems can be summarized as follows:

• Each job is processed on each machine in a natural order $1\to 2\to \cdots \to m$.
• Each machine processes jobs in a natural order $1\to 2\to \cdots \to n$.
• Between each two consecutive operations on each machine, there is a setup.
• Operations and setups cannot be interrupted.
• Each machine can process at most one job at any time.
• At most one setup can be performed in the system at any time (the system has single-server or, equivalently, setups are disjoint).

• Thus, at any given time, a machine is in one of three possible states: (1) processing a single operation, (2) undergoing a single setup, or (3) idling. The total number of disjoint setups in the system is $(n-1)m$ (there are $n-1$ setups on each of m machines). To shorten various equations, we also define an auxiliary set as $\mathcal{S}=\{1,2,\cdots ,(n-1\left)m\right\}$, which is used to enumerate data structures and notation related to setups in different contexts later on.

The solution of the problem can be represented by a schedule. A schedule is a set of starting and completion times for all operations and setups. By ${{}^{\pi }S}_i^a$ and ${{}^{\pi }C}_i^a$, $a\in \mathcal{M},i\in \mathcal{J}$, we will denote the starting and completion time of the operation of the job i, being processed on the machine a. Analogously, by ${{}^{\sigma }S}_i^a$ and ${{}^{\sigma }C}_i^a$, $a\in \mathcal{M},i\in \mathcal{J}\backslash \left\{n\right\}$, we will denote the starting and completion time of the setup performed on the machine a, after the job i. With the introduced notation, the problem constraints can be formalized as

$$\begin{array}{cccc}& \forall a\in \mathcal{M}\forall i\in \mathcal{J}\hfill & \hfill {{}^{\pi }C}_i^a& ={{}^{\pi }S}_i^a+p_i^a,\hfill \end{array}$$

(1)

$$\begin{array}{cccc}& \forall a\in \mathcal{M}\forall i\in \mathcal{J}\backslash \left\{n\right\}\hfill & \hfill {{}^{\sigma }C}_i^a& ={{}^{\sigma }S}_i^a+s_i^a,\hfill \end{array}$$

(2)

$$\begin{array}{cccc}& \forall a\in \mathcal{M}\backslash \left\{m\right\}\forall i\in \mathcal{J}\hfill & \hfill {{}^{\pi }C}_i^a& \le {{}^{\pi }S}_i^{a+1},\hfill \end{array}$$

(3)

$$\begin{array}{cccc}& \forall a\in \mathcal{M}\forall i\in \mathcal{J}\backslash \left\{n\right\}\hfill & \hfill {{}^{\sigma }C}_i^a& \le {{}^{\pi }S}_{i+1}^a,\hfill \end{array}$$

(4)

$$\begin{array}{cccc}& \forall a\in \mathcal{M}\forall i\in \mathcal{J}\backslash \left\{n\right\}\hfill & \hfill {{}^{\pi }C}_i^a& \le {{}^{\sigma }S}_i^a,\hfill \end{array}$$

(5)

$$\begin{array}{cccc}& \forall a,b\in \mathcal{M},a\ne b\forall i,j\in \mathcal{J}\backslash \left\{n\right\},i\ne j\hfill & \hfill {{}^{\sigma }C}_i^a\le {{}^{\sigma }S}_j^b& ⊻{{}^{\sigma }C}_j^b\le {{}^{\sigma }S}_i^a,\hfill \end{array}$$

(6)

where “⊻” is an exclusive OR. Constraints (1) and (2) guarantee that operations and setups cannot be interrupted. Constraint (3) represents the sequential processing of a job (technological constraints). Constraints (4) and (5) guarantee that setups and operations performed on the same machine do not overlap and are performed in a predefined order (machine constraints). Finally, Constraint (6) assures that at most one setup can be performed in the system at any time. A schedule is called feasible if it satisfies all the Constraints (1)–(6). The problem is to find such feasible schedule, so that the makespan $C_{\max }={{}^{\pi }C}_n^m-{{}^{\pi }S}_1^1$ is minimal. Without losing generality, we can fix the time the first job starts being processed; thus, we set ${{}^{\pi }S}_1^1$ := 0. This simplifies the computation of the makespan as $C_{\max }={{}^{\pi }C}_n^m$.

A schedule representation of a solution leads to an infinite set of possible solutions. Therefore, usually representing the solution by precedence constraints is better suited for both theoretical analysis and solving algorithms. Even though the order in which the jobs are processed is fixed, the order of the setups is not. Let $\mathit{\tau }\in \mathcal{T}$ describe an order in which setups are performed, where ${\tau }_k$, $k\in \mathcal{S}$, denotes the k-th setup performed in the system and $\mathcal{T}$ is a set of all possible setup orders. Setups are identified by a pair of numbers $(a,i)$, where $a\in \mathcal{M}$ is the machine on which the setup is performed on and $i\in \mathcal{J}\backslash \left\{n\right\}$ is the job the setup is performed on afterwards. The number of all possible setups orders $\left|\mathcal{T}\right|$ is equal to $\left(\right(n-1\left)m\right)!$. We say that an order of setups is feasible if it describes at least one feasible schedule. Since the order of setups on each machine is fixed, each feasible order of setups can be described unambiguously by the order of machines on which setups are performed $\mathit{\sigma }\in \Sigma$, where ${\sigma }_k$, $k\in \mathcal{S}$ is the machine on which the k-th setup is performed. When describing a setup order, we will refer to one of the two representations: $\mathit{\sigma }$ or $\mathit{\tau }$, depending on the context. In order to transform any feasible $\mathit{\tau }\in \mathcal{T}$ into a unique $\mathit{\sigma }\in \Sigma$, one can simply disregard a job number from each pair describing a setup. The reversed procedure is also possible, by assigning consecutive jobs to the setups performed on the same machine (refer to Example 1). Interestingly, sometimes an infeasible $\mathit{\tau }$ can be transformed by this method into a feasible $\mathit{\sigma }$ (as observed in the example). The number of different $\mathit{\sigma }$, denoted $|\Sigma |$, is smaller than $\left|\mathcal{T}\right|$, and equals

$$|\Sigma |=\frac{\left|\mathcal{T}\right|}{(n-1){!}^m}=\frac{\left(\right(n-1\left)m\right)!}{(n-1){!}^m}.$$

(7)

The set of all feasible $\mathit{\sigma }$ is denoted by ${\Sigma }_{\mathrm{feas}}$.

Example 1.

Consider a setup order for instance with $n=4$ and $m=2$:

$${\mathit{\tau }}^1=\left((1,3),(1,2),(1,1),(2,3),(2,2),(2,1)\right).$$

(8)

The setup order ${\mathit{\tau }}^1$ is infeasible, e.g., ${\tau }_1^1=(1,3)$ is scheduled to be the first setup, while operation 1 of job 3 cannot be performed yet, as the setup $(1,2)$ is not completed. Now, consider the setup order ${\mathit{\sigma }}^1=(1,1,1,2,2,2)$, that was built from ${\mathit{\tau }}^1$. This setup order is feasible and can be transformed into a feasible setup order

$${\mathit{\tau }}^2=\left((1,1),(1,2),(1,3),(2,1),(2,2),(2,3)\right).$$

(9)

Now, consider an infeasible setup order

$${\mathit{\tau }}^3=\left((2,1),(2,2),(2,3),(1,1),(1,2),(1,3)\right).$$

(10)

Its corresponding setup order ${\mathit{\sigma }}^2=(2,2,2,1,1,1)$ is also infeasible.

For a given setup order $\mathit{\sigma }$ to become a solution representation, a quick method for transforming a feasible $\mathit{\sigma }\in {\Sigma }_{\mathrm{feas}}$ into a unique feasible schedule is required. We will limit our discussion to left-shifted schedules, that is, the schedules where no setup or operation can be performed earlier, without changing the order of setups. It can be easily demonstrated that each feasible solution $\mathit{\sigma }$ describes exactly one feasible, left-shifted schedule, and each left-shifted schedule is described by exactly one $\mathit{\sigma }$. This schedule can be built similarly to how a schedule is built based on an order of operations in the Job Shop Scheduling Problem (e.g., in a paper by Nowicki and Smutnicki [49]), since Constraints (1)–(6) can also be represented as a sparse, acyclic, weighted graph. Thus, for any $\mathit{\sigma }\in {\Sigma }_{\mathrm{feas}}$, the corresponding schedule can be built in $O\left(nm\right)$ time. We define that the makespan of $\mathit{\sigma }$ is the makespan of the corresponding left-shifted schedule, and denote it by $C_{\max }(\mathit{\sigma })$. Since each optimal schedule can be transformed into a left-shifted one without affecting its makespan, the considered problem can be rewritten into finding an optimal setup order ${\mathit{\sigma }}^{*}$, such that

$$C_{\max }\left({\mathit{\sigma }}^{*}\right)=\underset{\mathit{\sigma }\in {\Sigma }_{\mathrm{feas}}}{min}{C}_{\max }(\mathit{\sigma }).$$

(11)

Hereinafter, unless otherwise stated, we will only use the setup order representation $\mathit{\sigma }\in \Sigma$.

Example 2.

Consider the instance with $n=4$, $m=3$ and processing times and setup times from

Table 2. Problem instance from Example 2 for $n=4$ and $m=3$.

i		${\mathit{p}}_{\mathit{i}}^1$	${\mathit{p}}_{\mathit{i}}^2$	${\mathit{p}}_{\mathit{i}}^3$		${\mathit{s}}_{\mathit{i}}^1$	${\mathit{s}}_{\mathit{i}}^2$	${\mathit{s}}_{\mathit{i}}^3$
1		1	2	1		1	1	1
2		1	2	2		1	1	1
3		1	1	1		1	2	2
4		2	1	1		-	-	-

. The order of setups $\mathit{\sigma }=(1,1,1,2,3,2,3,2,3)$ is feasible for that instance. A left-shifted schedule for solution $\mathit{\sigma }$, with $C_{\max }=17$, is shown as a Gantt chart in Figure 1. Note that $\mathit{\sigma }$ is not an optimal solution. For example, the first setup on machine 2 could be performed earlier (during the third operation on machine 1).

4. Problem Properties

In this section, we will formulate several problem properties, particularly the ones regarding the solution space. We start by demonstrating the solution representation using mathematical concepts of lattice paths. We then discuss the number of feasible solutions and the ways to compute it. We formulate two theorems that can be employed in solving methods: an elimination property for skipping certain solutions and a refinement procedure that can improve solutions. Finally, we discuss what portion of the solution space can be skipped by use of the formulated properties.

4.1. Lattice Path Solution Representation

As it was demonstrated in the previous section, some orders of setups are infeasible. To better illustrate the nuances of the solution feasibility in the researched problem, we will introduce the lattice path representation of a solution.

Formally, a lattice path $L=({\mathit{x}}_0,{\mathit{x}}_1,\cdots ,{\mathit{x}}_k)$ is a sequence of points in ${\mathbb{Z}}^d$, where the difference between any pair of consecutive points ${\mathit{x}}_{i+1}-{\mathit{x}}_i,i\in \{0,\cdots ,k-1\}$, is in a predefined set. Elements of the set are called steps. Here, the set is a standard basis ${\mathcal{E}}_m=\{{\mathit{e}}_1,{\mathit{e}}_2,\cdots ,{\mathit{e}}_m\}$ and $d=m$. One can associate each step ${\mathit{e}}_a$, with an act of a setup being performed on machine a. Consider lattice path L from $(0,0,\cdots ,0)$ to $(n-1,n-1,\cdots ,n-1)$, consisting of $(n-1)m$ steps in ${\mathcal{E}}_m$. Each point in this path ${\mathit{x}}_i=(x_1,x_2,\cdots ,x_m)$ can be interpreted as a state of a production system with $x_a,a\in \mathcal{M}$ setups already performed on machine a. Then, since there are $n-1$ steps to be performed on each machine, each L represents a unique sequence of setups.

Example 3.

Consider a problem size $n=3$, $m=3$ and a setup order $\mathit{\sigma }=(2,1,1,3,3,2)$. The transformation from $\mathit{\sigma }$ to the corresponding L can be performed as follows. Start building the path from $(0,0,0)$ (the number of dimensions $d=m=3$). Then, for each element ${\sigma }_i$ in $\mathit{\sigma }$, build sequentially a new point in L by adding 1 to the coordinate given by value of ${\sigma }_i$ of the previous point. Refer to the equations below:

$$\begin{array}{ccccccccccccccc}\hfill \mathit{\sigma }=(& & \underset{\downarrow }{2},& & \underset{\downarrow }{1},& & \underset{\downarrow }{1},& & \underset{\downarrow }{3},& & \underset{\downarrow }{3},& & \underset{\downarrow }{2}& & )\\ \hfill L=(& (0,0,0),(0,\hfill & 1,& 0),(& 1,& 1,0),(\hfill & 2,& 1,0),(2,1,\hfill & 1& ),(2,1,\hfill & 2& ),(2,& 2,& 2& \left)\right)& .\end{array}$$

(12)

The reasoning can be reversed to calculate the $\mathit{\sigma }$ corresponding to L.

The introduced lattice paths can describe not only feasible setup orders, but also infeasible ones. The problem Constraints (1)–(6) can be directly translated into the domain of lattice paths, by limiting admissible paths to ones consisting of elements in

$${\mathcal{X}}_m=\left\{\mathit{x}\in {\mathbb{Z}}^m|\forall a\in \mathcal{M}\backslash \left\{1\right\}{x}_a\le 1+\underset{1\le j<a}{min}{x}_j\right\}.$$

(13)

The interpretation of Equation (13) is that, at any time, the number setups performed on machine a cannot be greater than the number of setups performed on previous machines $j=1,2,\cdots ,a-1$ plus one. Note that ${\mathcal{X}}_m$ does not put direct constraints on a maximum and a minimum number of setups performed on any machine (i.e., constraint $\forall i\in \mathcal{M}$   $0\le x_i<n$). Such constraints are represented in the set of feasible steps, as well as in the described lattice paths’ start- and endpoints.

4.2. Counting Feasible Solutions

With the lattice path solution representation introduced, one can easily calculate the number of different solutions for a given n and $m=2$. The following Lemma 1 was first demonstrated by Gnatowski et al. [42]. Here, however, we will show a proof that will be derived from the general case described in (13).

Lemma 1

(Number of feasible solutions, $m=2$ [42]). Consider a problem instance with $m=2$ machines and $n>1$ operations. The number of different feasible setup orders is given by the n-th Catalan number

$$\left|{\Sigma }_{\mathrm{feas}}\right|=C_n=\frac{1}{n+1}\left(\genfrac{}{}{0pt}{}{2n}{n}\right)=\frac{\left(2n\right)!}{(n+1)!n!}.$$

(14)

Proof. 

The relation between Catalan numbers and the number of feasible setups can be explained in multiple ways. One can use an analogy to the problem of finding the number of possible legal sequences of parentheses; to several different Dyck words-related problems; or to more or less general lattice paths’ analysis (see, for example, a paper by Stanley [50]). Here, we will explore on the last mentioned possibility, as it also provides some insight into the multi-machine variant of the problem.

For $m=2$, Equation (13) becomes

$${\mathcal{X}}_2=\left\{\mathit{x}\in {\mathbb{Z}}^2|x_2\le 1+x_1\right\}.$$

(15)

Equation (15) limits the admissible lattice paths from $(0,0)$ to $(n-1,n-1)$ in ${\mathbb{Z}}^2$, to the ones weakly below line $x_2=x_1+1$. Such paths will be called $L_2$ paths (as shown in Figure 2).

Consider lattice paths $L_2^{\prime }$ from $(-1,0)$ to $(n-1,n)$, with steps in ${\mathcal{E}}_m$, staying weakly under $x_2=x_1+1$. In any $L_2^{\prime }$, the first and the last step are fixed (bold arrows in Figure 2). Therefore, the number of different $L_2^{\prime }$ paths is equal to the number of different $L_2$ paths. Now, by translating the first axis by 1, the $L_2^{\prime }$ starts in $(0,0)$ and ends in $(n,n)$, staying weakly under $x_2=x_1$. The problem of finding the number of different paths defined as such is well known, and has a solution of $C_n$. For the proof of this fact, as well as other occurrences of Catalan numbers in mathematics, refer to [50].    □

While for $m=2$, the number of different feasible solutions can be computed using (14), the case of $m>2$ is much harder. The reasoning from the proof of Lemma 1 cannot be trivially applied for any $m>2$, even though generalizations for multi-dimensional Catalan numbers exist (see, for example, papers by Haglund [51] or Vera-López et al. [52]).

The constraints on lattice path defined by ${\mathcal{X}}_m$ are relatively complex and—to our knowledge—cannot be addressed by lattice path analysis methods (refer to e.g., a paper by Krattenthaler [53]) to obtain a useful closed-form expression for computing $|{\Sigma }_{\mathrm{feas}}|$. On the other hand, recursive formula can be easily obtained and used as a basis for a Dynamic Programming (DP) algorithm, calculating the number of feasible solutions for any $m>1$.

An outline of the proposed DP method is shown in Algorithm 1. A subproblem given by any $\mathit{x}\in {\mathcal{X}}_m$ is defined as finding a number of different lattice paths from $\mathit{0}$ to $\mathit{x}$, satisfying (13). Observe that it is equal to the number of different paths from $\mathit{0}$ to each point $\mathit{y}\in {\mathcal{X}}_m$, where $\mathit{y}$ is any point in ${\mathcal{X}}_m$ that can be stepped back from $\mathit{x}$ (i.e., $\mathit{x}-\mathit{y}\in {\mathcal{E}}_m$). For example, for $\mathit{x}=(2,3,2)$, admissible $\mathit{y}\in \left\{\right(2,2,2),(2,3,1\left)\right\}$. Different candidates for $\mathit{y}$ are created in line 7, while in line 8, it is determined whether they are in ${\mathcal{X}}_m$. Lastly, a degenerate subproblem $\mathit{x}=\mathit{0}$ has solution of 1, and constitutes a stop criterion for the recurrence (line 3).

Property 1.

Algorithm 1 runs in $O\left(m{n}^m\right)$ time, using $O\left(n^m\right)$ memory.

Proof. 

First, let us count the number of recursive calls of CountSolution. Since the result for each unique $\mathit{x}$ is eventually stored in mem, the number of calls and the memory complexity of mem cannot be greater than a cardinality of

$${\mathcal{X}}_m\cap \{\mathit{x}\in {\mathrm{Z}}^m:\forall a\in \mathcal{M}0\le x_a\le n-1\},$$

(16)

where the latter set reflects origin and destination points for the lattice path L. In another words, mem must be able to store solutions to the subproblems corresponding to each point that can appear in L. A simple upper bound for such is obviously $O\left(n^m\right)$, which is the cardinality of the latter set. This allows mem to be a continuous block of $n^m$ memory registers, since it takes $O\left(n^m\right)$ to initialize them (line 1). The memory block can then be indexed similarily to C++ arrays, i.e., mem($\mathit{x}$) is understood as mem($x^{\mathtt{i}}$), where   

$$x^{\mathtt{i}}:=\sum _{a\in \mathcal{M}}{x}_a·n^{a-1}.$$

(17)

Equation (17) is a simple one-to-one mapping of all possible nodes of the considered lattice paths to numbers $\{0,1,\cdots ,{\sum }_{a\in \mathcal{M}}{n}^{a-1}\}$. The mapping is analogous to a flat array index for multidimensional arrays. The index notation is used to accelerate some computations, taking advantage of an unbounded capacity of a single memory cell (each memory cell of an assumed abstract machine can hold any integer). In a constant time, one can not only access or modify any element of $\mathit{x}$ represented by $x^{\mathtt{i}}$, but also copy $x^{\mathtt{i}}$, which is not possible for $\mathit{x}$ directly.

Algorithm 1: Counting feasible solutions

Data: $\mathit{x}$, a point in ${\mathcal{X}}_m$. Result: $|{\Sigma }_{\mathrm{feas}}|$: number of feasible solutions (paths from $\mathit{0}$ to $\mathit{x}$ in ${\mathcal{X}}_m$).

Next, let us derive the computational complexity of a single CountSolution call. Lines 3–6 can be conducted in $O\left(m\right)$ time. Although the computation of the index $x^{\mathtt{i}}$ of $\mathit{x}$ takes $O\left(m\right)$ time, any change in a constant number of elements in $\mathit{x}$ can be reflected in $x^{\mathtt{i}}$ in constant time. Therefore, lines 9 and 15 take $O\left(1\right)$ time. Line 10 can be conducted in $O\left(1\right)$ time, by using cumulative minimum from line 6. Memory access in lines 11 and 13 can also be conducted in $O\left(1\right)$ time, using precomputed index $x^{\mathtt{i}}$—resulting in an overall time complexity of $O\left(m\right)$. Memory complexity of a single CountSolution run is $O\left(m\right)$.

Overall, the computational complexity of the proposed algorithm is

$$O\left(n^m·m\right)=O\left(m{n}^m\right).$$

(18)

The memory complexity is

$$O(max\{n^m,m\})=O\left(n^m\right).$$

(19)

□

A tighter bound can probably be demonstrated for the cardinality of (16) (by a factor of $\frac{1}{m!}$). Then, however, one could not use a simple index $x^{\mathtt{i}}$ to access memory, leading to a potentially worse computational complexity.

Because of the time and memory complexities, Algorithm 1 performs best when $n\gg m$. Such an assumption is usually realistic. Even then, the algorithm can only be used to compute $|{\Sigma }_{\mathrm{feas}}|$ for small and medium instances.

Table 3. Relation between the number of feasible setup orders and the total number of setup orders.

		$\mathit{m}=2$			$\mathit{m}=3$
n		$|{\Sigma }_{\mathrm{feas}}|$	$|\Sigma |$		$|{\Sigma }_{\mathrm{feas}}|$	$|\Sigma |$
2		2.00	2.00		6.00	6.00
5		4.20 × 101	7.00 × 101		9.48 × 103	3.46 × 104
10		1.68 × 104	4.86 × 104		1.42 × 1010	2.28 × 1011
20		6.56 × 109	3.53 × 1010		2.46 × 1023	2.25 × 1025
50		1.98 × 1027	2.55 × 1028		6.62 × 1064	7.67 × 1067
100		8.97 × 1056	2.28 × 1058		1.63 × 10135	1.41 × 10139
200		5.12 × 10116	2.58 × 10118		1.44 × 10277	9.60 × 10281
500		5.39 × 10296	6.76 × 10298		9.65 × 10704	9.83 × 10710
1000		2.05 × 10597	5.12 × 10599
		$m=4$			$m=5$
n		$|{\Sigma }_{\mathrm{feas}}|$	$|\Sigma |$		$|{\Sigma }_{\mathrm{feas}}|$	$|\Sigma |$
2		2.40 × 101	2.40 × 101		1.20 × 102	1.20 × 102
5		6.56 × 106	6.31 × 107		1.06 × 1010	3.06 × 1011
10		1.52 × 1017	2.15 × 1019		1.08 × 1025	1.90 × 1028
20		2.28 × 1039	8.61 × 1042		1.22 × 1057	3.88 × 1062
50		7.13 × 10108	3.71 × 10114		4.46 × 10157	4.14 × 10166
100		1.22 × 10227	3.35 × 10234
200		4.95 × 10465	7.84 × 10474

summarizes the differences between $|{\Sigma }_{\mathrm{feas}}|$ and $|\Sigma |$ for several n and m combinations. In particular, for $m=2$, the $|\Sigma |/|{\Sigma }_{\mathrm{feas}}|$ can be calculated directly

$$\begin{array}{cc}\hfill \frac{|\Sigma |}{|{\Sigma }_{\mathrm{feas}}|}& =\frac{\left(2\right(n-1\left)\right)!}{(n-1){!}^2}·\frac{(n+1)!n!}{\left(2n\right)!}\hfill \\ \hfill & =\frac{(2n-2)!}{(n-1){!}^2}·\frac{(n-1)!n(n+1)(n-1)!n}{(2n-2)!(2n-1)2n}\hfill \\ \hfill & =\frac{(n+1)n}{2(2n-1)}\in O\left(n\right).\hfill \end{array}$$

(20)

Clearly, the number of feasible solutions is significantly smaller than the total number of solutions.

4.3. Elimination Property

In this section, we will discuss the elimination property, which can be used for a quick detection of suboptimal solutions or to potentially improve a solution (as shown in Section 4.4). The property relates to the consecutive setups performed after the same job—constituting a block.

Definition 1.

For solution $\mathit{\sigma }$, let ${\mathit{x}}^{\mathit{k}}=(x_1^k,x_2^k,\cdots ,x_m^k)$ be a k-th node of the lattice path corresponding to $\mathit{\sigma }$, i.e., $x_a^k$ denotes how many setups were performed on machine a after setup ${\sigma }_k$ was completed. Let $\mathit{\delta }$ be an h-element subsequence of subseqeuent setups from $\mathit{\sigma }$ starting at element k. Subsequence $\mathit{\delta }$ will be called a block of setups in solution $\mathit{\sigma }$ (in short, a block) if and only if:

1. 

All setups in $\mathit{\delta }$ are performed on a different machine:

$$\forall u,v\in \{1,2,\cdots ,h\},v\ne u{\delta }_u\ne {\delta }_v.$$

(21)

2. 

All setups in $\mathit{\delta }$ are performed after the same job:

$$\exists i\in \mathcal{J}\forall u\in \mathit{\delta }{x}_k^u=i.$$

(22)

3. 

The length h of the block $\mathit{\delta }$ is maximal i.e., $\mathit{\delta }$ of length $h+1$ starting at k is not a block.

4. 

Blocks partition the sequence $\mathit{\sigma }$, i.e., each element ${\sigma }_k$ belongs to exactly one block.

We will illustrate the above definitions with an example.

Example 4.

Consider the following solution:

$$\sigma =(3,2,1,1,4,2,4,1,3,3,2,4).$$

We start with lattice path node $\mathit{x}=(0,0,0,0)$. We then perform ${\mathit{\delta }}_1=(3,2,1)$. All setups are on different machines and after the same job ($i=0)$, thus ${\mathit{\delta }}_1$ is the first block. Note that we cannot define the first block as $(3,2,1,1)$, because setups are not on different machines. We are now on lattice node $\mathit{x}=(1,1,1,0)$. The next block cannot be ${\mathit{\delta }}_2=(1,4)$, because $x_1\ne x_4$. Thus, ${\mathit{\delta }}_2=\left(1\right)$, leading to $\mathit{x}=(2,1,1,0)$. Similarly ${\mathit{\delta }}_3=\left(4\right)$ and not $(4,2)$ because $x_4\ne x_2$. This leads to node $\mathit{x}=(2,1,1,1)$. Next, the block cannot be $(2,4,1)$ because $x_2\ne x_1$, but it can be $(2,4)$, leading to node $\mathit{x}=(2,2,1,2)$. Next, we cannot have a block $(1,3,3)$ (machines are not different) or $(1,3)$ ($x_1\ne x_3)$; thus, the next two blocks will be ${\mathit{\delta }}_5=\left(1\right)$ and ${\mathit{\delta }}_6=\left(3\right)$ leading to nodes $\mathit{x}=(3,2,1,2)$ and then $(3,2,2,2)$. Finally, we have ${\mathit{\delta }}_7=(3,2,4)$, as all elements are different and $x_3=x_2=x_4$, leading to $\mathit{x}=(3,3,3,3)$. Thus, solution $\mathit{\sigma }$ contains seven blocks, as marked by the brackets below.

$$\begin{array}{cccccccc}\mathit{\sigma }=\hfill & (3,2,1,\hfill & 1,\hfill & 4,\hfill & 2,4,\hfill & 1,\hfill & 3,\hfill & 3,2,4).\hfill \\ \hfill & 1^{\prime }\hfill & 1^{\prime }\hfill & 1^{\prime }\hfill & 1^{\prime }\hfill & 1^{\prime }\hfill & 1^{\prime }\hfill & 1^{\prime }\hfill \end{array}$$

With the blocks defined, the elimination property can be formulated. The property is a generalization of the result presented by Gnatowski et al. [42], for any $m>1$.

Theorem 1

(Elimination property). Let $\mathit{\sigma }\in {\Sigma }_{\mathrm{feas}}$ be a feasible solution, with two consecutive setups ${\sigma }_k=b$, ${\sigma }_{k+1}=a$, in a block of job $j\in \mathcal{J}\backslash \left\{n\right\}$; such that $a<b$. Then, a solution $\widehat{\mathit{\sigma }}$, where the order of the setups is reversed,

$$\forall i\in \mathit{S}{\widehat{\sigma }}_i=\left\{\begin{array}{cc}a\hfill & \mathit{for}i=k,\hfill \\ b\hfill & \mathit{for}i=k+1,\hfill \\ {\sigma }_i\hfill & \mathit{otherwise},\hfill \end{array}\right.$$

(23)

is feasible and $C_{\max }\left(\widehat{\mathit{\sigma }}\right)\le C_{\max }(\mathit{\sigma })$.

Proof. 

The proof is based on an analysis of left-shifted schedules build from both $\mathit{\sigma }$ and $\widehat{\mathit{\sigma }}$. The elements of the schedule build from $\widehat{\mathit{\sigma }}$ are denoted with hats (${}^{\sigma }\phantom{C}\widehat{C}$, ${}^{\pi }\phantom{C}\widehat{C}$, etc.). Moreover, let $\gamma$ denote the completion time of setup ${\sigma }_{k-1}$, which is unaffected by the swap. The notation is presented in Figure 3.

First, let us identify elements of schedule not affected by the change in the order of setups. Since k-th setup in the original solution is performed on machine b, then by the time the setup can start, the first b operations of job j must be already performed before the setup is started (marked in bold in the figure). Therefore, ${{}^{\pi }C}_j^a$ and ${{}^{\pi }C}_j^b$ remain constant for both setup orders. As a result, the completion time of setups in $\widehat{\mathit{\sigma }}$ performed after job j on machines $\{1,2,\cdots ,b\}\backslash \{a,b\}$, can only be affected by a change in completion time of $k+1$-th setup. The change can be expressed as ${{}^{\sigma }C}_j^a-{}^{\sigma }\phantom{C}{\widehat{C}}_j^b$, where

$$\begin{array}{cc}\hfill {{}^{\sigma }C}_j^a& =s_j^a+max\{s_j^b+max\{\gamma ,{{}^{\pi }C}_j^b\},{{}^{\pi }C}_j^a\}\hfill \\ \hfill & =s_j^a+s_j^b+max\{\gamma ,{{}^{\pi }C}_j^b\},\hfill \end{array}$$

(24)

$$\begin{array}{cc}\hfill {}^{\sigma }\phantom{C}{\widehat{C}}_j^b& =s_j^b+max\{s_j^a+\gamma ,s_j^a+{{}^{\pi }C}_j^a,{{}^{\pi }C}_j^b\}\hfill \\ \hfill & =s_j^b+s_j^a+max\{\gamma ,{{}^{\pi }C}_j^a,{{}^{\pi }C}_j^b-s_j^a\}.\hfill \end{array}$$

(25)

Then,

$$\begin{array}{c}\hfill {{}^{\sigma }C}_j^a-{}^{\sigma }\phantom{C}{\widehat{C}}_j^b=max\{\gamma ,{{}^{\pi }C}_j^b\}-max\{\gamma ,{{}^{\pi }C}_j^a,{{}^{\pi }C}_j^b-s_j^a\}.\end{array}$$

(26)

Since ${{}^{\pi }C}_j^a<{{}^{\pi }C}_j^b$, we have ${{}^{\sigma }C}_j^a-{}^{\sigma }\phantom{C}{\widehat{C}}_j^b\ge 0$ and the completion time of $k+1$-th setup cannot increase in $\widehat{\mathit{\sigma }}$. As a result, the operations in job $j+1$ preceding operations on machines a and b cannot be delayed, thus ${}^{\pi }\phantom{C}{\widehat{C}}_{j+1}^{a-1}\le {{}^{\pi }C}_{j+1}^{a-1}$ and ${}^{\pi }\phantom{C}{\widehat{C}}_{j+1}^{b-1}\le {{}^{\sigma }C}_{j+1}^{b-1}$. Therefore, if also operations in job $j+1$ performed on machines a and b can only start earlier, then makespan also can only decrease. We check that further.

Let us discuss the change in completion time of job $j+1$ on machine a,

$$\begin{array}{cc}\hfill {{}^{\pi }C}_{j+1}^a-{}^{\pi }\phantom{C}{\widehat{C}}_{j+1}^a& =max\left\{s_j^a+s_j^b+max\{\gamma ,{{}^{\pi }C}_j^b\},{{}^{\pi }C}_{j+1}^{a-1}\right\}\hfill \\ \hfill & -max\left\{s_j^a+max\{\gamma ,{{}^{\pi }C}_j^a\},{}^{\pi }\phantom{C}{\widehat{C}}_{j+1}^{a-1}\right\}.\hfill \end{array}$$

(27)

Knowing, that ${{}^{\pi }C}_{j+1}^{a-1}\ge {}^{\pi }\phantom{C}{\widehat{C}}_{j+1}^{a-1}$, we only need to calculate

$$\begin{array}{cc}{s}_j^a+s_j^b+max\{\gamma ,{{}^{\pi }C}_j^b\}-\left(s_j^a+max\{\gamma ,{{}^{\pi }C}_j^a\}\right)\hfill & \\ & =s_j^b+max\{\gamma ,{{}^{\pi }C}_j^b\}-max\{\gamma ,{{}^{\pi }C}_j^a\}.\hfill \end{array}$$

(28)

Since ${{}^{\pi }C}_j^b>{{}^{\pi }C}_j^a$, then the value of (28) is non-negative and therefore ${{}^{\pi }C}_{j+1}^a-{}^{\pi }\phantom{C}{\widehat{C}}_{j+1}^a\ge 0$ and ${{}^{\pi }C}_{j+1}^a\ge {}^{\pi }\phantom{C}{\widehat{C}}_{j+1}^a$.

Next, let us discuss the change in completion time of job $j+1$ on machine b. Since ${{}^{\sigma }C}_j^b<{{}^{\sigma }C}_j^a<{{}^{\pi }C}_{j+1}^a<{{}^{\pi }C}_{j+1}^{b-1}$, we have

$$\begin{array}{c}\hfill {{}^{\pi }C}_{j+1}^b=p_{j+1}^b+max\left\{{{}^{\sigma }C}_j^b,{{}^{\pi }C}_{j+1}^{b-1}\right\}=p_{j+1}^b+{{}^{\pi }C}_{j+1}^{b-1},\end{array}$$

(29)

$$\begin{array}{c}\hfill {}^{\pi }\phantom{C}{\widehat{C}}_{j+1}^b=p_{j+1}^b+max\left\{{}^{\sigma }\phantom{C}{\widehat{C}}_j^b,{}^{\pi }\phantom{C}{\widehat{C}}_{j+1}^{b-1}\right\}.\end{array}$$

(30)

Since we know that ${{}^{\pi }C}_{j+1}^{b-1}\ge {}^{\pi }\phantom{C}{\widehat{C}}_{j+1}^{b-1}$ and ${{}^{\pi }C}_{j+1}^{b-1}>{{}^{\sigma }C}_j^a\ge {}^{\sigma }\phantom{C}{\widehat{C}}_j^b$, then also ${{}^{\pi }C}_{j+1}^b\ge {}^{\pi }\phantom{C}{\widehat{C}}_{j+1}^b$.

To sum up, it was proven that in the left-shifted schedule build for $\widehat{\mathit{\sigma }}$, completion time of jobs $1,2,\cdots ,j+1$ on machines $1,2,\cdots ,b$ can only decrease compared to the schedule build for $\mathit{\sigma }$. The same can be said about completion time of $k+1$-th setup. Therefore, all further jobs and setups can only be performed earlier, resulting in $C_{\max }\left(\widehat{\mathit{\sigma }}\right)\le C_{\max }(\mathit{\sigma })$.    □

Theorem 1 allows to detect potentially suboptimal solutions. Since the described $\mathit{\sigma }\to {\mathit{\sigma }}^{\prime }$ transformation cannot lead to an increase in makespan, any $\mathit{\sigma }\in {\Sigma }_{\mathrm{feas}}$ that fulfills conditions of Theorem 1 (i.e., satisfies the elimination property) can be safely eliminated from the solution space, without the risk of removing all optimal solutions.

4.4. Refinement Procedure

Theorem 1 provides tools for reducing the size of the solution space. However, it can also be observed as a way to potentially improve a solution, by applying a swap move on the setups satisfying the elimination property. A single solution can contain multiple such setup pairs. Moreover, the swap can create a new pair of setups satisfying the elimination property, as shown in Example 5.

Example 5.

Consider a problem size of $m=3$ and $n=2$. Solution $\mathit{\sigma }=(3,2,1)$ is feasible; however, two setup pairs: $(3,2)$ and $(2,1)$, satisfy elimination property. By applying the swap move to the first pair, we obtain solution ${\mathit{\sigma }}^{\prime }=(2,3,1)$—now containing a single, new pair $(3,1)$ satisfying the property. By applying the swap move, we obtain ${\mathit{\sigma }}^{″}=(2,1,3)$. Once again, the solution contains a pair $\mathit{\sigma }$, $(2,1)$. Finally, the swap move can be applied a third time to obtain ${\mathit{\sigma }}^{‴}=(1,2,3)$. The setup order ${\mathit{\sigma }}^{‴}$ does not satisfy the condition from Theorem 1 and cannot be eliminated. The procedure can be summarized as follows:

$$\begin{array}{c}\mathit{\sigma }\\ \left(\begin{array}{c}3,\underset{⏝}{2,1}\\ ⏝ \hfill \end{array}\right)\end{array}\underset{(3,2)}{\overset{\mathrm{swap}}{\to }}\begin{array}{c}{\mathit{\sigma }}^{\prime }\\ (2,\underset{⏝}{3,1})\end{array}\underset{(3,1)}{\overset{\mathrm{swap}}{\to }}\begin{array}{c}{\mathit{\sigma }}^{″}\\ (\underset{⏝}{2,1},3)\end{array}\underset{(2,1)}{\overset{\mathrm{swap}}{\to }}\begin{array}{c}{\mathit{\sigma }}^{‴}\\ (1,2,3)\end{array}.$$

The observation above is a basis of a refinement procedure. Given a solution $\mathit{\sigma }$, the procedure performs setup swaps until Theorem 1 cannot be applied anymore. The resulting solution ${\mathit{\sigma }}_{\mathit{N}}$ is said to be refined and

$$C_{\max }\left({\mathit{\sigma }}_{\mathit{N}}\right)\le C_{\max }(\mathit{\sigma }).$$

(31)

Of course, there exist solutions that do not contain any setup pairs satisfying the elimination property. In such a case, no swaps are performed. In Example 5, the solution $(1,2,3)$ is the result of refining the solution $(3,2,1)$.

A few questions arise with regards to the refinement procedure, namely, how to detect which swaps should be performed and in what order. Moreover, we would like to know how fast could this procedure be performed. We will answer those questions in the following theorem, using the fact that the procedure resembles the bubble sort algorithm.

Theorem 2

(Block property). For any feasible solution σ, the refinement procedure can be completed in $O\left(nm\right)$ time.

Proof. 

First, observe that rearranging setups within a single block does not change the total number of blocks or contents of other blocks. Therefore, the refinement can be applied for each block separately. Consider a block with a length of l. There is only a single order of setups, for which no pair of setups in the block satisfy the elimination theorem—setups ordered increasingly by the machine on which they are performed. The block can be sorted by applying at most $O\left(l^2\right)$ swap-moves, chosen according to the elimination theorem (refer to bubble sort results by Cormen et al. [54] (p. 40)). As a result, the worst case time complexity of the procedure would be $O\left(n{m}^2\right)$. However, the sorting can be performed quicker in $O\left(nm\right)$ by using Algorithm 2, which sorts all blocks simultaneously. □

Algorithm 2: Refinement procedure

Data: ${\sigma }$: solution to be refined. Result: ${{\sigma }}^{{\prime }}$: refined solution.

The refinement procedure can be utilized to potentially improve the quality of solutions as a part of larger solving algorithm (e.g., similarly to the individual learning procedure in memetic algorithms proposed by Moscato [55]). The computational complexity of $O\left(nm\right)$ is equal to the complexity of calculating the objective function; thus, the refinement procedure can be used frequently.

4.5. Counting Eliminated Solutions

In order to estimate how much of the solution space can be eliminated, we first discuss the number of setup orders that cannot be eliminated (preserved solutions). For $m=2$, the number is given by a known, closed-form expression, first proposed in the lemma by Gnatowski et al. [42] (without a proof). Here, we present a proof for the lemma.

Lemma 2

(Number of preserved solutions $m=2$ [42]). Consider a problem size $m=2$, $n>1$. The number of feasible solutions not eliminated by Theorem 1 is given by the $n-1$-nth Catalan number

$$C_{n-1}=\frac{1}{n}\left(\genfrac{}{}{0pt}{}{2n-2}{n-1}\right)=\frac{(2n-2)!}{n!(n-1)!}.$$

(32)

Proof. 

For the elimination property to be applied, two consecutive setups must be performed after the same job, but on different machines. For $m=2$, it means that the first setup must be performed on machine 2, and the second on machine 1. For that to be possible, all the setups between previous jobs must already be performed. Such a condition corresponds in the domain of lattice paths to the points on $x_1=x_2$ line. Then, step $(0,1)$ (setup performed on machine 2, against elimination property) moves the lattice path above $x_1=x_2$, and step $(1,0)$ keeps the lattice path below $x_1=x_2$. Therefore, the elimination property limits the admissible lattice paths from $(0,0)$ to $(n-1,n-1)$, to stay weakly below the $x_1=x_2$ line. The number of such paths is given by $C_{n-1}$.    □

The Lemma 2 allows one to easily obtain the number of preserved solutions for $m=2$, and thus the number of eliminated solutions.

Theorem 3

(Eliminated solutions for $m=2$ [42]). Consider a problem size $m=2$, $n>1$. Theorem 1 eliminates 50% to 75% of feasible solutions.

• The proof will be omitted, as it was demonstrated in [42].

Since even for calculating $|{\Sigma }_{\mathrm{feas}}|$ and $m>2$, a closed-form expression is not known; to compute the number of preserved solutions, we will resort to the DP approach again. Algorithm 1 must be modified to check both the elimination property condition and the feasibility. For the modified procedure, refer to Algorithm 3.

Algorithm 3: Counting preserved solutions

Data:$\mathit{x}$: potin in ${\mathcal{X}}_{\mathcal{m}}$. Result:$\left|{\sum }_{\ast }\right|$: number of unique preserved solutions.

To allow for checking the elimination property, the machine on which the last setup was performed must be added to the definition of a subproblem. For example, for $n>3$ and $\mathit{x}=(2,2,2)$, the last setup could be performed on any of the three machines (1, 2 or 3). In the Algorithm 3, the machine the last setup was performed on is stored in $l_m$.

Property 2.

Algorithm 3 runs in $O\left(m^2{n}^m\right)$ time, using $O\left(m{n}^m\right)$ memory.

Proof. 

The proof is similar to the proof of Property 1. However, now the number of subproblems is m times larger, since each $\mathit{x}\in {\mathcal{X}}_m$ can be potentially matched with any $l_m\in \mathcal{M}$. It results with both computational and memory complexities greater by a factor of m.    □

The Algorithm 3 was used to compute the number of unique preserved solutions, denoted by $|{\Sigma }_{*}|$, for $m\in \{1,2,\cdots ,8\}$ and $n\in \{2,3,\cdots ,10\}$. Then, an elimination ratio

$$\mathit{ER}=\frac{|{\Sigma }_{\mathrm{feas}}|}{|{\Sigma }_{*}|},$$

(33)

was calculated. The results are demonstrated in Figure 4. For $n=2$, only a single setup order is preserved, resulting in high elimination ratios that can be calculated from Equation (14). For $n>2$, $\mathit{ER}$ increases with the increase of n, eventually overtaking the value for $n=2$. For instances with a larger number of machines, the elimination ratio continues to increase steadily, reaching almost ${10}^5$ for $m=8$.

5. Solving Algorithms

In this section, three solving algorithms will be described: a MILP-based method, a simple greedy heuristic and a Tabu Search metaheuristic algorithm. The first algorithm will be used later on as a reference to assess the heuristics. Both can also be a part of a two-level algorithm, solving the extended problem for varying the job order.

5.1. Greedy Heuristic

The greedy algorithm was inspired by the NEH algorithm proposed in the paper by Nawaz et al. [56] for the FSSP problem. In this case, however, the result of the algorithm is the order of setups $\mathit{\sigma }$ for a fixed order of jobs. The method is based on the step-by-step building of a partial solution. First, we set the completion times for the all operations of the first job, as those require no setups. Then, we perform the first setup on the first machine (${\sigma }_1=1$) and the operation after it, while also calculating their completion times. Then, we proceed to insert the remaining elements into $\sigma$, as follows.

Each time, we choose the value of ${\sigma }_k$ by considering all values $a\in \mathcal{M}$ that are feasible (given partial setup order up to ${\sigma }_{k-1}$). For each such candidate of value a, we compute the completion time of the corresponding setup. In order to do this, we store the completion time of the last setup in ${\sigma }_{k-1}$ throughout the algorithm. For each calculated setup, we then calculate the completion time of the operation after it. Then, as ${\sigma }_k$, we choose such value a, for which the computed operation completion time is smallest. The computational complexity of the algorithm depends on the number of setups and machines, and is given by $O\left(m\right|\mathcal{S}\left|\right)=O\left(n{m}^2\right)$.

Example 6.

Consider the instance from Table 2. For this instance, the greedy solution is constructed as follows. In the first step, we determine the completion time of all three operations of the first job, since they can be processed without any prior setups:

$$\begin{array}{cccc}{{}^{\pi }C}_1^1=1,\hfill & & & \end{array}$$

(34)

$$\begin{array}{cc}\hfill & {{}^{\pi }C}_2^1={{}^{\pi }C}_1^1+2=3,\hfill \end{array}$$

(35)

$$\begin{array}{cc}\hfill & {{}^{\pi }C}_3^1={{}^{\pi }C}_2^1+1=4.\hfill \end{array}$$

(36)

The first setup ${\sigma }_1$ in the greedy heuristic is always performed after the first operation on the first machine. We perform this setup, which allows us to perform the second operation on the first machine, and we calculate the appropriate completion times:

$$\begin{array}{cccc}{\sigma }_1=1\hfill & & & \end{array}$$

(37)

$$\begin{array}{cc}\hfill & {{}^{\sigma }C}_1^1={{}^{\pi }C}_1^1+1=2,\hfill \end{array}$$

(38)

$$\begin{array}{cc}\hfill & {{}^{\pi }C}_1^2={{}^{\sigma }C}_1^1+1=3.\hfill \end{array}$$

(39)

The next setup ${\sigma }_2$ can be performed on any machine; thus, we have three candidates, $a\in \{1,2,3\}$. For each candidate, we evaluate the resulting completion times:

$$\begin{array}{cc}\hfill & {{{}^{\pi }C}^{\prime }}_3^1=max\{{{}^{\pi }C}_3^1,{{}^{\sigma }C}_1^1\}+1+1=5,\hfill \end{array}$$

(40)

$$\begin{array}{cc}\hfill & {{{}^{\pi }C}^{\prime }}_2^2=max\{{{}^{\pi }C}_1^2,{{}^{\sigma }C}_1^1\}+1+2=6,\hfill \end{array}$$

(41)

$$\begin{array}{cc}\hfill & {{{}^{\pi }C}^{\prime }}_2^3=max\{{{}^{\pi }C}_1^3,{{}^{\sigma }C}_1^1\}+1+2=7.\hfill \end{array}$$

(42)

Out of those three possibilities, the minimal value is ${{}^{\pi }C}_3^{\prime 1}$, so ${\sigma }_2=1$, ${{}^{\sigma }C}_2^1=4$ and ${{}^{\pi }C}_2^1={{}^{\pi }C}_2^{\prime 1}$. We repeat this procedure for subsequent decisions ${\sigma }_3$ through ${\sigma }_9$. Finally, we obtain solution $\sigma =(1,1,2,1,2,3,2,3,3)$, shown as a Gantt chart in Figure 5, for which $C_{\max }=16$.

5.2. MILP Formulation

Mixed-Integer Linear Programming formulation is a popular method for solving optimization problems, especially if a dedicated algorithm does not exist. The MILP formulation used in this paper as a reference algorithm was introduced first in [42]. Although the aforementioned paper considers a two-machine problem, the formulation can be used for any $m>1$. It utilizes a relative order to encode setups’ order $\mathit{\sigma }$, resulting in $m(n-1)·(m-1)(n-1)$ binary variables (relative order of setups performed on the same machine is fixed). We improved the method by utilizing the warm start and providing the solver with upper and lower bounds on the objective function of an optimal solution.

5.2.1. Warm Start

To improve the performance of the algorithm, we used a feasible solution as a starting point. It is especially important for the large instance (with $m>3$), where without providing a feasible initial solution, the solver struggled to find any feasible solution at all within a time limit. The starting solution was chosen as a better one from the following two:

• Natural setup order

  $$\left(\underset{n-1\mathrm{times}}{\underbrace{1,2,\cdots ,m,1,2,\cdots ,m,1,2,\cdots ,m,\cdots }}\right).$$

  (43)
• Result of a greedy heuristic from Section 5.1.

5.2.2. Objective Function Bounds

The upper bound of the objective function was assigned based on the initial solution from the warm start. The lower bound was calculated from the expression

$$LB=\sum _{i=1}^{n-1}\left(p_i^1+s_i^1\right)+\sum _{i=1}^m{p}_n^i.$$

(44)

5.3. Tabu Metaheuristic

Tabu Search (TS), is a well-known local search metaheuristic proposed by Glover [57,58], which uses a short- and (optionally) a long-term memory to avoid being trapped in a local optimum. Due to its deterministic nature and good performance in practice, it is one of the most commonly used metaheuristic methods, with applications ranging from scheduling (Bożejko et al. [9]), through knapsack problem (Lai et al. [59]), model selection (Marcoulides [60]), or even data replication in cloud environments (Ebadi and Jafari Navimipour [61]). A general pseudocode of our TS is shown in Algorithm 4. Below, we will describe the most important features of our implementation.

Algorithm 4: Tabu Search pseudocode

Data:$\mathit{\sigma }$: initial solution. Result:${\mathit{\sigma }}^{\mathit{\ast }}$: best solution found.

5.3.1. Initial Solution and Stopping Condition

The initial solution was the same as for the MILP (best out of “natural” and “greedy” constructive heuristics). The choice of the initial solution is not very impactful, TS can generally provide similar results starting from the worse initial solution, provided the number of iterations is a bit higher. The algorithm stops when the time limit MaxTime is reached.

5.3.2. Neighbourhoods

The neighborhood a of solution $\mathit{\sigma }$ is defined as the set of solutions that can be created from $\mathit{\sigma }$ by applying a pre-defined move. In our implementation, we considered the insert move $ins(a,b)$. When this move is applied on $\mathit{\sigma }$, it creates neighboring solution ${\mathit{\sigma }}^{\prime }$ by removing from it element ${\sigma }_a$ and inserting it before element ${\sigma }_b$. For example, performing move $ins(3,6)$ on the solution from Example 2 would result in:

$${\mathit{\sigma }}^{\prime }=(1,1,2,2,3,1,3,2,3).$$

(45)

Normally, the insert neighborhood contains $O\left(n^2{m}^2\right)$ solutions. However, we apply several rejection rules, which may limit the neighborhood size we need to evaluate:

• We ignore moves where $a=b$, as those moves do not change $\mathit{\sigma }$.
• We ignore moves where $|b-a|>\mathtt{W}$, where $\mathtt{W}\in \mathcal{S}$ is an algorithm parameter that defines the width of the neighborhood. We include this parameter, because the full neighborhood search is very costly (i.e., $O\left(n^3{m}^3\right)$).
• We reject insert moves that results in infeasible solutions and (optionally) satisfy elimination property and can be eliminated. This operation is faster than evaluating the objective function, and can be potentially conducted in constant time, assuming that the lattice path corresponding to the initial solution is known.

The move leading to the solution with the lowest makespan is chosen (unless it is forbidden, see the next paragraph for details). Optionally, the solution is then refined by the procedure, as described previously in Section 4.4.

5.3.3. Tabu List

We employed a short-term tabu list memory that stores forbidden moves. Solutions created by such moves are ignored unless they are better than the current value of ${\mathit{\sigma }}^{*}$. The tabu list was implemented as a matrix T of size ${\left(nm\right)}^2$, enabling all tabu list operations in time $O\left(1\right)$. The algorithm parameter $\mathtt{C}$, called cadence, determines for how many iterations the moves stay forbidden. Based on preliminary research, we chose $\mathtt{C}=\lfloor \sqrt{nm}\rfloor$. Note that when move $ins(k,l)$ is performed, the reverse move $ins(l,k)$ also becomes forbidden.

5.3.4. Backjumps

Even with the tabu list mechanism in place, the algorithm can still enter a cycle. To alleviate this problem, we used a long-term memory in the form of a list. Every time ${\mathit{\sigma }}^{*}$ is updated, we add to the list a triple of: (1) a copy of current solution $\mathit{\sigma }$, (2) a copy of the current tabu list; and (3) the move that led to ${\mathit{\sigma }}^{*}$ (not its reverse). If we reach MaxNoImprove iterations without improving ${\mathit{\sigma }}^{*}$, then we perform a backjump. This is conducted by replacing the $\mathit{\sigma }$ and tabu list with their copies in the most recent element of the long-term memory list. Algorithm then proceeds normally, except that during the next iteration, we cannot choose the move that was saved in the memory (this prevents TS from following the same branch). After each backjump, we remove the last element of the long-term memory list. If MaxNoImprove is reached and the list is empty, then instead of performing a backjump, we simply restart the search process by setting $\mathit{\sigma }$ to a random, feasible solution. Based on preliminary research, we chose $\mathtt{MaxNoImprove}=200$.

6. Experimental Results

In this section, we describe the computer experiments on the effectiveness of the proposed solving methods on different instance types.

6.1. Experimental Setup

We conducted tests on the following three algorithms described earlier:

MILP 

a commercial solver using the MILP formulation of the problem from Section 5.2;

TabuA 

TS method from Section 5.3, that does not use elimination property to reject neighbors, but uses refinement procedure to improve the best neighbor;

TabuB 

TS method from Section 5.3, that uses elimination property to reject neighbors.

The TabuA and TabuB algorithms were written in C++ programming language and compiled using g++ version 9.3.0 (with -O3 compilation flag). The MILP formulation was written in Julia programming language version 1.5.3 and employed the Gurobi solver version 9.1.1.rc0 with the default parameters and presolver turned on.

The experiments were run on a machine with 64-core AMD Ryzen Threadripper 3990X processor with 2.9 GHz clock and 64 GB of RAM. Each algorithm used only one CPU core. The experiment was run under a Windows 10 Pro operating system with Windows Subsystem for Linux.

6.1.1. Test Instances

We prepared 120 test instances by the use of a modified version of the FSSP instance generator proposed by Taillard [62]. We use the same random number generator as Taillard, which is meant to provide integer numbers from uniform distribution $\mathcal{U}(1,99)$. Both operation processing times and setup times were drawn from this distribution. We first generated $nm$ processing times, identical to Taillard. Then, we generated—without reseeding the random generator—all $n^{2}m$ setup times, starting with the first machine. We generated setup times for each possible job pair; however, only a single pair is used, as the order of jobs is fixed. We generated 10 instances for each of the following size groups ($n\times m$): $5\times 2$, $10\times 2$, $10\times 3$, $15\times 2$, $15\times 3$, $20\times 3$, $20\times 5$, $20\times 10$, $30\times 5$, $30\times 10$, $40\times 5$, $40\times 10$. All instances were given identifiers from 1 to 120. All generated instances are available in the Supplementary Materials to this paper.

6.1.2. Evaluation Method

To measure the quality of the solutions provided by the algorithms, we calculated the percentage relative differences between their quality and the quality of reference solutions—called short gaps. In other words, the gap for a solution $\mathit{\sigma }$ is defined as:

$$\mathrm{gap}(\mathit{\sigma })=\frac{C_{\max }(\mathit{\sigma })-C_{\max }\left({\mathit{\sigma }}_{\mathrm{ref}}\right)}{C_{\max }\left({\mathit{\sigma }}_{\mathrm{ref}}\right)}·100\%,$$

(46)

where ${\mathit{\sigma }}_{\mathrm{ref}}$ is a reference solution. Generally, we chose ${\mathit{\sigma }}_{\mathrm{ref}}$ to be the best known solution in a given context.

6.2. Width of the Neighborhood

First, we investigated how the width of the neighborhood W affects the performance of the TS algorithm. We ran the TabuA algorithm with $\mathtt{MaxTime}=10\left[s\right]$ for all 120 instances. For each instance, the algorithm was run 100 times, and each time W was set to a different value, equal to a given fraction of the maximum possible neighborhood width. For example, for $n=30$ and $m=10$, the value of W is in $[1,290]$. Then, a 50% width corresponds to W = 145. The reference solution for computing the gap was the best among all 100 runs for each instance. The resulting gaps, averaged over all instances, are shown in Figure 6.

Higher values of W provided considerably worse results, i.e., a larger neighborhood size does not compensate the larger time required to evaluate it. Thus, lower values of W are preferred. However, a very small neighborhood size also leads to a larger gap. Such results are to be expected, as in high quality solutions, most setups are close to their initial positions in the order $\mathit{\sigma }$ generated by the starting procedure, and wide inserts are rarely required. On the other hand, a very narrow neighborhood requires multiple TS iterations to perform any significant change in $\mathit{\sigma }$. Based on this observation, we set W to 10% of the maximum neighborhood width in the following experiments.

6.3. Performance of the Algorithms

In this experiment, we have evaluated the performances of the MILP formulation and the TabuA and TabuB metaheuristics, which utilize the problem properties. In order to correctly compare such different solving methods, we opted to use the same stopping condition—a time limit. Since we intend for the solving methods to be applicable as sub-procedures for solving a two-level problem, the short running time is crucial. Thus, we decided to test several short time limits

$$t\in \{1,2,5,10,20,50,100\}$$

(47)

seconds. Although the times $t\le 10$ are the most practical in the context of a two-level problem, we considered times up to 100 s to better evaluate how the solving methods converge. For each instance, the reference solution was the best one found by any algorithm in 100 seconds (the makespans of the reference solutions can be found in the Supplementary Materials). The results obtained are shown in

Table 4. Average gap [%] for the MILP, TabuA and TabuB methods for different instance size groups and time limits. Best values for each instance size and time limit are underlined. Rows “Diff” contain performance differences (gains) between running times 100 and 1.

Time [s]	Algorithm	Size of the Problem $\mathit{n}\times \mathit{m}$
		$5\times 2$	$10\times 2$	$10\times 3$	$15\times 2$	$15\times 3$	$20\times 3$	$20\times 5$	$20\times 10$	$30\times 5$	$30\times 10$	$40\times 5$	$40\times 10$	Average
	MILP	0.00†	0.00†	0.00†	0.00†	0.84	2.77	2.34	1.53	2.15	0.93	1.81	0.45	1.07
1	TabuA	0.00†	0.20	1.40	0.33	0.94	2.13	0.25	0.55	0.34	0.47	0.33	0.18	0.60
	TabuB	0.00†	0.45	1.43	0.48	1.44	2.01	0.06	0.13	0.12	0.18	0.02	0.01	0.54
	MILP	0.00†	0.00†	0.00†	0.00†	0.37	2.05	1.11	1.53	2.15	0.93	1.81	0.45	0.87
2	TabuA	0.00†	0.20	1.40	0.33	0.93	1.96	0.12	0.45	0.34	0.41	0.10	0.11	0.54
	TabuB	0.00†	0.45	1.43	0.48	1.44	1.88	0.06	0.00	0.12	0.18	0.02	0.01	0.52
	MILP	0.00†	0.00†	0.00†	0.00†	0.27	0.77	0.56	1.53	1.28	0.93	1.65	0.45	0.62
5	TabuA	0.00†	0.20	1.40	0.33	0.93	1.68	0.06	0.45	0.11	0.41	0.08	0.06	0.49
	TabuB	0.00†	0.45	1.43	0.48	1.44	1.77	0.06	0.00	0.08	0.05	0.02	0.01	0.49
	MILP	0.00†	0.00†	0.00†	0.00†	0.13	0.52	0.23	1.53	0.94	0.93	1.41	0.45	0.51
10	TabuA	0.00†	0.20	1.40	0.33	0.93	1.68	0.06	0.45	0.11	0.41	0.08	0.06	0.48
	TabuB	0.00†	0.45	1.43	0.48	1.44	1.77	0.06	0.00	0.08	0.05	0.00	0.00	0.49
	MILP	0.00†	0.00†	0.00†	0.00†	0.11	0.31	0.15	1.11	0.89	0.93	0.88	0.45	0.41
20	TabuA	0.00†	0.20	1.40	0.33	0.93	1.68	0.06	0.39	0.08	0.41	0.02	0.06	0.47
	TabuB	0.00†	0.45	1.43	0.48	1.44	1.77	0.06	0.00	0.08	0.05	0.00	0.00	0.49
	MILP	0.00†	0.00†	0.00†	0.00†	0.01	0.08	0.12	0.35	0.48	0.93	0.60	0.45	0.25
50	TabuA	0.00†	0.20	1.40	0.33	0.93	1.68	0.06	0.10	0.08	0.18	0.00	0.06	0.42
	TabuB	0.00†	0.45	1.43	0.48	1.44	1.77	0.06	0.00	0.08	0.05	0.00	0.00	0.49
	MILP	0.00†	0.00†	0.00†	0.00†	0.00‡	0.00	0.01	0.17	0.22	0.90	0.40	0.45	0.18
100	TabuA	0.00†	0.20	1.40	0.33	0.93	1.68	0.06	0.08	0.07	0.09	0.00	0.06	0.41
	TabuB	0.00†	0.45	1.43	0.48	1.44	1.77	0.06	0.00	0.08	0.05	0.00	0.00	0.49
	MILP	0.00	0.00	0.00	0.00	0.84	2.77	2.33	1.36	1.94	0.03	1.41	0.00	0.89
Diff	TabuA	0.00	0.00	0.00	0.00	0.01	0.45	0.19	0.47	0.27	0.37	0.32	0.12	0.19
	TabuB	0.00	0.00	0.00	0.00	0.00	0.24	0.00	0.13	0.04	0.12	0.02	0.01	0.05

Optimality of “0.00” entries: ^† All the instances solved optimally. ^‡ The majority of the instances solved optimally.

.

For smaller instances (up to 3 machines, under around 60 operations), the MILP formulation is consistently better or on-par with any TS algorithm, regardless of the time limit. In fact, the solver frequently reported for the returned solutions to be optimal and therefore unbeatable by TS. However, for larger, industry-size instances, the TS algorithm performs better than MILP. Once again, this effect is consistent over all time limits.

Comparing the two TS algorithm variants, TabuB (which makes a wide use of Theorem 1) is consistently better or on-par with TabuA (which uses only the refinement procedure). For larger running times ($t\ge 50$), both TS algorithms start to provide similar results. This demonstrates that, given enough running time, both versions of the TS algorithm converge to solutions of a similar quality. However, the TabuB variant is superior in convergence speed, outperforming TabuA for $t\le 20$ and staying on-par with it for $t>20$. This is easily observed in the last rows of the table, showing the difference (gain) between $t=1$ and $t=100$ time limits. For TabuB, the values are close to 0, meaning the algorithm does not benefit from a higher running time, while still equaling or outperforming TabuA.

Finally, to better visualize the improvements each method makes within the 100 s, we shown in Figure 7 and Figure 8 the relation between the best solution found and time for 6 exemplary instances. The performance of MILP was recorded for seven different time limits (see (47)) set within the solver, while for TS algorithms, a timestamp of each improvement was recorded. The plots confirm that TabuB method converges much faster than TabuA, while the MILP formulation still makes improvements when both TS algorithms have almost converged. Moreover, for some large instances (e.g., instance 78, refer to the figure), even 100 s is not enough for a MILP formulation to improve its starting solution, while TS algorithms converge in under 2 s. On the other hand, in several cases all algorithms failed to make any significant improvements. This, however, mostly happened for smaller instances, where the initial solutions are near-optimal.

7. Conclusions and Future Work

In the paper, we considered a single-server permutation Flow Shop manufacturing process. We divided the full problem into two levels and tackled the second level, i.e., finding an optimal order of disjoint setups for a given, fixed order of jobs.

We presented a mathematical model of the considered problem, including a compact solution representation. Then, we formulated several problem properties. We demonstrated an interesting connection between Catalan numbers and the number of feasible solutions for two machines. We also discussed the challenge of generalizing this result for more machines, despite several generalizations of the Catalan numbers existing. With a lack of a closed-form expression, we proposed a Dynamic Programming algorithm for the task, with a time complexity of $O\left(m{n}^m\right)$. Furthermore, we formulated an elimination property that allows to detect and skip suboptimal solutions. For 10 jobs and 6 machines, the property allows one to disregard almost 99.9% of the solution space. This property was then used to develop an efficient refinement procedure, which can be applied to potentially improve any feasible solution in a time as short as a time required to evaluate it.

To solve the problem, we proposed three algorithms: a Mixed-Integer Linear Programming (MILP) formulation and two variants of the Tabu Search (TS) metaheuristic, implementing the identified properties. The solving methods were then tested empirically on instances based on Taillard’s generation scheme. The MILP formulation was the best for smaller instances (up to 50–60 operations), allowing to obtain optimal or near-optimal solutions. For larger, industry-size instances, the TS algorithms outperformed MILP (which was sometimes unable to improve the starting solution at all). Between the two TS variants, the one utilizing elimination property converged faster than the variant that used only the refinement procedure, usually finding good solutions in under 1 s. A good performance together with short running time proved the usefulness of the proposed method as a part of a larger, two-level heuristic for a full problem.

For future work, we consider three research directions. First, we want to tackle the full, two-level problem, optimizing both the order of setups and the order of jobs. Second, we want to generalize the problem shown in this paper, by allowing for a fixed number of setups to be performed at the same time (multi-server). Third, we want to extend our research concerning the connection between the number of feasible setup orders and lattice paths, in order to obtain a closed-form formula for the size of the solution space.