Mathematical Modeling and A Novel Heuristic Method for Flexible Job-Shop Batch Scheduling Problem with Incompatible Jobs

Abstract

This paper investigates a novel flexible job-shop scheduling problem, where the machines have batch-processing capacity, but incompatible jobs cannot be processed in a batch (FJSPBI) simultaneously. This problem has wide applications in discrete manufacturing, especially in chemical and steel casting industries. For the first time, in this study, a 3-indexed mixed-integer linear programming (MILP) model is proposed, which can be efficiently and optimally solved by commercial solvers for small-scale problems. In addition, an improved large neighborhood search (LNS) algorithmic framework with an optimal insertion and tabu-based components (LNSIT) is proposed, which can achieve high-quality solutions for a large-scale FJSPBI in a reasonable time. A perturbation strategy and an optimal insertion strategy are then additionally embedded to improve the exploitation and exploration ability of the algorithm. The proposed model and algorithm are tested on numerous existing benchmark instances without the incompatibility characteristics, and on newly generated instances of the FJSPBI. The experimental results indicate the effectiveness of the proposed MILP model and the algorithm, including the proposed strategies, and the optimal insertion strategy can significantly reduce the computational burden of the LNS algorithm. The comparison results further verify that the proposed LNSIT can directly solve the specific flexible job-shop batch scheduling problem without incompatibility, with better results than existing methods, especially for large-scale instances. Additionally, the impacts of a wide range of characteristics, including batch capacity, incompatibility rate, instance scale, and machine processing rate, on the performance of the LNSIT and the scheduling results are analyzed and presented.

1. Introduction

1.1. Job-Shop Scheduling Problem

Job-shop scheduling problem (JSP) is the core of production management to realize artificial intelligence, automation, and information in manufacturing. Effective scheduling is vital to improve the efficiency of production assignment, and, thus, JSP has a strong and extensive engineering practical application in the pharmaceutical industry [1] and in consumer electronics manufacturing [2]. JSP was derived from the parallel-machine scheduling problem (PMSP) and is one of the most important scheduling problems in real-world manufacturing systems, where each job consists of a sequence of operations, and each operation needs to be processed on a given machine. Due to its high complexity and NP-hard nature, JSP has attracted great research attention. Zhang et al. [3] classified JSP models into five categories according to their complexity and components’ properties, which are known as the basic, multi-machine, multi-resource, multi-plant, and smart factory types. Regarding the approaches for solving the JSP, many researchers have attempted to develop efficient algorithms to obtain optimal solutions for large-scale cases. In terms of the exact methods, Carlier and Pinson [4] presented a branch-and-bound method to optimally solve the instance with 10 machines and 10 jobs that was proposed by Fisher [5] 20 years ago. Lawrence [6] proposed 40 benchmark instances of JSP with up to 15 jobs and 10 machines. AitZai et al. [7] proposed a modified branch-and-bound method with a new branch strategy to solve the instances in [6] as well, and they obtained the optimal solutions for instances with up to 6 jobs and 10 machines. Their numerical results indicated that the method has great advantages and is promising for solving small- and medium-scale JSPs. Other scholars have also presented other exact methods, such as dynamic programming (DP) [8] and Lagrange relaxation (LR) [9], for solving JSPs.

Due to the fact that exact algorithms can be challenging to apply when solving large-scale JSPs, scholars have paid more attention to devising new heuristics. Kurdi [10] proposed an improved genetic algorithm (GA) for solving a JSP, where different sub-populations have different evolutionary methods, so that the individuals with the worst environmental adaptability could be exchanged to diversify the search process. To integrate the advantages of various algorithms, some researchers hybridized several algorithms to construct more effective hybrid algorithms to solve JSPs, such as the hybrid GA [11] and the hybrid tabu search-path relinking algorithm [12]. In some cases, there are certain objectives and constraints that are considered in terms of preference, and researchers have found different methods to somehow satisfy them. For example, Vela et al. [13] analyzed a JSP with flexible due dates and proposed a hybrid GA and the tabu search algorithm to efficiently solve the JSP with up to 20 jobs and 15 machines. Huang and Yu [14] studied a multi-objective JSP for minimizing a weighted sum of makespan, tardiness, and lot-splitting cost, which has managed to efficiently solve instances with up to 100 jobs and 10 machines.

1.2. Flexible Job-Shop Scheduling Problem

An investigation on customization in healthcare, mobility, retail, and home and city environments of 3000 consumers shows that nearly all consumers expect some level of customization in their products, and 83% of consumers expect their products to be completely customized [15]. In reality, machines may be unavailable for processing jobs when a breakdown happens, which undermines flexible production. Flexible JSP (FJSP) is a variation of JSP that can overcome this drawback, which allows each operation to be processed by any machine out of a given set of candidate machines. The framework for solving FJSP can be classified into two branches. In the first branch, the FJSP is decomposed into two sub-problems, i.e., allocating jobs to machines and optimizing the sequence of jobs on each machine, and the whole problem is solved by the interactions between the algorithms for each sub-problem [16]. The second approach is more common, which treats the FJSP as a multiple traveling salesman problem (TSP) where jobs and machines are mapped to cities and salesmen, respectively. As such, neighborhood search algorithms and evolutionary algorithms are widely applied in the FJSP. For example, two TS algorithms [17] and an improved quantum cat swarm optimization (QCSO) algorithm [18] have been adopted and adapted to solve the FJSP. There are many extensions of FJSP, such as the distributed flexible job-shop scheduling problem (DFJSP) [19] and the energy-efficient FJSP [20].

1.3. Batch Scheduling

Batch scheduling stems from large-scale integrated circuit manufacturing in semiconductor production, which is widely applied in diverse areas such as semiconductor manufacturing, aircraft manufacturing, shoe manufacturing, and healthcare [21]. A batch processing machine processes several jobs simultaneously as a batch to improve machine utilization and reduce processing time. In order to maximize the efficiency in the manufacturing system with batch processing ability, batch scheduling has been extensively investigated. Damodaran and Vélez-Gallego [22] presented a method to calculate the lower bound of the identical parallel-machine batch scheduling problem (PBMP) with preemptions and non-identical job sizes by separating each job as a set of jobs with unit size. Muter [23] obtained the upper and lower bounds of the PBMP via a column generation algorithm. There are many heuristic algorithms for solving PBMP. Chang et al. [24] proposed a simulated annealing (SA) algorithm to solve the PBMP with identical job sizes. Jia and Leung [25] proposed an ant-colony-optimization-based metaheuristic to solve the same problem with non-identical job sizes to minimize the makespan. Jia et al. [26] extended the research in [25] by considering identical machine capacities, non-identical job sizes, and different weights of jobs. Shahvari and Logendran [27] proposed an enhanced TS algorithm with diversification strategies for solving the PBMP.

Most existing studies focus on batch processing in a parallel-machine scheduling environment. Only a few studies have considered batch processing in a flexible job-shop scheduling environment. Ham [28] studied a flexible job-shop scheduling problem with parallel batch processing machine and compatible job families (FJSPBC), where a 4-indexed MILP model was proposed, which could optimally solve FJSPBCs using Gurobi. For these instances, the maximum number of jobs multiplied by the number of operations is 96. Subsequently, Ham and Cakici [29] proposed a 3-indexed model for the same problem, which was experimentally proven to be more efficient through a set of instances. However, the lack of correctness and comprehensiveness in the constraints of the 3-indexed model undermines its efficacy. For example, the 3-indexed model cannot ensure that the start time of an operation of a job is later than or the same as the completion time of its direct precedent operation when job operations are processed on different machines. In addition, the 3-indexed model cannot obtain the optimal solution for the FJSPBC when the operations of different jobs with different indexes (e.g., operation 1 of job 1 and operation 2 of job 2) need to be processed in the same batch. Moreover, the two models proposed in Ham [28] and Ham and Cakici [29] can only solve the problem where each job has the same number of operations, since there are no parameters or variables defining the operations belonging to each job.

1.4. Batch Scheduling Considering Incompatible Jobs

In this study, we extend the research in Ham and Cakici [29] by proposing a new 3-indexed MILP model for the FJSPBC to overcome the drawbacks of the models proposed in previous studies. Meanwhile, we adapt the model to accommodate a more generalized scenario by considering incompatible jobs under the batch processing environment (i.e., FJSPBI). In fact, job processing generally has different procedural requirements, and incompatible jobs commonly occur in batch scheduling problems [30,31,32]. Solving this problem has wide applicability in industrial settings, such as in chemical processing and heat treatment facilities in steel casting industries. The FJSPBI is a problem extended from the FJSP, with more batch capacity and incompatibility constraints. When the batch capacity and the number of job family both equal to one, the FJSPBI can be transformed to the FJSP. In addition, a heuristic algorithm known as LNSIT is proposed in this study to efficiently solve large-scale FJSPBIs. To verify the efficacy of the proposed model and approach, numerical experiments are performed on a wide range of FJSPBC and FJSPBI instances with different problem characteristics.

1.5. Contribution of This Work

The main contributions of this work are threefold: (i) The FJSPBI is studied for the first time, which is extended from the FJSP. A 3-indexed MILP model is proposed, which can optimally solve small-scale FJSPBCs and FJSPBIs. (ii) A LNSIT heuristic incorporating an optimal insertion and tabu-based strategy with a large neighborhood search algorithm is established, which can efficiently solve large-scale FJSPBCs and FJSPBIs. (iii) The impacts of different characteristics, such as batch capacity, incompatibility rate, and machine processing rate, on the performance of the MILP-based and heuristic algorithms are analyzed and concluded.

The remainder of this paper is organized as follows: Section 2 details the FJSPBI problem and proposes a 3-indexed MILP model. A perturbation-based LNSIT for solving the FJSPBI is proposed and explained in Section 3. In Section 4, many FJSPBI instances with various characteristics are generated and solved by the proposed method, with the numerical results presented and analyzed. Finally, Section 5 concludes the paper with a discussion on future research direction.

2. MILP Model of the FJSPBI

2.1. Problem Description

In the FJSPBI shown in Figure 1, we are given a set of machines M (m ∈ M), jobs J (j ∈ J) and job families I (i ∈ I), where each job has a set of operations O_j (j ∈ J) that have to be processed successively on one machine out of a subset of candidate machines. Each machine is associated with a capacity Φ_m (m ∈ M), where operations of different jobs can be processed simultaneously in a batch as long as the following two conditions are satisfied: (i) the total size of the batch does not exceed the capacity of the machine, and (ii) the operations in the same batch belong to the same job family. Since different operations may need different processing times, the processing time of a batch is determined by the longest processing time of operations in the batch. The FJSPBI of interest aims to achieve an optimal schedule that minimizes the maximum completion time over all operations (i.e., makespan), while satisfying all operational constraints.

In Figure 1, $J_{ijo}{p}_t$ represents the operation o of job j that belongs to job family i with a processing time of t. Figure 1a illustrates a feasible solution, and Figure 1b illustrates an infeasible solution where (i) incompatible jobs cannot be processed in the same batch, (ii) the size of a batch cannot exceed the capacity of the machine that processes it, and (iii) the operations of a job must be processed in the correct order. The sets, parameters, and variables used for the model are defined in

Table 1. The meaning of sets, parameters and variables.

Sets and Parameters	Meaning
J:	Set of jobs.
O:	Set of operations.
Oj:	Set of operations of job j.
I:	Set of job families.
M:	Set of machines.
Mjo:	Set of machines capable of processing operation o of job j.
B:	Set of batches. The number of batches is defined as the number of jobs multiplied by the number of operations.
pjom:	Processing time of operation o of job j on machine m.
${\Phi }_m$:	Processing capacity of machine $m$.
$l$:	Max (${{\displaystyle \sum }}_{j\in J}{{\displaystyle \sum }}_{o\in O}{p}_{jom}, \forall m\in M$).
Variables	Meaning
$X_{job}$:	Binary variable, $X_{job}=1$ if operation $o$ of job $j$ is processed in batch $b$, and 0 otherwise.
$Y_{bm}$:	Binary variable, $Y_{bm}=1$ if batch $b$ is processed on machine $m$, and 0 otherwise.
$Z_{jib}$:	Binary variable, $Z_{jib}=1$ if job $j$ belonging to family $i$ is processed in batch $b$, and 0 otherwise.
$H_{jo}$:	Start time of operation $o$ of job $j$.
$U_{jo}$:	Completion time of operation $o$ of job $j$.
$S_b$:	Start time of batch $b$.
$C_b$:	Completion time of batch $b$.
$P_b$:	Processing time of batch $b$.
$C_{max}$:	Makespan.

.

2.2. MILP Model of the FJSPBI

Objective (1) minimizes the makespan.

$$\min C_{max}$$

(1)

Constraint (2) ensures that each operation has to be assigned to a batch.

$${{\displaystyle \sum }}_{b\in B}{X}_{job}=1,\forall j\in J,o\in O_j$$

(2)

Constraint (3) ensures that jobs belonging to different families cannot be processed in the same batch.

$$Z_{jib}+Z_{j^{\prime }{i}^{\prime }b}\le 1,\forall j,j^{\prime }\in J,j\ne j^{\prime },i,i^{\prime }\in I,i\ne i^{\prime },b\in B$$

(3)

Constraint (4) ensures that only when there is a batch $b$ processed on a given machine $m$ that a job can be processed in the batch.

$${{\displaystyle \sum }}_{m\in M}{Y}_{bm}\ge X_{job},\forall j\in J,o\in O,b\in B$$

(4)

Constraint (5) ensures that the number of operations processed in batch $b$ on machine $m$ does not exceed the capacity of the machine.

$${{\displaystyle \sum }}_{j\in J}{{\displaystyle \sum }}_{o\in O}{X}_{job}\le {\Phi }_m+(1-Y_{bm})l,\forall b\in B,m\in M$$

(5)

Constraint (6) ensures that $X_{job}$ and $Y_{bm}$ cannot both be 1, which ensures that job $j$ can only be processed on one machine out of a subset of candidate machines.

$$X_{job}+Y_{bm}\le 1,\forall j\in J,o\in O, b\in B, m\in M\backslash M_{jo}$$

(6)

Constraint (7) defines the processing time of batch $b$ on machine $m$, which is determined by the maximum processing time of jobs in the batch.

$$P_b\ge p_{jom}-(2-X_{job}-Y_{bm})l,\forall j\in J,o\in O,b\in B,m\in M$$

(7)

Constraints (8)–(11) determine the start time and completion time of batch $b$. Constraints (8) and (9) ensure that the start time of each operation is the same as the start time of the batch that processes it.

$$S_b\le H_{jo}+(1-X_{job})l,\forall j\in J,b\in B,o\in O$$

(8)

$$S_b\ge H_{jo}-(1-X_{job})l,\forall j\in J,b\in B,o\in O$$

(9)

Similarly, Constraints (10) and (11) ensure that the completion time of each operation is equal to the completion time of the batch that processes it.

$$C_b\le U_{jo}+(1-X_{job})l, \forall j\in J, b\in B,o\in O$$

(10)

$$C_b\ge U_{jo}-(1-X_{job})l,\forall j\in J,b\in B,o\in O$$

(11)

Constraint (12) ensures precedence relationship between operations of the same job.

$$H_{jo}\ge U_{j\left(o-1\right)},\forall j\in J,o\in O,o>1$$

(12)

Constraint (13) ensures that the completion time of batch $b$ is equal to the sum of the start time and the processing time of the batch.

$$C_b-P_b=S_b,\forall b\in B$$

(13)

Constraint (14) ensures precedence relationship between batches on the same machine.

$$C_b\le S_{b^{\prime }}+(2-Y_{bm}-Y_{b^{\prime }m})l,\forall m\in M,b,b^{\prime }\in B,b<b^{\prime }$$

(14)

Constraint (15) ensures that if an operation $o$ of a job $j$ is processed in batch $b$, then job $j$ belonging to family $i$ is processed in batch $b$.

$$Z_{jib}\ge X_{job},\forall j\in J,o\in O,i\in I,b\in B$$

(15)

Constraint (16) ensures that the start time of an operation $o$ of a job $j$ is at least the total minimum processing time of the precedent operations of the job. It is valid for tightening the feasible region of the problem and can reduce solution time.

$$H_{jo}\ge {{\displaystyle \sum }}_{k<o}\min p_{jom},\forall j\in J,k,o\in O,o>0,m\in M$$

(16)

Constraint (17) guarantees the makespan of batch $b$ must be shorter than the maximum makespan.

$$C_{max}\ge C_b, \forall b\in B$$

(17)

The constraints for boundaries and the types of variables are formulated as follows:

$$X_{job}\in \left\{0,1\right\},\forall j\in J,o\in O,b\in B$$

(18)

$$Y_{bm}\in \left\{0,1\right\},\forall b\in B,m\in M$$

(19)

$$Z_{jib}\in \left\{0,1\right\},\forall j\in J,i\in I, b\in B$$

(20)

$$0\le H_{jo}, U_{jo},S_b,C_b,P_b\le C_{max}, \forall j\in J,o\in O,b\in B$$

(21)

3. Solution Method for the FJSPBI

The generality of MILP solution methods is limited, and heuristics can help tackle instances with large sizes. This study proposes an improved large neighborhood search algorithmic framework with optimal insertion and tabu-based components (LNSIT) as a heuristic for solving the FJSPBI. The framework for solving the FJSP can be separated into two branches, where the approaches in the second branch mentioned above treat the FJSP as a multiple TSP domain. Recent research results have shown that neighborhood-search-based algorithms have advantages in solving multiple TSPs [33]. The LNS algorithm has been proven to have significant advantages in solving discrete combinatorial optimization problems [34,35]. The LNS algorithmic framework is presented due to its mechanism of large neighborhood reconstruction and strong ability in global search [36]. This study adopts the LNS framework and improves its performance by incorporating optimal insertion and TS strategies according to the characteristics of the FJSPBI. The LNSIT searches for an optimal solution structure (i.e., solution of the main assignment problem), where the Bellman–Ford algorithm [37] and the LNSIT algorithm are called for, and the feasibility of job batch incompatibility is checked during the objective function evaluation. The computational complexity of the Bellman–Ford algorithm is O(VA), where V and A denote the number of vertices and arcs, respectively. In the FJSPBI, V denotes the number of batches in the solution structure, and A describes the precedence relations between these batches. In the worst-case scenario where each operation of a job is assigned to a single batch, the number of batches equals the number of all operations. Let E be the total number of operations of jobs, then the number of arcs is bounded by O(E). As such, the highest possible computational complexity of the Bellman–Ford algorithm in the solution approach is O($E^2$). The computational complexity of the proposed LNSIT depends on the removal and insertion operators. For the removal operator, the worst computational complexity of the worst removal operator is O(ElogE). For the insertion operator, the worst-case computational complexity of the deep greedy insertion operator is O($E^3$). Therefore, the worst-case computational complexity of the solution approach is O($E^5$).

There are 3 jobs and 2 machines, each job with 2 operations. Figure 2a shows the processing time of operation $o$ of job $j$ belonging to family $i$ on machine $m$. After each operation is assigned to a machine, the initial solution is obtained. In Figure 2b, $J_{222}{p}_{21}$ and $J_{112}{p}_{64}$ are processed in the same batch, and the batch is removed, as shown in Figure 2c. Then, $J_{222}{p}_{21}$ and $J_{112}{p}_{64}$ are reinserted to other existing batches or a new batch, and a new solution can be obtained, as shown in Figure 2d. The next iteration is implemented in the same manner.

3.1. Framework of the Proposed LNSIT for the FJSPBI

Denote $M$ and $\left|M\right|$ as the set of machines of the FJSPBI and the total number of machines, respectively. Let $B_m$ and $|B_m$| be the set of batches and the total number of batches processed on a given machine $m$, respectively. The solution structure of the FJSPBI is defined as follows:

$$S=\left[\begin{array}{ccc}{N}_1\left(1\right)& \cdots & N_1\left(\left|B_1\right|\right)\\ ⋮& \ddots & ⋮\\ N_{\left|M\right|}\left(1\right)& \cdots & N_{\left|M\right|}\left(\left|B_{\left|M\right|}\right|\right)\end{array}\right]$$

(22)

where $N_m\left(b\right)=\left\{o\in O_j, j\in J|X_{job}=1\right\}, \forall m\in M,b\in B_m\}$ represents a subset of operations that are assigned to batch $b$ of machine $m$. Thus, the aim of solving the FJSPBI is to find the optimal solution structure. It can be proven that the optimal start time of each batch can be obtained as long as the optimal solution structure $S$ of Equation (22) is obtained, and, thus, the makespan can be obtained. We also need to estimate the merit of the solution structure (i.e., calculate the objective function value), which can be converted to the shortest path problem and solved by the Bellman–Ford algorithm (see Section 3.5). Based on the above analysis, the idea of the proposed method is to present an algorithm to search for the optimal solution structure $S$. The LNS algorithm will deal with redundant calculations and cause large computational burden because all feasible positions are checked and considered when inserting operations using this algorithm. In our LNSIT algorithm framework, the infeasible positions to insert are identified when the constraints are violated. In order to avoid repetitive searching, a tabu-based worst removal operator is proposed, which prevents the undesirable removal of operations from the tabu list within a Tabu period ($TP$). An optimal insertion-based deep greedy insertion operator is also proposed to accelerate solving the search process of the algorithm. In addition, a perturbation mechanism is embedded to insert operations to their optimal insertion positions, to diversify the solutions, and to escape the local optimum. This paper draws on the exponential Monte Carlo acceptance criterion, which is similar to the simulated annealing acceptance criterion that was proposed by [38] to accept a new solution. The difference is that the former generates a random number $RN<\exp$($-AP\cdot$($O_b$($X^{-}$)$-O_b$($X$))) in [0, 1], where $AP$ is a constant and $O_b$($X$) denotes the objective value of solution $X$. The framework of LNSIT for solving the FJSPBI is described in Algorithm 1.

Algorithm 1 LNSIT for FJSPBI

Input: FJSPBI instances and parameters Output: Optimal solution $S^{\ast }$ 1: Create initial solution $S_0,$ let $S^{\ast }=S_0;$ current solution $S=S_0,$ initial tabu-related iteration of each operation $I_o=0$ 2: while the maximum number of iterations is not met do 3: Implement the tabu-based worst removal operator $R_i^{-}$ on $S$ and obtain a partial solution $S^{-}$ 4: Implement the optimal insertion-based deep greedy repair operator $R_i^{+}$ on $S^{-}$ and obtain a new solution $S^{\prime }$ 5: if $O_b\left(S^{\prime }\right)<O_b\left(S\right)$ do 6:  $S=S^{\prime }$ 7:  if $O_b \left(S^{\prime }\right)<O_b(S^{\ast })$ do 8:   $S^{\ast }=S^{\prime }$ 9:  end if 10:  else 11:  Add the removed operations to tabu list with a probability of ${\rho }_1$ 12:  $I_o=I_o+1$ 13:  if $I_o>TP$ do 14:   Remove operation $o$ from the tabu list 15:  end if 16: end if 17: Present the exponential Monte Carlo acceptance criterion 18: end while

3.2. Initial Solution Construction

Each operation is assigned as an individual batch to a machine. Specifically, each operation is assigned to a candidate machine that can process this operation, while balancing the workload between different machines. The procedure for constructing an initial solution structure is listed as follows:

Step 1: Shuffle the jobs randomly and assign the first operation in front of the sequence to a machine that can process it. Assign the first operation of the first job to a machine so it can process the operation.

Step 2: Repeat Step 1. Ensure that the machine is not the one previously assigned if there is more than one machine that can process the current operation.

Step 3: Repeat Step 2, and an initial solution is obtained until all operations are assigned to one machine out of a subset of candidate machines.

This initial solution construction method guarantees the feasibility of a solution and ensures all operations are assigned. It increases the randomness of solutions as well as balances the workload among all machines.

3.3. Tabu-Based Worst Removal Operator

The worst removal operator was first proposed in [39], which removes the operation node that contributes most to the objective of the current solution. Let $S_{\_o}$ be the partial solution without operation $o$, and $O_b\left(S\right)$ and $O_b\left(S_{\_o}\right)$ be the objective values of solutions $S$ and $S_{\_o}$, respectively. For each operation, the difference $D_f(S,o)=O_b\left(S\right)-O_b\left(S_{\_o}\right)$ is calculated and operation $o$ that leads to the largest difference is removed. Then, the difference of each remaining operation is calculated based on the new structure. This procedure is repeated until a certain number of operations are removed.

To enhance the efficiency of the removal operator, a tabu-based strategy is incorporated into the worst removal operator. Specifically, if a removed operation is reinserted and it leads to a worse solution than the current one, the removed operation is put into the tabu list with a probability ${\rho }_1$, which is forbidden to be removed again within the predetermined $TP$. The procedure of the tabu-based worst removal is described in Algorithm 2, where $\omega$ is the number of operations that need to be removed.

Algorithm 2 Tabu-based worst removal

Input: Current solution $S,$ tabu list $R_o^{’},$ constant $\omega$ Output: Set of operations needs to be removed $\left(R_o\right)$ 1: while $o$ is in $R_o\backslash R_o^{’}$ do 2: if the number of operations $\left|R_o\right|<\omega$ do 3:  For all $o\in O$, sort $D_f(S,o)=O_b\left(S\right)-O_b\left(S_{\_o}\right)$ by descending order 4:  Remove operator $o={\mathrm{argmin}}_{o\in O\backslash R_o}{D}_f(S,o), R_o$=$R_o\cup \left\{o\right\}$ 5: end if 6: end while

3.4. Deep Greedy Insertion Operator

Ropke and Pisinger [39] proposed the deep greedy insertion operator, which aims to insert the operations in $R_o$ into their best positions in a certain order. Firstly, for each operation in $R_o$, the objective value is calculated when the operation is inserted into an available position, and then the operations are sorted in ascending order according to their smallest objective value corresponding to their best insertion position. Subsequently, the operation in front of the sequence is inserted into its best insertion position. This process is repeated until all the operations in $R_o$ are inserted. The deep greedy insertion operator calls for the objective value evaluation algorithm for each operation position assignment, which can be very time consuming especially for large-scale problems.

For this reason, an optimal insertion strategy is proposed here to significantly reduce the computational burden without diminishing its functionality. The basic idea is to consider a subset of positions rather than all possible positions, where the subset can be proven to always contain the best insertion position rather than all feasible positions. In addition, the traditional deep greedy insertion operator inserts operations to their best positions during the whole search, which is not conducive to exploration ability and may cause a premature convergence of the algorithm. Therefore, a perturbation mechanism is incorporated into the greedy insertion, and the enhanced deep greedy insertion operator is described in Algorithm 3.

The solution structure is denoted as $S_{+o}^{-}$ after the insertion of operator $o$; $p_o^l$ represents the $l_{th}$ position where operation $o$ can be inserted; and set $P$ includes the subset positions. Symbol $O_b(S_{+o}^{-},p_o^l)$ is the objective value after operation $o$ is inserted in the $l_{th}$ position, and $O_b^1(S_{+o}^{-},p_o^1)$, $O_b^2(S_{+o}^{-},p_o^2)$, …, denote the ordered objective values.

Algorithm 3 Optimal insertion-based deep greedy insertion

Input: Set of removed operations $R_o,$ current solution structure $S^{-}$, and corresponding objective $O_b\left(S^{-}\right)$ Output: Solution structure with the operation inserted and corresponding objective value $O_b(S_{+o}^{-},p_o^l)$ 1: while the number of operations $\left|R_o\right|<\omega$ and $R_o\ne \varnothing$ do 2: Present the optimal insertion strategy 3: for $o\in R_o$ and $p_o^l\in P$ do 4:  Insert each operation $o$ to each $p_l^m$ and calculate $O_b(S_{+o}^{-},p_o^l)$ 5:  For all $o\in O$, sort difference of objective $D_f(S,o)=O_b(S_{+o}^{-},p_o^l)-O_b\left(S^{-}\right)$ by ascending order 6:  Choose operator $o={\mathrm{argmin}}_{o\in R_o}{D}_f(S,o)$ 7: Insert the operator $o={\mathrm{argmin}}_{o\in R_o}{O}_b^l(S_{+o}^{-},p_o^1), R_o$=$R_o\backslash \left\{o\right\}$ and calculate $O_b(S_{+o}^{-},p_o^l)$ 8:  end for 9: end while

3.4.1. Optimal Insertion Strategy

The optimal insertion strategy is inspired by the research on the FJSP in [17], which presented a local search algorithm for the FJSP. In their study, a local neighborhood solution was generated by removing one operation and inserting it into the resulting partial solution, wherein the best position with a minimum increment of the objective value was selected to generate a promising neighborhood solution. An optimal insertion strategy was proposed, which enables the algorithm to identify a subset of positions rather than all candidate positions in the partial solution for obtaining the best position. To achieve this, they proved that the subset positions are feasible positions for the removed operation to be inserted to achieve a feasible neighborhood solution, and the subset of positions contains the best position. This strategy helps the local search algorithm reduce its computational burden without degrading the quality of solutions.

This optimal insertion strategy is extended in our study. Two differences are considered before applying the strategy, which are distinguished by the properties of the problems and the algorithms presented in [17] and this study. Specifically, the local search algorithm only removes and reinserts one operation to generate a neighborhood solution, while the LNSIT removes and reinserts more than one operation to reconstruct a solution. Moreover, the batching ability was not considered in the FJSP in [17], which means a removed operation can only be reinserted to the positions in front of or after another operation. In contrast, the batching processing ability considered in the FJSPBI allows a removed operation to be reinserted to all positions in an existing batch. In the following sections, we will show how the optimal insertion strategy can be applied to the LNSIT for reconstructing the solutions of the FJSPBI in the specific case when a removed operation is reinserted into the partial solution structure to generate a new batch. Following this, the repair operator only identifies the positions if a removed operation can be inserted into an existing batch without violating the capacity of the machine and a subset of positions, where a removed operation can be inserted to generate a new batch. Therefore, the computational burden of the LNSIT algorithm can be reduced significantly since the objective evaluation algorithm is only called for a subset of insertion positions when implementing the repair operator.

As mentioned before, in the graph representing the solution structure of the FJSPBI, let nodes represent batches (rather than operations) and arcs represent precedence relationship of batches. Let $G$ be the corresponding solution graph and $G_v$ be the graph obtained from $G$ after removing operation $v$. Let $\xi$ be a set of all batches, i.e.,$\xi =\left\{B_{ij}|i\in B,j\in M\right\}$. A neighborhood solution ($m,S$) of the problem is defined for each batch $b\in B_{ij}$, each machine $m\left(b\right)$ on which $b$ is processed without preemption, and each start time $S_b$. Two virtual nodes 0 and ∗ represent the start and end periods, respectively. The weight of each node is the processing time $P_{b,\mu \left(b\right)}$ of corresponding batch $b$ on machine $m_b$, and $P_0=P_{\ast }=0$ is defined. Precedence relations are incorporated in the solution graph by means of precedence arcs; an arc is represented as ($B_{ij}, B_{\left(i+1\right)j}$), where $i\in B$ and $j\in M$. For each batch $b\in B$, we introduce dummy arcs (0,$b$) and ($b$,$\ast$). A machine arc ($b,d)$ indicates that batch $b$ is a direct predecessor of batch $d$ processed on the same machine. Accordingly, the graph is defined as $G$($\varsigma ,\tau$), $\varsigma =\xi \cup \left\{0,\ast \right\}$, and $\tau$ is composed of machine arcs, precedence arcs, and dummy arcs.

The start time $S_b$ of batch $b$ is $l$($0,b$) in the graph, and the $P_{b,\mu \left(b\right)}$ is denoted as $P_b$ in the following for brevity. We define the length of a path ($b_1,b_2,\dots ,b_q$) as the sum of processing time from batch $b_2$ to batch $b_{q-1}$. The virtual node 0 represents the start time $S_b=0$, and each arc ($b,d)\in \tau$ represents the constraint of the form $S_d\ge S_b+P_b$. The length of the longest path from point 0 to point $\ast$ is the makespan, and the path is referred to as a critical path. A solution is not feasible if the solution graph contains a cycle. A solution graph not containing a cycle cannot guarantee the feasibility of the solution, since the incompatibility and batch capacity should also be considered. All those constraints are considered in the insertion operational process. We define the tail time $t_b$ as the length of the longest path from batch $b$ to batch $\ast$, i.e., $t_b=l$($b,\ast$). If and only if batch $b$ satisfies $S_b+P_b+t_b=C_{max}$, the batch is called the critical path.

For every operation $x$ in figure $G_v$, let $s_x^{-}$ and $t_x^{-}$ be the start time and the tail time of an operation $x$. We also define a start time ($s_w^{\prime -}$), a tail time ($t_w^{\prime -}$), and a processing time ($p_w^{’-}$) for each operation $w$ in $G_v$, which are equal to the start time, the tail time, and the processing time of the batch that processes this operation. Let $PJ\left[v\right]$($SJ\left[v\right])$ denote the direct operation that precedes (follows) the removed operation $v$ of the same job. In graph $G_v$, we have $s_v^{-}=s_{PJ\left[v\right]}^{-}+p_{PJ\left[v\right]}$ and $t_v^{-}=t_{SJ\left[v\right]}^{-}+p_{SJ\left[v\right]}$. If $v$ is the first (last) operation, let $PJ\left[v\right]=0$($SJ\left[v\right]= \ast$). Since removing operation $v$ will not change the start time of its preceding operations and the tail time of its following operations, we have $s_{PJ\left[v\right]}^{-}=s_{PJ\left[v\right]}$, $t_{SJ\left[v\right]}^{-}=t_{SJ\left[v\right]}$. Let $Q_m$ be the set of all batches processed by machine $m$ in figure $G_v$, which is sorted by the ascending order of start time.

The optimal insertion strategy and proof in [17] can be extended to our study. It can be proven that the set of solutions obtained by inserting operation $v$ after all the batches of $L_m\backslash R_m$ and before all the batches of $R_m\backslash L_m$ (defined as set $F_{vm}$) are feasible. In addition, it can be proven that the insertions on machine $m$ other than the ones in $F_{vm}$ cannot contribute to a solution with a better makespan. The details of the proof are presented in the following. We define $R_m=$($x\in Q_m|s_x$+$p_x>s_v^{-}$) and $L_m=$($x\in Q_m|p_x$+$t_x>t_v^{-}$).

1. $R_m=$($x\in Q_m|s_x$+$p_x>s_v^{-}$): According to the definition of $R_m$, there is no path from any operation $x\in R_m$ to $v$ in $G_v$. If $x$ is an operation of $Q_m\backslash R_m$, then $s_x+p_x\le s_v^{-}$. Since $s_v\ge s_v^{-}$ and $p_v>0$, then $s_x<s_v+p_v$. Therefore, there does not exist any path from $v$ to any operation of $Q_m\backslash R_m$ in $G$ (and hence in $G_v$).

2. $L_m=$($x\in Q_m|p_x$+$t_x>t_v^{-}$): Similarly, there is no path from $v$ to any operation $x\in L_m$ in $G_v$. If $x$ is an operation of $Q_m\backslash L_m$, then $p_x+t_x\le t_v^{-}$. Since $t_v\ge t_v^{-}$ and $p_v>0$, then $t_x<p_v+t_v$. Hence, there is no path from any operation of $Q_m\backslash L_m$ to $v$ in $G$ (and hence in $G_v$).

It follows that the subset position set ${\mathsf{\Theta }}_{vm}$ can be defined as the set of positions after all the operations of $R_m\backslash L_m$ and before all the operations of $L_m\backslash R_m$. We now prove that ${\mathsf{\Theta }}_{vm}$ is a set of feasible positions. There are two cases for $L_m\cap R_m$:

1. $L_m\cap R_m\ne \varnothing$: For each operation $x$ of $L_m\cap R_m$, there is no path from $v$ to $x$ and from $x$ to $v$. Hence, each $k$-insertion of $v$ in $L_m\cap R_m$ delivers a feasible solution.

2. $L_m\cap R_m=\varnothing$: For each operation $x$ of $Q_m\backslash \left(L_m\cup R_m\right)$, there is no path from $v$ to $x$ and from $x$ to $v$ in $G_v$. Therefore, any $k$-insertion of $v$ after each operation of $L_m$ and before each operation of $R_m$ delivers a feasible solution.

A $k$-insertion is called the best $k$-insertion if the resulting solution structure has the minimal objective value which is equal to or smaller than the objective values of all other solution structures. The subset position set ${\mathsf{\Theta }}_{vm}$ contains the best position of $k$-insertion of operation $v$.

3.4.2. Search Perturbation

Ropke and Pisinger [39] first considered inserting a perturbation strategy by proposing a disturbance factor to the objective function for increasing randomness in each iteration to improve the local exploitation ability of the algorithm. Different from the perturbation strategy presented in [39], where a disturbance factor is introduced in each iteration, this paper considers the performance in a certain number of iterations to dynamically decide whether to consider disturbances to balance the exploration and exploitation performances of the algorithm. Specifically, when the optimal solution is not updated within the number of iterations $I_1$, the disturbance factor is triggered. The optimal solution is not updated within the number of iterations $I_2$ when the disturbance factor is removed. This improves the effectiveness and diversity of the algorithm when searching for neighborhood solutions to improve the performance of the algorithm. Among them, disturbance value $N$ is randomly generated in an interval $\left[-MN,MN\right]$ to obtain the processing time $C^{\prime }=\max \left\{0,C+N\right\}$ required to insert an operation. The maximum absolute disturbance value $MN=\phi \cdot MX$ where $\phi$ is a constant in (0, 1], and $MX$ is the maximum processing time of all operations over all capable machines.

3.5. Objective Evaluation

It is useful to represent the problem by a disjunctive graph to calculate the objective function value, since searching the optimal start time of each batch can be converted to a shortest path problem with negative weights and solved by the Bellman–Ford algorithm. The objective value of each solution structure can be calculated via a graph $G$ = ($V, \psi$) inspired by [40], which is defined as follows: $V$= $B\cup \left\{0, \ast \right\}$, where $B$ is a node set containing all batches, and point 0 and point $\ast$ represent the virtual start and end batch, respectively.$\psi =\left\{A, E\right\}$, $A=\left\{\left(b, d\right)|b, d\in B, b\to d\right\}\cup \left\{\left(0, d\right)|d\in B, \nexists b\in B: b\to d\right\}\cup \left\{\left(b, \ast \right)\right|b\in B, \nexists d\in B: b\to d\},$ and $E=\left\{\left\{b, d\right\}|b, d\in B_m, b<d\right\}$ represents a set of arcs between the preceding and the following batches processed on a machine. Each node $d\in B_m$, $m\in M$ in the graph $G$ has a weight (${\lambda }_d$) that is equal to the processing time of the batch that processes the operation, and we define ${\lambda }_0={\lambda }_{\ast }=0$. Each node $d\in B_m$, $m\in M$ is associated with a start time $S_d$, and the arc $\left(b, d\right)\in B$ can be deemed as representing the constraint of the form $S_d\ge S_b+{\lambda }_d$. If we set the length of an arc $\left(b, d\right)\in B$ as ${\lambda }_b$, determining the optimal start time of each batch $d\in B\cup \left\{0, \ast \right\}$ means to find the longest path from node 0 to node $d$. Figure 3 represents a solution for an FJSPBI with 3 jobs, 3 machines, and 3 operations (denoted as 3/3/3). The objective value of the FJSPBI is determined by the length of the longest path in the graph. The weight of each node represents the processing time of each batch. The situations can be classified into two categories: (i) only a single operation in a batch is removed, and (ii) one of the operations in the same batch is removed. For the first category, if a single operation $o$ in a batch is removed, the corresponding batch will not exist and the arcs that are directly connected to it will be removed. Then, the node (batch) which contains the direct preceding operation of operation $o$ will be connected with the node that contains the direct successor. For the second category, removing an operator will not contribute to a deletion of the node, while the arcs in the graph will change according to the precedence relationships between operations. In the single-batch scheduling scenario, the optimal start time of each batch only relates to the start time of the previous batch processed in the same machine and the operations’ start time. In contrast, an operation’s start time is affected by the batch’s start time that processes the previous operation of the same job. As such, the start time of a batch influences the preceding batch processed by the same machine and the batches that are assigned with the previous operations of the corresponding jobs.

4. Computational Experiments

4.1. Instances and Parameters

To assess the quality of the model and the algorithm, several experiments are performed on many instances (i.e., FJSPBC and FJSPBI instances). In order to identify the influence of different problem characteristics on the results of the instances, we generate new instances in two classes. In Class 1, there are 20 small-scale instances as proposed by [41], which are named as F_ instances and are shown in

Table 2. Information of F_ instances.

Instance	$\mathit{n}\mathit{j}$	$\mathit{n}\mathit{m}$	$\mathit{n}\mathit{o}$	Instance	$\mathit{n}\mathit{j}$	$\mathit{n}\mathit{m}$	$\mathit{n}\mathit{o}$
F_01	2	2	2	F_11	5	3	6
F_02	2	2	2	F_12	5	3	7
F_03	3	2	2	F_13	6	3	7
F_04	3	2	2	F_14	7	3	7
F_05	3	2	2	F_15	7	3	7
F_06	3	3	2	F_16	8	3	7
F_07	3	3	5	F_17	8	4	7
F_08	3	3	4	F_18	9	4	8
F_09	3	3	3	F_19	11	4	8
F_10	4	3	5	F_20	12	4	8

. In addition, referring to the generation criterion in [42], we generated 9 medium- and large-scale instances, which are named NI_ instances with different number of jobs ($nj$) and machines ($nm$) ($nj$ and $nm$ are 5 or 10), and the number of operations per job ($no$) are randomly generated in the range of [1, 10], [5, 10], and [10, 15]. For each size, the processing time of operation $o$ on $m$ are randomly generated in the range of [10, 100]. The set of machines $M_o$ capable of processing operation $o$ is constructed by letting the machine be $M_o$ with probability ${\rho }_2$.

As shown in

Table 3. Information of NI_ instances.

Instance	$\mathit{n}\mathit{j}$	$\mathit{n}\mathit{m}$	$\mathit{n}\mathit{o}$	${\mathit{\rho }}_2$
NI_01–NI_06	5	5	[1, 10]	0.2, 0.8
NI_07	5	5	[10, 15]	0.8
NI_08	10	5	[5, 10]	0.8
NI_09	10	10	[10, 15]	0.8

, $nj$ and $nm$ of NI_01–NI_06 are both 5, and $no$ is randomly generated ranging from 1 to 10 ([1, 10]), while their probability ${\rho }_2$ is set as 0.2 and 0.8, respectively. Three replicates for each combination are generated, and six instances are obtained. In contrast, the probability ${\rho }_2$ of NI_07–NI_09 is all set to 0.8, and they differ in the values of $nj$, $nm,$ and $no$.

Under this configuration, we assume that the two different ${\Phi }_m$ as 1 (odd)–2 (even) and 2 (odd)–4 (even) numbered machines have a capacity of 1 (2), or otherwise 2 (4); we refer to the capacity of the machine as 1–2 (2–4), engendering 20 sets of F_ instances and 9 sets of NI_ instances, which are named NI_01–NI_09. For simple expression, instances NI_01–NI_06 with $nj\times no\le$ 50 are named medium-scale instances, and others are large-scale instances.

In Class 2, we generate the instances based on the sets of F_ and NI_ instances by randomly classifying the jobs into different job families, so that there are 152 instances in the two classes when considering different batch capacities and job families.

By applying the trial-and-error approach, the chosen parameters of NI_ instances are presented in

Table 4. Parameters of LNSIT for NI_ Instances.

Instance	$\mathit{n}\mathit{i}$	Scale	${\mathit{\rho }}_2$	${\mathit{\Phi }}_{\mathit{m}}$
NI_01	2, 3, 4	5/5/9	0.2	1–2, 2–4
NI_02	2, 3, 4	5/5/10	0.2	1–2, 2–4
NI_03	2, 3, 4	5/5/10	0.2	1–2, 2–4
NI_04	2, 3, 4	5/5/9	0.8	1–2, 2–4
NI_05	2, 3, 4	5/5/10	0.8	1–2, 2–4
NI_06	2, 3, 4	5/5/6	0.8	1–2, 2–4
NI_07	2, 3, 4	5/5/15	0.8	1–2, 2–4
NI_08	2, 3, 4	10/5/10	0.8	1–2, 2–4
NI_09	2, 3, 4	10/10/15	0.8	1–2, 2–4

, where $ni$ is the number of job families. Parameter $TP$ = max ($no$), and the removal of the upper bound is randomly selected as in [15,25]. The scale and the number of job families of instances are represented by “scale” and $ni$, respectively. The parameter $\phi$= 0.3, $I_1$= 50, $I_2$= 5, the minimum number of removal operations $MNR$= 4, $AP$= 0.1, and the removed operation is input into the tabu list with a probability of ${\rho }_1$= 0.5, and the number of iterations $MI$ = 30,000.

All experiments were coded in the C program and run on an Intel Core i7–10700 processor of 3.80 GHz with 64 GB of memory running 64-bit Windows 10, and a 64-bit version of Gurobi 9.0.3 with an academic license. The 3-indexed MILP model was coded in Gurobi, and all experimental instances with the LNSIT and MILP model were solved within a one-hour time limit. The experimental instances can be downloaded via https://github.com/booksilence/FJSPBI–instances (accessed on 19 December 2022).

4.2. Numerical Results of Instances

4.2.1. Results of the Exact Algorithm

The 3-indexed model proposed in [29] cannot solve the instances when different operations of different jobs belong to a batch, and the number of operations for jobs are different, due to the precedence relationship between batches on the same machine. Therefore, the results of the 3-indexed (TI) model in this paper are compared with the 4-indexed (FI) model proposed in [28] for the FJSPBC instances, as shown in

Table 5. Results of the FJSPBC solved by the MILP model-based methods and the two heuristics. The results in bold and “–” indicate that optimal solutions have been obtained and no feasible solutions have been obtained within the time limit, respectively. The results are italicized when $R{D}_{FTS}$ is not 0.

Instance	$${\mathit{\Phi }}_{\mathit{m}}\mathbf{is}1–2$$						$${\mathit{\Phi }}_{\mathit{m}}\mathbf{is}2–4$$
	TI	FI [28]	$${\mathit{B}}_1\mathit{S}$$	$${\mathit{A}}_1\mathit{S}$$	$${\mathit{B}}_2\mathit{S}$$	$${\mathit{A}}_2\mathit{S}$$	TI	FI [28]	$${\mathit{B}}_1\mathit{S}$$	$${\mathit{A}}_1\mathit{S}$$	$${\mathit{B}}_2\mathit{S}$$	$${\mathit{A}}_2\mathit{S}$$
F_01	66	66	66	66	66	66	66	66	66	66	66	66
F_02	107	107	107	107	107	107	107	107	107	107	107	107
F_03	208	208	208	208	208	208	208	208	208	208	208	208
F_04	272	272	272	272	272	272	272	272	272	272	272	272
F_05	100	100	100	100	100	100	100	100	100	100	100	100
F_06	320	320	320	320	320	320	310	310	310	310	310	310
F_07	397	397	397	397	397	397	397	397	397	397	397	397
F_08	216	216	216	216	216	216	216	216	216	216	216	216
F_09	210	210	210	210	210	210	210	210	210	210	210	210
F_10	516	516	516	516	516	516	486	486	486	486	486	486
F_11	410	410	410	419	410	410	403	403	403	403	403	403
F_12	410	410	410	410	410	410	396	396	396	396	396	396
F_13	420	453	420	420	420	420	397	397	397	397	397	397
F_14	546	506	503	503	503	503	496	496	496	496	496	496
F_15	488	488	488	488	488	488	426	426	426	426	426	426
F_16	614	614	614	614	614	614	614	614	614	614	614	614
F_17	827	975	789	789	789	789	914	852	764	764	764	764
F_18	841	884	787	789	784	788	–	764	764	764	764	764
F_19	–	–	843	865	843	849	–	–	764	764	764	764
F_20	–	–	1005	1024	994	1001	–	–	944	954	944	947

. We define $R{D}_{FTS}$= (FI − TI)$/ \mathrm{TI} \times$100%, where TI and FI represent the results obtained from the 3-indexed and the 4-indexed model-based methods, respectively. Terms $B_{1}S$ and $B_{2}S$ are the best solutions obtained by LNSIT and by LNST in 20 runs. Terms $A_{1}S$ and $A_{2}S$ are the average solutions obtained by LNSIT and by LNST in 20 runs, respectively. When the capacity of machine is 1–2, the values of $R{D}_{FTS}$ of instances F_13, F_14, F_17, and F_18 are 7.86%, –7.33%, 17.90%, and 5.11%, respectively. When the capacity of machine is 2–4, the $R{D}_{FTS}$ of instance F_17 is –6.78%.

It can be seen from Table 5 that the TI model-based method and the FI model-based method obtain the optimal solutions for 24 instances out of the 40 instances. In addition, there are three instances where the feasible solution obtained by the TI model-based method is better than those obtained by FI model-based method, and the maximum relative deviation $R{D}_{FTS}$ reaches 17.90% in instance F_17. The average computational times for the TI and FI model-based methods to obtain a feasible solution for the set of instances F_ are 169 s and 183 s, respectively. The comparison results are shown in Figure 4, which shows the advantage of TI model-based method over the FI model-based method in solution quality and computational burden.

4.2.2. Results of the Proposed Heuristic Framework

The performance of the proposed LNSIT is compared with the MILP-based methods, as presented for the FJSPBC in Table 5, which shows that LNSIT can efficiently solve all instances in a short time. Among all instances, 24 instances can be solved to optimality within one hour by the MILP-based methods, and the LNSIT can obtain the optimal solutions as well. For the other instances, LNSIT can obtain better solutions in a shorter time. The results of the LNSIT and the LNST for solving the instances with different capacities and job families are shown in Table 5. We can see that the LNSIT and the LNST both obtain 24 optimal and 40 feasible solutions for 40 instances, respectively. In order to have a deeper insight of the optimal insertion strategy on the performance of the LNSIT, medium- and large-scale instances in NI_ are solved with these two methods.

The LNSIT and the LNST can always reach the optimum for six instances in

Table 6. Results of the instances solved by the heuristics with different batch capacities and job families. The results in bold and “–“ indicate that optimal solutions have been obtained and no feasible solution have been obtained within the time limit, respectively.

Instance	${\mathit{\Phi }}_{\mathit{m}} \mathbf{is} 1–2$					${\mathit{\Phi }}_{\mathit{m}} \mathbf{is} 2–4$
	TI	${\mathit{A}}_1\mathit{S}$	${\mathit{A}}_2\mathit{S}$	${\mathit{B}}_1\mathit{S}$	${\mathit{B}}_2\mathit{S}$	TI	${\mathit{A}}_1\mathit{S}$	${\mathit{A}}_2\mathit{S}$	${\mathit{B}}_1\mathit{S}$	${\mathit{B}}_2\mathit{S}$
NI_01	531	531	531	531	531	510	510	510	510	510
NI_02	–	714	710	685	688	–	625	619	618	618
NI_03	665	559	559	559	559	582	556	556	556	556
NI_04	285	285	285	285	285	285	285	285	285	285
NI_05	924	317	320	310	313	783	310	310	308	308
NI_06	218	218	218	218	218	218	218	218	218	218
NI_07	–	418	417	415	413	–	417	415	410	411
NI_08	–	539	550	523	524	–	491	502	476	486
NI_09	–	348	346	342	339	–	340	341	334	334

. For the best solutions, the LNSIT obtains better solutions for five instances, compared with those obtained by the LNST. In contrast, the LNST only obtains better solutions for two instances. Overall, the comparison results indicate that the average result of the instances solved by the LNSIT is slightly better than those solved by the LNST.

The standard deviations and the average computational times of the LNSIT and the LNST for all instances are shown in Figure 5 and Figure 6, respectively. The standard deviations in 20 out of 58 instances obtained by the LNSIT and the LNST are all zero. Figure 5 indicates the good stability of the two algorithms, and it can be seen from Figure 6 that the computational time of the LNSIT is much shorter than the LNST. Indeed, the average times of the LNSIT and the LNST for solving all instances are 56 s and 165 s, respectively. Overall, the results indicate that the LNSIT is better than the LNST in terms of solution quality and computational burden for most instances. This is mainly because the LNSIT only searches for parts of the available positions, which can find the optimal insertion position in one iteration, leading to an expedited solving process. The LNSIT has more significant advantages in the required computational time, which reflects the effectiveness of the optimal insertion strategy, especially for large-scale problems.

The numbers on the x-axis denote the scale of $nj$ × $no$, while F_ ($nm$) and NI_ ($nm$) denote the number of machines ($nm$) in the set of F_ instance’s and the set of NI_ instance’s configurations, respectively.

Table 7. Solutions obtained by the LNSIT and the TI model-based method for both sets of instances F_ and NI_ with incompatible jobs (Instance denotes as Ins in Table 7). The results in bold and “–“ indicate that optimal solutions have been obtained and no feasible solution have been obtained within the time limit, respectively.

Ins	Scale	2 Job Families				3 Job Families				4 Job Families
		${\mathit{\Phi }}_{\mathit{m}} \mathbf{is} 1–2$		${\mathit{\Phi }}_{\mathit{m}} \mathbf{is} 2–4$		${\mathit{\Phi }}_{\mathit{m}} \mathbf{is} 1–2$		${\mathit{\Phi }}_{\mathit{m}} \mathbf{is} 2–4$		${\mathit{\Phi }}_{\mathit{m}} \mathbf{is} 1–2$		${\mathit{\Phi }}_{\mathit{m}} \mathbf{is} 2–4$
		TI	${\mathit{B}}_1\mathit{S}$	TI	${\mathit{B}}_1\mathit{S}$	TI	${\mathit{B}}_1\mathit{S}$	TI	${\mathit{B}}_1\mathit{S}$	TI	${\mathit{B}}_1\mathit{S}$	TI	${\mathit{B}}_1\mathit{S}$
F_01	2/2/2	66	66	66	66
F_02	2/2/2	107	107	107	107
F_03	3/2/2	208	208	208	208	221	221	221	221
F_04	3/2/2	277	277	277	277	355	355	355	355
F_05	3/2/2	107	107	100	100	119	119	119	119
F_06	3/2/3	320	320	310	310	320	320	320	320
F_07	3/5/3	397	397	397	397	397	397	397	397
F_08	3/4/3	216	216	216	216	253	253	253	253
F_09	3/3/3	210	210	210	210	210	210	210	210
F_10	4/5/3	516	516	516	516	516	516	516	516	516	516	516	516
F_11	5/6/3	415	425	415	415	453	460	420	420	465	465	465	465
F_12	5/7/3	419	419	419	419	419	419	419	419	446	446	423	423
F_13	6/7/3	460	460	446	454	457	457	413	420	459	466	468	459
F_14	7/7/3	527	527	503	503	568	527	517	503	561	554	503	527
F_15	7/7/3	514	514	484	484	513	513	469	469	519	514	483	473
F_16	8/7/3	615	614	614	614	614	614	614	614	634	614	614	614
F_17	8/7/4	–	814	808	784	936	809	–	789	–	871	–	809
F_18	9/8/4	–	827	799	789	–	834	–	819	–	827	–	830
F_19	11/8/4	–	910	–	822	–	996	–	991	–	1004	–	986
F_20	12/8/4	–	1102	–	1020	–	1149	–	1072	–	1171	–	1118
NI_01	5/5/9	535	531	531	531	571	531	–	531	531	531	531	531
NI_02	5/5/10	–	685	–	660	–	694	–	650	–	694	–	694
NI_03	5/5/10	–	559	–	556	–	559	–	559	–	559	–	556
NI_04	5/5/9	285	285	285	285	285	285	285	285	285	285	285	285
NI_05	5/5/10	–	310	–	315	–	317	–	311	–	313	–	313
NI_06	5/5/6	218	218	218	218	218	218	218	218	218	218	218	218
NI_07	5/5/15	–	414	–	413	–	413	–	415	–	415	–	414
NI_08	10/5/10	–	519	–	513	–	542	–	524	–	543	–	538
NI_09	10/10/15	–	340	–	333	–	341	–	339	–	339	–	337

shows the results obtained by the LNSIT and TI model-based method for 152 F_ and NI_ instances while considering the incompatibility of jobs. The blank in Table 7 represents that the number of jobs is less than the number of specified job families. The jobs in instances F_01–F_02 and F_03–F_09 can only be divided into two and three job families, respectively. Symbol “–” means that a feasible solution cannot be found within an hour. Job families are recorded as 2C, 3C, and 4C when jobs are divided into two, three, and four job families, respectively. As shown in Table 7, 75 out of the 152 instances have the same objective value achieved by the LNSIT and the TI model-based method, and 50 instances have been solved with optimal solutions. For feasible solutions obtained by the two methods, the LNSIT obtains better solutions for 13 instances, compared with those obtained by the TI model-based method. In contrast, the TI model-based method only obtains better solutions for six instances. All instances can still be solved with feasible solutions by the LNSIT in a relatively short time, while the TI model-based method cannot find feasible solutions for 58 instances.

Figure 7 and Figure 8 show that the average relative deviation of the two sets of instances $R{D}_{T{B}_{1}S}$= (TI − $B_{1}S$) $/ B_{1}S\times$100% by the TI model-based method and the LNSIT is 41.02%. These results suggest that the performance of the LNSIT is better than the TI model-based method for a FJSP with incompatible jobs.

Figure 9 and Figure 10 show the computational times of the two methods for solving instances with different numbers of job families. In general, the computational times of the two methods for small-scale instances are comparable. The results for medium- and large-scale instances indicate that the LNSIT can achieve better results than the TI model-based method within a shorter time.

Figure 11 and Figure 12 show the standard deviations of the results for all instances obtained by the LNSIT. The standard deviations in 75 out of 152 instances and in 152 instances are 0 and 4.24, respectively, which indicates that the LNSIT has much better stability.

4.2.3. Impacts of Batch Capacity and Incompatibility Rate

(i) Two methods for solving instances of different batch capacities

In Table 5, Table 6 and Table 7, there are 105 instances when the number of job families changes from one to four. The TI model reaches the optimum for 35 instances in both scenarios, and feasible solutions can be obtained for 70 and 69 instances when the batch capacity is 1–2 and 2–4, respectively. In Figure 13, the average computational times of the optimal solution obtained by the TI model-based method are 246.6 s and 73.4 s, respectively. Additionally, in these instances, the LNSIT reaches the optimal solutions for 35 instances in both scenarios, and the average computational times of these instances are 2.9 s and 3.4 s when the capacity is 1–2 and 2–4, respectively.

In Table 5, Table 6 and Table 7, when the batch capacity increases from 1–2 to 2–4, the objective values corresponding to the optimal solutions of 3 instances drop, while the values remain unchanged for 31 instances. This is because the number of jobs that can be processed in a batch may increase or remain unchanged when the batch capacity increases, and the completion time of the batch that determines the makespan may be earlier or unchanged. For instances that can be solved to optimality, the average computational time of the two methods decreases with an increase in the capacity. This is because when the capacity is 2–4, the solution is equivalent to the lower bound of the solution when the capacity is 1–2.

(ii) Two methods for solving instances with different incompatibility rates

In Table 5, Table 6 and Table 7, when the number of job families is one, two, three, and four, the percentage of the attested optimal solutions obtained by the TI model-based method for all instances is 41.4%, 39.7%, 37.0%, and 17.5%, respectively, and the corresponding percentages of the LNSIT are the same. It indicates that the proportion of optimal solutions solved by the two methods drops as the number of job families increases. The proportion of feasible solutions solved by the TI model-based method is 77.6%, 69.0%, 63.0%, and 50.0%, respectively. The percentages of feasible solutions obtained decrease with the increase in the number of job families. For both methods with two different batch capacities, the objective values corresponding to the optimal solutions of three instances drop as the number of job families rises, and the values remain unchanged for four instances. In Figure 13, the average computational times of the optimal solutions acquired by the TI model-based method are 100.7 s, 29.3 s, 200.1 s, and 356.7 s, respectively. Meanwhile, the average computational times of the optimal solutions obtained by the LNSIT are 1.8 s, 2.8 s, 3.5 s, and 6.6 s, respectively. Generally, the FJSPBI becomes more difficult to solve as the number of job families increases.

4.2.4. The Impact of Instance Scales

In Table 7, there are 18 instances in the three sets of medium-scale instances NI_04 –NI_06 and in the three sets of large-scale instances NI_07–NI_09, with three different batch capacities and two job families. The numerical results show that the LNSIT can reach the optimum for 12 out of 18 instances, which are attested by the TI model-based method. For the other instances that cannot be solved by the TI model-based method within the time limit, the LNSIT can always achieve feasible solutions in a reasonable time. The average computational times of the optimal solution in NI_04 and NI_06 obtained by the TI model-based method and by the LNSIT are shown in Figure 14. A comparison of the computational times is presented in Figure 9 and Figure 10, which show that the average computational times of the two sets of instances NI_04 and NI_06 that can be optimally solved by the TI model-based method and the LNSIT are 311.5 s and 7.5 s, respectively. These results further confirm that the LNSIT is less affected by increased scales of instances, showing that the LNSIT is more advantageous for solving large-scale instances within a reasonable time.

4.2.5. Influence of Machine Processing Rate

In Table 7, there are 18 instances in the three sets of instances NI_02, NI_03, and NI_05 with $nj/nm/no=$5/5/10, considering different batch capacities and numbers of job families, and the probability ${\rho }_2$ that the machines can process each operation is 0.2, 0.2, and 0.8, respectively. Table 7 shows that the LNSIT obtains 18 feasible solutions in the three sets of instances which cannot be solved by the TI model-based method within the time limit. A comparison of the computational times of the TI model-based method and the LNSIT is presented in Figure 9 and Figure 10, which show that the average computational time of the LNSIT for those instances whose machine processing rate is 0.2 (two sets of instances NI_02 and NI_03) and 0.8 (set of instances NI_05) is 10.1 s and 47.0 s, respectively. The comparison results indicate that the computational time of the LNSIT increases with an increase in ${\rho }_2$. It can be attributed to the fact that there are more capable machines, which increases the solution space.

The results indicate that the number of optimal and feasible solutions obtained by the two methods increases or remains with an increase in ${\rho }_2$. However, the computational time of the TI model-based method is unchanged because it cannot obtain feasible solutions for large-scale instances within the time limit.

5. Conclusions

This paper studied the flexible job-shop batch scheduling problem with incompatible jobs. A 3-indexed model is proposed to optimally solve the problem, and a perturbation-based LNSIT is embedded for solving large-scale FJSPBI problems effectively. The tabu-based worst removal operator is proposed to improve the performance of the algorithm and the optimal insertion-based deep greedy repair operator is incorporated to speed up the solving process. The perturbation mechanism diversifies the insertion positions. Numerous FJSPBC and FJSPBI instances were generated to test the proposed model and algorithm, and the results were compared with existing methods.

The results indicate that the 3-indexed model-based method can optimally solve small-scale instances of FJSPBC and FJSPBI in a short time, while it is difficult to obtain optimal or feasible solutions within an hour for medium- and large-scale instances. In contrast, the LNSIT can obtain high-quality solutions of different scales of instances in a reasonable time. The comparison between the LNSIT and the LNST indicates that the optimal insertion strategy proposed in this paper can greatly reduce computational time without damaging the overall solution quality. By analyzing the influence of problem characteristics on the efficiency of the algorithms, we can conclude that the numbers of optimal solutions obtained by the LNSIT and the TI model-based method increases with an increase in batch capacities. The number of optimal solutions decreases and the optimal objective value decreases or remains the same with an increase in the number of job families. For instance, when the optimal solution is obtained, the average computational times of the LNSIT and the TI model-based method decrease with an increase in instance scale. The efficacy of solving the FJSPBI by the two methods is mostly affected by the batch capacity, the incompatibility rate, and the instance scale. When other problem characteristics are the same, the LNSIT and the TI model-based method are mainly affected by the machine processing rate and the instance scale, respectively. In general, the standard deviation of the LNSIT is small, and its average computational times are much shorter than those of the TI model-based method. Therefore, the proposed LNSIT is more efficient in solving problems with a larger batch capacity, a larger scale of instances, and a higher machine processing rate.

In the future, strategies such as column generation can be designed to speed up the solving process of the exact algorithms. Different sizes of jobs and release times of jobs can be considered, and random programming and robust optimization models can be constructed to tackle uncertainties in the problem.