Arc Flow Formulation for Efficient Uniform Parallel Machine Scheduling

Abstract

This paper considers the scheduling problem of uniform parallel machines. The objective is to minimize the makespan. This problem holds practical significance and is inherently NP-hard. Therefore, solutions of the exact formulation are limited to small-sized instances. As the problem size increases, the exact formulation struggles to find optimal solutions within a reasonable time. To address this challenge, an arc flow formulation is proposed, aiming to solve larger instances. The arc flow formulation creates a pseudo-polynomial number of variables, with its size being significantly influenced by the problem’s bounds. Therefore, bounds from the literature are utilized, and symmetry-breaking rules are applied to reduce the size of the arc flow graph. To test the effectiveness of the proposed arc flow formulation, it was compared with a mathematical formulation from the literature on small instances with up to 30 jobs. Computational results showed that the arc flow formulation outperforms the mathematical formulation from the literature, solving all cases within a few seconds. Additionally, on larger benchmark instances, the arc flow formulation solved 84.27% of the cases to optimality. The maximum optimality gap does not exceed 0.072% for the instances not solved to optimality.

1. Introduction

The manufacturing industry faces increasing pressure to optimize operations, reduce costs, and minimize environmental impact. Effective scheduling is crucial to addressing these challenges by optimizing resource allocation and production efficiency. Given the industry’s significant energy consumption [1], particularly in regions like China, where it accounts for approximately 70% of total emissions [2], scheduling also plays a vital role in enhancing energy efficiency.

This paper addresses the uniform parallel machine scheduling problem, aimed at minimizing makespan. This problem is denoted as Q||C_max, in Graham’s three-field notation [3]. In the uniform parallel machine, a set of machines M = {1, 2, …, m, …, w}, which may differ in their processing speed vm_m, is used to schedule a set of n independent jobs J = {1, 2, …, j, …, n}. The machines are ordered by increasing speed such that ${vm}_1\le {vm}_2\le \cdots \le {vm}_m\le \cdots \le {vm}_w$, where machine 1 is the slowest and machine w is the fastest.

Each job $j\in J$ has a processing time, defined based on the slowest machine (i.e., machine 1). The jobs are ordered in non-increasing order of processing times, i.e., $p_1\ge p_2\ge \cdots \ge p_n$. The processing time of job j on machine m is then computed as

$$p_{mj}={\displaystyle \frac{p_j}{{vm}_m}} \forall m\in M;\forall j\in J$$

(1)

Accordingly, the machine speed ${vm}_m$ can be computed from any job j, assuming j = 1, as

$${vm}_m={\displaystyle \frac{p_1}{p_{m1}}} \forall m\in M$$

(2)

Alternatively, if the processing times p_j are defined based on the fastest machine (i.e., machine w), the processing times of each job j on machine m can be expressed using a slowness factor ${Sm}_m\ge 1$, which represents how much slower machine m is compared to the fastest machine w. In this case,

$$p_{mj}={Sm}_m\times p_j \forall m\in M;\forall j\in J$$

(3)

Here, the slowness factor satisfies ${Sm}_w=1$ and ${Sm}_m\ge 1 \forall m\in M$.

Each job is assumed to be available at the beginning of scheduling, and no preemption is allowed.

Minimizing makespan in the Q||C_max problem is a fundamental challenge in operations research with significant applications across various industries where machines have different processing capabilities [4]. Its inherent computational complexity classifies it as NP-hard [5], making the development of exact solution methods particularly challenging for solving larger problem sizes. While heuristic and metaheuristic approaches have been widely explored to obtain near-optimal solutions, the pursuit of exact algorithms remains crucial for obtaining provably optimal schedules. This paper develops an exact solution approach by proposing a novel adaptation of arc flow formulation, originally developed for the identical parallel machine scheduling problem [6,7], to address the uniform parallel machine scheduling problem. By leveraging the strengths of arc flow modeling, we aim to tackle the computational challenges associated with this NP-hard problem.

The following sections of this paper are as follows: Section 2 provides a review of the relevant literature on uniform parallel machine scheduling. The methodology proposed for solving the problem is detailed in Section 3. Section 4 discusses the computational results of the proposed approach. Finally, Section 5 provides a conclusion and suggestions for future work.

2. Literature Review

The scheduling problem of uniform parallel machines involves assigning a set of independent jobs to a group of parallel machines with different speeds to minimize the makespan. This problem is NP-hard [5], implying that achieving optimality for large-scale instances is computationally intractable. While heuristic and metaheuristic algorithms can produce solutions relatively quickly, their ability to guarantee optimal solutions is limited. Consequently, there is a continued need for an effective exact formulation capable of optimally solving larger problem instances.

The longest processing time (LPT) rule is a fundamental and simple heuristic for identical parallel machine scheduling. Introduced by Graham [8], it prioritizes jobs based on their longer processing times, assigning each job to the least loaded machine. For uniform parallel machines, the LPT rule is adapted to consider machine speeds. Jobs are sorted in descending order of processing times, and each job is assigned to a machine that completes it earlier [9].

Despite its simplicity, the LPT rule has limitations in terms of solution quality. For identical parallel machines, Graham [8] established a worst-case bound of 4/3 − 1/3w. Subsequent research by Della Croce and Scatamacchia [10] improved upon this bound to (4/3 − 1/(3(w − 1))) when the total number of machines $\left(w\right)\ge 3$. In the context of uniform machines, a worst-case bound for the adapted LPT rule is no more than twice the optimal solution, as demonstrated by Gonzalez et al. [9]. Friesen [11] improved the worst-case ratio to be within (1.52, 1.67). Moreover, other studies have investigated the LPT rule, resulting in various performance bounds for different machine configurations [12,13,14,15].

Beyond the LPT rule, various heuristics have addressed makespan minimization in uniform parallel machine scheduling. Li and Zhang [16] introduced the LPT-LRD rule, which prioritizes jobs based on a combination of the LPT rule and the largest release date. The authors further enhance the solution quality by developing a variable neighborhood search algorithm. Sivasankaran et al. [17] developed a heuristic method and assessed its efficiency against a mathematical model on small instances. Li and Yang [18] addressed the uniform parallel machine scheduling with heads and tails and a makespan objective, developing heuristic algorithms to solve it. De Giovanni et al. [19] focused on modifying the LPT rule and combined it with an iterated local search algorithm. Song et al. [20] extended the problem to a green manufacturing context, incorporating energy consumption constraints. They aimed to minimize two objectives, namely the makespan and the maximum job lateness, while adhering to an energy budget.

To obtain better solutions, metaheuristics often enhance heuristic solutions by exploring a wider solution space and escaping local optima, leading to improved overall performance. Senthilkumar and Narayanan [21] compared various genetic algorithms and simulated annealing approaches for the uniform parallel machine scheduling problem. Balin [22] studied the makespan minimization in non-identical parallel machine scheduling and introduced a genetic algorithm (GA), which was evaluated on a small-scale instance involving four machines and nine jobs. Building upon this work, Noman et al. [23] introduced a tabu search (TS) algorithm and compared its performance with Balin’s GA [22] using the same example. Recently, Bamatraf and Gharbi [24] introduced two variants of a variable neighborhood search (VNS) algorithm differentiated by their initial solution generation strategy for Q| |C_max. The VNS algorithm was compared with the GA [22] and TS [23] algorithms from the literature, demonstrating competitive performance. Additionally, the two versions of the VNS algorithms were evaluated on randomly generated instances with larger problem sizes, comparing their performance to optimal solutions for smaller problems and a lower bound for larger ones. The results demonstrated that one version of the VNS achieved the optimal solutions for 90.19% of the small instances, with an average gap of approximately 0.15% compared to the lower bound for larger problem sizes.

As mentioned earlier, due to the NP-hard nature of the Q||C_max scheduling problem, the development of exact algorithms is particularly challenging. However, it is still applied to achieve optimal solutions for small to medium-sized instances. As the problem size increases, the time required to obtain an optimal solution remains a computational challenge. Therefore, researchers attempt to develop exact algorithms capable of solving larger instances. Among the researchers who developed exact formulations for this problem, Horowitz and Sahni [25] employed dynamic programming followed by De and Morton’s [26] mathematical formulation and branch and bound algorithm, which was effective for small-scale instances. Liao and Lin [27] proposed an optimal algorithm for this problem with only two uniform parallel machines and tested it on instances with up to 1000 jobs. Building upon this, Lin and Liao [28] extended the optimal algorithm to be capable of solving multiple uniform parallel machines, incorporating techniques to identify quasi-optimal solutions, improve the lower bound, and accelerate the search process. Their algorithm was evaluated on instances with three to five machines and a maximum of 1000 jobs. Other researches include Popenko et al.’s [29] optimality sufficient condition, Berndt et al.’s [30] improved integer linear program (ILP) bounds for faster approximation algorithm, and Mallek and Boudhar’s [31] mixed-integer linear program (MILP) formulation for uniform parallel machines with conflict graphs. For further studies on parallel machine scheduling, consider exploring the works cited in references [32,33].

In recent years, an arc flow model that enables establishing pseudo-polynomial variables and constraints has emerged as a valuable tool for solving classical optimization problems. It has been successfully implemented in solving various optimization problems, such as a cutting stock problem [34], a bin packing problem [35], and a two-dimensional strip-cutting problem [36]. In the field of scheduling, the work of Mrad and Souayah [6] introduced an arc flow formulation for minimizing the makespan in identical parallel machine scheduling. Their proposed arc flow model significantly outperformed existing methods, efficiently solving the most challenging benchmark instances to optimality within seconds. However, the arc flow model struggles to achieve optimality for some instances within the time limit, particularly those with a relatively larger number of jobs and a job-to-machine ratio of at least 2.25. Recently, Gharbi and Bamatraf [7] improved the arc flow formulation presented by Mrad and Souayah [6] by proposing a variable neighborhood search algorithm to provide an upper bound, utilizing three lower bounds from existing literature, and applying a method to minimize the graph’s size. Computational results on the instances generated by Mrad and Souayah [6] showed the outperformance of the improved arc flow formulation over the arc flow formulation proposed by Mrad and Souayah [6] in finding the optimal solution for 99.97% of the instances and achieving an 87% reduction in CPU time. Other research on scheduling problems that applied arc flow formulation includes minimizing the total weighted completion time for the identical parallel machine scheduling [37], and it is extended to include release times [38]. Additionally, the arc flow formulation has been applied to single and parallel batch-processing machine scheduling with unequal sizes of jobs and capacities of machines [39,40].

From the literature, we have noticed that mathematical formulations such as the formulation proposed by De and Morton [26] for the Q||Cmax problem provide an optimal solution for small instances. As the problem size increases, this mathematical model struggles to find the optimal solution within a reasonable computational time due to the rapid growth of the number of variables and constraints. This scalability limitation highlights the need for an efficient mathematical formulation capable of solving larger instances.

To address this gap, this study extends the applicability of the arc flow formulation to the uniform parallel machine scheduling problem, aiming to improve scalability and solution efficiency. The proposed arc flow formulation applied tight bounds and symmetry-breaking rules to reduce the number of variables in the arc flow model, thereby enhancing scalability and allowing the arc flow formulation to solve larger instances efficiently.

Unlike the arc flow for identical parallel machine scheduling, where a single graph is constructed to represent all machines, the proposed arc flow model constructs a separate graph for each machine. In the proposed arc flow formulation, the bounds for the problem are utilized from the literature, and a novel arc reduction technique was proposed. This technique identifies the minimum completion time on each machine and prevents the creation of job arcs whose cumulative processing times are insufficient to reach this minimum completion time threshold.

The combination of this graph reduction technique, along with symmetry-breaking rules and the proposed bounds, allows for a reduction in the arcs of the constructed graph, thereby enhancing scalability and computational performance.

To summarize, the uniform parallel machine scheduling problem has many applications in industries. The proposed arc flow formulation offers solutions for optimizing resource allocation and minimizing the makespan. It also serves as a benchmark for evaluating the performance of heuristic and metaheuristic algorithms for real-world scheduling scenarios.

3. Research Methodology

To solve the uniform parallel machine scheduling problem with the makespan objective using an arc flow formulation, the following methodological steps are proposed:

(1)

Calculate the bounds of the problem.

(2)

Construct a graph for the arc flow model.

(3)

Develop a mathematical formulation for the constructed graph and present a mathematical formulation from the literature.

(4)

Implement the bounding algorithms and mathematical formulations using an optimization solver.

(5)

Validate the arc flow model on a numerical example

(6)

Evaluate the performance of the arc flow formulation against a mathematical formulation from the literature and a lower bound on randomly generated instances.

(7)

Analyze the computational results.

Efficient bounds play a crucial role in improving the performance of the arc flow model. This was obvious in the performance of the improved arc flow model proposed by Gharbi and Bamatraf [7] compared to the arc flow model proposed by Mrad and Souayah [6]. Therefore, in step 1, we calculate three lower bounds from the literature and select the best one. Additionally, the variable neighborhood search (VNS) algorithm proposed by Bamatraf and Gharbi [24] is utilized as an upper bound.

In the second step, a graph consisting of arcs and nodes is constructed, where each machine has its own graph. In these graphs, each arc represents the potential start and end times for jobs on each machine. In the arc flow graph, we provide symmetry-breaking rules and an equation to determine the minimum completion time for each machine, enabling us to further reduce the graph size by omitting arcs that end before this time.

Following this, in the third step, we provide the mathematical formulation of the arc flow model. Then we present a mathematical formulation from the literature [26] that is used to evaluate the performance of the arc flow model.

In the fourth step, the bounding algorithms and the mathematical formulation are implemented in C++ with the optimization library of Cplex 12.10.

In the fifth step, a numerical example is presented to illustrate and validate the graph construction process.

In the sixth step, the performance of the arc flow formulation is evaluated against the mathematical formulation by De and Morton [26] on small-sized problems with up to 30 jobs. For larger instances, we only test the performance of the arc flow formulation against the lower bound.

Finally, in the seventh step, an analysis of the computational results is presented and discussed.

The following subsections detail the lower bounds applied, the graph construction of the arc flow model, the mathematical formulations, and the numerical example.

3.1. Definition of the Problem Bounds

3.1.1. Lower Bounds

This paper utilizes three different lower bounds. The first lower bound (LB₁) assumes the workload is balanced among all machines and is equal to the sum of the jobs’ processing times of the slowest machine ($Tp=\sum _{j=1}^n{p}_{1j}$) divided by the total speeds of the machines ($Tvm=\sum _{m=1}^w{vm}_m$), assuming the first machine to be the slowest. LB₁ is illustrated as follows:

$${LB}_1={\displaystyle \frac{Tp}{Tvm}}$$

(4)

The other bound of the problem, denoted by LB₂, represents the longest processing time required by a job when assigned to the fastest machine, as illustrated in Equation (5) as follows:

$${LB}_2=p_{w1}$$

(5)

The third lower bound (LB₃), as presented by Lin and Liao [28], is an attempt to improve LB₁ using quasi-optimal allocations. The authors determined an upper bound (C_LPT) from the LPT schedule. Then, they determined each machine’s maximum workloads (${wi}_m$) that limit the final job’s completion time to LB₁, such that

$${wi}_m=⌊{vm}_m\times {LB}_1⌋ \forall m\in \left\{1,\dots ,w\right\}$$

(6)

After that, the authors identified the quasi-optimal solutions $\left(q_m\right)$ by assigning workloads to each machine without exceeding C_LPT, such that

$$q_m=⌊{vm}_m\times C_{LPT}⌋-{wi}_m \forall m\in \left\{1,\dots ,w\right\}$$

(7)

Then, they calculated the possible quasi-optimal solutions ($C_{mu}$) as follows:

$$C_{mu}={\displaystyle \frac{{wi}_m+u}{{vm}_m}} \forall m\in \left\{1,\dots ,w\right\}; \forall u\in \{1,\dots ,q_m\}$$

(8)

The improved lower bound was then found by sorting these solutions along with LB₁ in increasing order and selecting the one at position Tp-WL, where WL is the total assigned workload.

From the above-mentioned lower bounds, the maximum lower bound is considered the best, as follows:

$$LB=\mathrm{m}\mathrm{a}\mathrm{x}({LB}_1,{LB}_2,{LB}_3)$$

(9)

3.1.2. Upper Bound

Having established the lower bounds, we now turn our attention to the upper bound. This study employs the VNS algorithm, which was proposed by Bamatraf and Gharbi [24], as the upper bound. For reproducibility, we describe the VNS algorithm.

The VNS algorithm starts with an initial solution generated by the longest processing time (LPT) rule. The algorithm then iteratively explores five neighborhood structures to search for better solutions from the current best schedule. These neighborhood structures are applied to two sets of machines: problem machines S_pm (those with completion time equal to the makespan) and non-problem machines S_npm (the remaining machines).

These neighborhood structures are as follows:

(1)

Move: Move a job from a machine in S_pm to a machine in S_npm.

(2)

Exchange (1-1): Exchange one job from a machine in S_pm with one job from a machine in S_npm.

(3)

Exchange (2-1): Exchange two jobs from a machine in S_pm with one job from a machine in S_npm.

(4)

Exchange (1-2): Exchange one job from a machine in S_pm with two jobs from a machine in S_npm.

(5)

Exchange (2-2): Exchange two jobs from a machine in S_pm with two jobs from a machine in S_npm.

The proposed neighborhood structures attempt to alter the current schedule to reduce the completion time of problem machines. Starting from the first neighborhood structure (k = 1), if there is an improvement in makespan when applying a neighborhood structure, the makespan and both the problem and non-problem machines are updated, and the search restarts from the first neighborhood structure. However, if there is no improvement, the search proceeds to the next neighborhood structure (k + 1).

The algorithm terminates under three conditions: (1) it finds a solution with a makespan equal to the lower bound, (2) when no further improvements can be made by these neighborhood structures, (3) all machines have the same completion time. The steps of the VNS algorithm are presented in Algorithm 1, and for more details about the VNS algorithm, the reader is referred to the work of Bamatraf and Gharbi [24].

Algorithm 1: VNS algorithm for uniform parallel machine scheduling.

Initialize: Maximum number of iterations (MaxIter)←1, Maximum number of neighborhood structures (kmax)←5, Best makespan (mksp), Best lower bound (LB), i←0, Upper bound (UB) For (i = 0; i < MaxIter; i++) do        Generate an initial schedule (S) using the LPT rule and compute the makespan (Makspan(S))        mksp = Makespan(S)        If (mksp = LB)                      Break. //Exit out of the loop “for(i = 0; i < MaxIter; i++)”        Else:                      Create one list for machines with makespan equal makespan (S_pm[]) and another list for the remaining machines (S_npm[]).                      Initialize r←0 and q←0                      While (r < size of S_pm & Makespan(S) ! = LB) do                             While (q < size of S_npm & Makespan(S) ! = LB) do                                     Initialize: pm1 = S_pm[r], npm1 = S_npm[q], k = 0                                     While (k < kmax) do                                          Apply neighborhood structure k for pm1 and npm1 to get a new schedule (S’)                                          If (Makespn(S’) < Makespan(S))                                               Update: S←S’, S_pm[], S_npm[], and mksp = Makesapn(S)                                               If (size of S_npm! = 0 & mksp! = LB)                                                     Initialize: r,q,k = 0, pm1 = S_pm[r], and npm1 = S_npm[q]                                               Else: Break. //Exit out of the loop “While (k < kmax)”                                          Else: k←k + 1                                     End-while                                     q←q + 1                             End-while                             r←r + 1                      End-while        End-for output: UB←mksp.

3.2. Graph Construction

To create the graph of the arc flow model for minimizing the makespan in the uniform parallel machine scheduling problem (Q| |C_max), a graph is established for each machine with several disjoint arcs for each job. The arcs A and vertices V define each graph G, G = (V, A). Each vertex $v\in V$ represents the start or end time of a job, $v\in \{0,\dots ,UB\}$, whereas the set of arcs A is a combination of both job arcs (A_j), where j = {1,…,n}, and loss arcs (A₀), i.e., $A=A_j\cup A_0$. Each arc of a job j (A_j) represents the job starting and ending processing times at vertices v₁ and v₂, respectively. Therefore, the processing time for each job j on each machine m is p_mj = v₂ − v₁. On the other hand, for each machine m, each loss arc (A₀) starts from each candidate vertex to the vertex with the maximum completion time on that machine (MaxV_m). The procedures for graph construction are illustrated in Algorithm 2 and visually explained in a flowchart in Figure 1.

Algorithm 2: Graph construction for the arc flow model.

Initialize: V [0,…,w − 1][0,…UB]$\leftarrow \varphi$, NewV [0,…,w − 1][]$\leftarrow \varphi$, $A_j\leftarrow \varphi$, $A_0\leftarrow \varphi$, JobArcs$\leftarrow 0$, LossArcs$\leftarrow 0$ and TotalArcs$\leftarrow 0$. For $m\leftarrow 0$ to $w-1$ do // Loop through each machine.        V[m][0]$\leftarrow 1$        MinV[m] $\leftarrow {\displaystyle \frac{Tp-\left(Tvm-{vm}_m\right)\times UB}{{vm}_m}}$ End for CumP[n−1]$\leftarrow$p [0][n−1]; For $j\leftarrow n-2$ down to $0$ do // Loop through jobs from index n−2 to index 0.          CumP[j]$\leftarrow$CumP[j + 1]+p [0][j]; End for For $m\leftarrow 0$ to $w-1$ do        For $j\leftarrow 0$ to $n-1$ do // Loop through each job.                 $NewVertices[ ]\leftarrow \varphi$                 For $v\leftarrow 0$ to $sizeof\left(V\left[m\right]\right)-1$ do // Loop through each added vertex.                           If(V[m][v]= 1 AND $v+p\left[m\right]\left[j\right]\le UB$ AND $v+{\displaystyle \frac{CumP\left[j\right]}{vm\left[m\right]}}\ge MinV\left[m\right]$                                     $A_j\leftarrow A_j\cup (v,v+p\left[m\right]\left[j\right], j,m)$                                     $NewVertices\leftarrow NewVertices\cup (v+p\left[m\right]\left[j\right])$                                     JobArcs$\leftarrow JobArcs+1$                           End if                 End for                 For $v\leftarrow 0$ $\mathrm{t}\mathrm{o}$ $sizeof\left(NewVertices\right)-1\mathrm{d}\mathrm{o}$ // Loop through the new vertices.                        $V\left[m\right]\left[NewVertices\left[v\right]\right]\leftarrow 1$                 End for        End for End for For $m\leftarrow 0$ to $w-1$ do        For $v\leftarrow 0$ to $sizeof\left(V\left[m\right]\right)-1$ do                 If(V[m][v] = 1)                        $NewV\left[m\right]\leftarrow NewV\left[m\right]\cup V\left[m\right]\left[v\right]$                 End if        End for End for For $m\leftarrow 0$ to $w-1$ do        For $v\leftarrow 1$ to $sizeof\left(NewV\left[m\right]\right)-1$ do // Loop through the vertices of the graph.                 If($NewV\left[m\right]\left[v\right]\ge MinV\left[m\right]$                         $A_0\leftarrow A_0\cup (v,NewV[m\left]\right[sizeof\left(NewV\left[m\right]\right)-1], -1,m)$                         $LossArcs\leftarrow LossArcs+1$                 End if        End for End for $TotalArcs\leftarrow JobArc+LossArcs$

In constructing the graph, the job arcs and loss arcs are characterized by four terms, namely a starting time at vertex v₁, an ending time at vertex v₂, a job index j, and a machine index m, such that

$$A_j=\{\left(v_1,v_2,j,m\right):0<v_1<v_2\le UB, v_2-v_1=p_{mj}\}$$

(10)

$$A_0=\{\left(v_1,v_2,-1,m\right): v_1\in V\backslash \{0\}, v_2={MaxV}_m\}$$

(11)

The job arcs ($A_j$) were constructed by establishing a directed arc for each machine m that connects two vertices $v_1$ and $v_2$ given that $v_2>v_1$ if $p_{mj}=v_2-v_1$ and $v_2$ does not exceed the upper bound, i.e., $v_2\le UB$. These job arcs ($A_j$) can be reduced through several ways as follows:

• High-quality upper bound:

A tight upper bound obtained by the VNS algorithm proposed by Bamatraf and Gharbi [24] is used to limit the range of completion times, thereby preventing the establishment of job arcs that would exceed this bound. As a result, the number of vertices and arcs in a graph will be reduced, and the solver’s computational efficiency will be improved.

2.

Symmetry-breaking rule:

To eliminate redundant solutions, symmetry-breaking rules are applied during graph construction. These symmetry-breaking rules, as proposed by Mrad and Souayah [6], are as follows:

• Jobs are listed from longest to shortest processing times.
• A job arc ($A_j$) is created only from vertex 0 or from vertices created by other jobs.

3.

Minimum completion time on each machine:

In addition to the above symmetry-breaking rules, we propose a method to further reduce the number of job arcs and vertices of the graph by identifying the potential arcs of jobs to be established from each created vertex. This involves calculating the cumulative processing time for each job j on the slowest machine (denoted as CumP_j), starting from the job with the minimum processing time and ending with the job with the maximum processing time.

Next, we determine the minimum completion time (MinV_m) for each machine, ensuring that the lower bound of the remaining processing times on the remaining machines is no more than the upper bound. To find the minimum completion time (MinV_m) for each machine m, we exclude that machine from the calculation of the lower bound (LB₁) by subtracting its minimum completion time (${MinV}_m\times {vm}_m$) and its speed from the total processing time (Tp) and the total speeds (Tvm), respectively. Thus, MinV_m is the minimum value that makes the obtained lower bound not exceed the upper bound, as illustrated in the following equation:

$${\displaystyle \frac{Tp-{MinV}_m\times {vm}_m}{Tvm-{vm}_m}}\le UB \forall m\in \{1,\dots ,w\}$$

(12)

Rearranging this equation, we get the following expression for MinV_m:

$${MinV}_m\ge {\displaystyle \frac{Tp-\left(Tvm-{vm}_m\right)\times UB}{{vm}_m}} \forall m\in \{1,\dots ,w\}$$

(13)

Then, for each graph of a machine m, an arc of job j is established from vertex v₁ if v₁ is previously created on the graph, and the following equations are satisfied:

$$v_1+p_{mj}\le UB; \forall m\in \left\{1,\dots ,w\right\};\forall j\in \{1,\dots ,n\}$$

(14)

$$v_1+{\displaystyle \frac{{CumP}_j}{{vm}_m}}\ge {MinV}_m; \forall m\in \{1,\dots ,w\};\forall j\in \{1,\dots ,n\}$$

(15)

The loss arcs (A₀) are only created from vertices between the vertex MinV_m and the vertex immediately preceding the maximum vertex on each machine, directed toward the vertex with the maximum completion time on that machine.

3.3. Mathematical Formulation

This section introduces the mathematical formulation of the proposed arc flow model for Q| |C_max and reviews the existing formulation by De and Morton [26] for the same scheduling environment.

3.3.1. Mathematical Formulation of the Arc Flow Model

To present a mathematical formulation for the graph of the arc flow model,

Table 1. Sets, parameters, and decision variables of the arc flow model.

Symbol	Definition
Sets:
$A$	Set of all arcs.
$A_{job}$	Set of job arcs.
Parameters:
$r$	Index of an arc.
$R$	Total arcs.
$R_{job}$	Total job arcs.
$m$	Machine’s index.
$w$	Total number of machines.
$j$	Job’s index.
$n$	Total number of jobs.
$v$	Index of a vertex.
${TotalV}_m$	Total vertices of machine $m$.
${Initial}_r$	Initial vertex of an arc $r \forall r\in A$.
${Final}_r$	Final vertex of an arc $r \forall r\in A$.
${Job}_r$	Job index of an arc $r \forall r\in A$.
${Machine}_r$	Machine index of an arc $r \forall r\in A$.
${MinV}_m$	Minimum completion time on a machine $m \forall m\in \{0,\dots , w-1\}$.
$V_{mv}$	Time at vertex $v$ on a machine $m \forall m\in \left\{0,\dots , w-1\right\};$$\forall v\in \{0,\dots , {TotalV}_m-1\}$.
$\mathrm{U}\mathrm{B}$	Upper bound.
$\mathrm{L}\mathrm{B}$	Lower bound.
Decision Variables:
$x_r$	1 if arc r is included in the final solution; 0 otherwise. $\forall r\in \mathrm{A}$.
$C_{max}$	Makespan of a schedule.

lists the parameters, sets, and decision variables used in the mathematical model. In the following sections, the arc flow formulation will be denoted as AF.

Objective function:

$$Minimize C_{max}$$

(16)

Constraints:

$$\begin{gathered} C_{max}\ge {Final}_r\times x_r \forall m\in \left\{0,\dots ,w-1\right\}, \\ \forall r\in A_{job} such that {Machine}_r=m and {Final}_r\ge {MinV}_m \end{gathered}$$

(17)

$$\sum _{\begin{array}{c}r\in A_{job}\\ {Machine}_r=m; \\ {Initial}_r=0\end{array}}{x}_r=1 \forall m\in \left\{0,\dots ,w-1\right\}$$

(18)

$$\begin{gathered} \sum _{\begin{array}{c}r\in A\\ {Machine}_r=m\\ {Final}_r=V_{mv}\end{array}}{x}_r-\sum _{\begin{array}{c}r\in A\\ {Machine}_r=m\\ {Initial}_r=V_{mv}\end{array}}{x}_r=0 \forall m\in \left\{0,\dots ,w-1\right\}; \\ \forall v\in \left\{1,\dots ,{TotalV}_m-2\right\} \end{gathered}$$

(19)

$$\sum _{\begin{array}{c}r\in A_{job}\\ {Job}_r=j\end{array}}{x}_r=1 \forall j\in \left\{0,\dots ,n-1\right\}$$

(20)

$$x_r\in \left\{\mathrm{0,1}\right\} \forall r\in \left\{0,\dots ,R-1\right\}$$

(21)

$$LB\le C_{max}\le UB$$

(22)

Equation (16) presents the makespan minimization objective. The constraint in Equation (17) ensures that the makespan ($C_{max}$) is at least as large as the completion time of the last job on any machine. Equation (18) ensures that each machine has an arc that starts from a vertex at time 0. The flow conservation constraint is shown in Equation (19). Equation (20) ensures that only one arc is selected for each job. The type of decision variables is presented in Equation (21). Equation (22) represents the bounds of the makespan.

3.3.2. Mathematical Formulation of De and Morton [26]

In this section, the mathematical formulation proposed by De and Morton [26] for the Q| |C_max problem will be presented. In the following sections, the De and Morton [26] formulation will be denoted as D&M. This formulation serves as a benchmark for evaluating the effectiveness of the proposed arc flow formulation. Due to the NP-hard nature of the problem, the computational time for De and Morton’s mathematical formulation [26] grows rapidly even with medium-sized instances. Therefore, only small instances were solved by this formulation. The parameters and decision variables are listed in

Table 2. De and Morton’s Model [26] parameters, sets, and decision variables.

Symbol	Definition
Parameters:
$m$	Machine’s index.
$w$	Total machines.
$j$	Job’s index.
$n$	Total jobs.
$p_{mj}$	Processing time of a job $j$ on machine $m$. $\forall m\in \left\{0,\dots ,w-1\right\};$ $\forall j\in \left\{0,\dots ,n-1\right\}$.
$UB$	Upper bound.
$LB$	Lower bound.
Decision Variables:
$x_{mj}$	1 if machine $m$ is scheduled for job $j$; 0 otherwise. $\forall m\in \left\{0,\dots ,w-1\right\};\forall j\in \left\{0,\dots ,n-1\right\}$.
$C_{max}$	Maximum completion time of the last job on all machines (makespan).

.

Objective function:

$$Minimize C_{max}$$

(23)

Constraints:

$$\sum _{j=0}^{n-1}{p_{mj}x}_{mj}\le C_{max} \forall m\in \left\{0,\dots ,w-1\right\}$$

(24)

$$\sum _{m=0}^{w-1}{x}_{mj}=1 \forall j\in \left\{0,\dots ,n-1\right\}$$

(25)

$$x_{mj}\in \left\{\mathrm{0,1}\right\} \forall m\in \left\{0,\dots ,w-1\right\};\forall j\in \left\{0,\dots ,n-1\right\}$$

(26)

The makespan minimization objective is illustrated in Equation (23). This makespan, as presented in Equation (24), is at least the maximum of the sum of processing times of jobs on any machine. Equation (25) states that each job is scheduled on only one machine. The type of decision variables is illustrated in Equation (26).

Equation (27) is introduced to the mathematical formulation to provide a valid bound for the makespan.

$$LB\le C_{max}\le UB$$

(27)

3.4. Numerical Example

Consider 3 uniform parallel machines to be used to process 9 jobs. The speed of the machines, the time taken to process each job on every machine, and the cumulative processing times of jobs on the slowest machine (CumP_j) are presented in

Table 3. Data of the numerical example.

Machine No.	Machine Speed	Job No.
		1	2	3	4	5	6	7	8	9
1	1	4624	4080	4080	3264	2720	1632	1088	272	272
2	272/225	3825	3375	3375	2700	2250	1350	900	225	225
3	68/25	1700	1500	1500	1200	1000	600	400	100	100
	CumPj	22,032	17,408	13,328	9248	5984	3264	1632	544	272

.

The following steps illustrate the process of graph construction:

• Compute machine parameters.
  From Table 3,
  • The total speed of machines (Tvm) = 1109/225.
  • The sum of the slowest machine’s processing times (Tp) = 22,032.
• Determine lower and upper bounds.
  • Equation (9) is applied to find the best lower bounds.
  • $LB=\max \left({LB}_1,{LB}_2,{LB}_3\right)=\max \left(4469.97, 1700, 4470.22\right)=4470.22.$
  • The LPT rule obtains an upper bound of 4725, which the VNS algorithm improves to 4600. Therefore, UB = 4600.
• Calculate the minimum completion time for each machine.
  • Using Equation (13), the minimum completion time for machine 1 is

    $${MinV}_m\ge {\displaystyle \frac{Tp-\left(Tvm-{vm}_m\right)\times UB}{{vm}_m}} \forall m\in \{1,\dots ,w\}$$
  • ${MinV}_1\ge {\displaystyle \frac{\mathrm{22,032}-\left(\frac{1109}{225}-1\right)\times 4600}{1}}=3959.11.$
  • In the same manner, ${MinV}_2$ = 4069.85.
  • ${MinV}_3$ = 4364.38
• Calculate the cumulative processing time.

The cumulative processing time for each job on the slowest machine (CumP_j) is listed in Table 3.

5.

Construct the graph for each machine.

• Initialize the first vertex v = 0 as visited in each machine to allow establishing arcs from that vertex.
• For each job and vertex in each machine, an arc $(v,v+p\left[m\right]\left[j\right], j,m)$ is created if

  $$V\left[m\right]\left[v\right]=1 \mathrm{AND} v+p\left[m\right]\left[j\right]\le UB\mathrm{AND} v+{\displaystyle \frac{CumP\left[j\right]}{vm\left[m\right]}}\ge MinV[m]$$
• New vertices are added whenever a valid arc is established.

6.

Constructing the graph for machine 1.

• Job 1: An arc is not added since v₁ + p₁₁ > UB.
• Job 2: An arc is added from vertex 0 to a new vertex 4080.
• Job 3: An arc is added only from vertex 0. However, from vertex 4080, the completion time exceeds the upper bound.
  visited vertices: V [1][] = {0, 4080}.
• Job 4: An arc is added only from vertex 0 to a new vertex 3264. → V [1][] = {0, 4080, 3264}.
• Job 5: An arc is added only from vertex 0 to a new vertex 2720.
  The remaining jobs cannot create arcs from vertex 0 since CumP[j] < ${MinV}_1$.
• Job 6: An arc from vertex 2720 to vertex 4352.
• Job 7: Two arcs each from vertices 2720 and 3264 to 3808 and 4352, respectively.
• Jobs 8 and 9 have the same processing time, and two arcs can be created for each job from vertices 3808 and 4080 to vertices 4080 and 4352, respectively.

Thus, V [1][] = {0, 2720, 3260, 3808, 4080, and 4352}. Only one loss arc (dashed) can be created from vertex 4080 to vertex 4352 since v ≥ MinV[m]

The graph construction for machine 1 is shown in Figure 2.

7.

Repeat for the remaining machines.

Similarly, the procedures were performed for machines 2 and 3, and the resulting graphs are shown in Figure 3 and Figure 4, respectively.

8.

Optimal solution.

• The arc flow formulation achieved an optimal solution of 4500.

The optimal arcs selected for both machines, with a machine name included for each arc, are shown combined in Figure 5. Furthermore, the Gantt chart schedule of the optimal solution is presented in Figure 6. It is worth noting that indexing starts from 1 for both jobs and machines to enhance the readability of the figures.

4. Results and Discussion

The arc flow formulation and the mathematical formulation by De and Morton [26] were implemented in C++ with the optimization library of Cplex 12.10. We conducted the experiments using an Intel^® Core i7-4930 k CPU @ 3.40 GHz and 32.0 GB of RAM. To evaluate the effectiveness of the proposed arc flow formulation, we tested it on a set of instances generated by Bamatraf and Gharbi [24]. To recap, the generated instances considered four key parameters:

• Total number of machines (w): Four sizes were selected: $w\in \left\{3, 4, 5, 10\right\}$.
• Ratio of jobs ($n$) to machines (w), $n/w$: Seven ratios were considered: $n/w\in \left\{2, 3, 4, 5, 10, 20, 30\right\}$.
• Processing time for each job (j) on the speediest machine (w), $p_{wj}$: A discrete uniform distribution, $U~[1,p]$, is applied to generate the processing times with three levels for $p$: $p\in \{25, 50, 100\}$.
• The slowness of each machine to the fastest machine $\left(Sm\right)$: Generated with a uniform distribution $U~[1,Sm]$ with three levels for $Sm$: $Sm\in \{3, 5, 7\}$. $Sm$ values were rounded to two decimal digits. For each combination of these parameters ($w,n/w, p, and Sm$), 10 instances were generated, for a total of 2520 instances.

In the following subsection, we first compare the arc flow model (AF) with the mathematical formulation proposed by De and Morton (D&M) [26]. For a fair comparison, both the proposed arc flow formulation and the De and Morton (D&M) formulation [26] were implemented under the same solver parameters and computational settings. The same lower and upper bounds were used in both cases. Moreover, the upper bound obtained by the VNS algorithm was provided as an MIP start to both formulations. No preprocessing steps were applied beyond the solver’s default setting. A time limit of 3600 s is set for both formulations as a termination condition. For the instances that are not solved to optimality within the time limit, the solver returns the best solution obtained so far along with the gap from the best lower bound. The comparison between the two mathematical formulations is limited to instances with a maximum of 30 jobs. We begin by comparing the number of optimal solutions. Next, we examine the gap for instances that do not reach optimality within the given time limit of 3600 s. Finally, we compare the CPU times for each mathematical formulation. Additionally, we present the results of the arc flow formulation for the remaining set of instances.

4.1. Comparison of the Arc Flow and De & Morton Formulations [26]

In this section, we conduct a comparative analysis of the proposed AF formulation and the D&M formulation [26].

Table 4. The number of optimal solutions obtained by the AF and D&M mathematical formulations.

			Sm ~ [1,3]						Sm ~ [1,5]						Sm ~ [1,7]
n/w	w	n	p ~ [1,25]		p ~ [1,50]		p ~ [1,100]		p ~ [1,25]		p ~ [1,50]		p ~ [1,100]		p ~ [1,25]		p ~ [1,50]		p ~ [1,100]
			AF	D&M	AF	D&M	AF	D&M	AF	D&M	AF	D&M	AF	D&M	AF	D&M	AF	D&M	AF	D&M
2	3	6	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10
	4	8	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10
	5	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10
	10	20	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10
3	3	9	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10
	4	12	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10
	5	15	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10
	10	30	10	0	10	1	10	0	10	2	10	2	10	0	10	4	10	0	10	4
4	3	12	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10
	4	16	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10
	5	20	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10
5	3	15	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10
	4	20	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10	10
	5	25	10	5	10	2	10	4	10	7	10	8	10	9	10	9	10	7	10	9
10	3	30	10	10	10	4	10	3	10	10	10	9	10	5	10	10	10	8	10	10

presents the number of optimal solutions achieved by each algorithm across various job and machine sets, as well as intervals of the slowness of machines and processing times.

Table 4 clearly shows that the AF formulation achieves the optimal solution across all instances. In contrast, the D&M formulation finds the optimal solution only in cases with 20 jobs or fewer. For instances with more than 20 jobs, such as m = 10, n = 30 or m = 5, n = 25, the D&M formulation fails to reach optimality across all slowness and processing time intervals. In the case where m = 3, n = 30, with a ratio n/m = 10, the D&M formulation demonstrates better performance by achieving optimality in certain combinations of slowness and processing time intervals such as Sm ~ [1,3] with p ~ [1,25], and Sm ~ [1,7] with both p ~ [1,25] and p ~ [1,100]. Figure 7 illustrates the percentage of the average optimality gap for both the AF and D&M formulations across each interval of slowness and processing time. The figure shows that the AF formulation consistently achieves an average gap of 0%, while the average gap for the D&M formulation ranges from 0.008% to 0.067%. Although this gap is small, it highlights that D&M falls short of AF’s performance, particularly in instances with a larger number of jobs.

In addition to comparing the total optimal solutions achieved by the AF and D&M formulations and the average RPD, it is crucial to consider the computational efficiency of each approach.

Table 5. Average CPU time for the AF and D&M mathematical formulations.

			Sm ~ [1,3]						Sm ~ [1,5]						Sm ~ [1,7]
n/w	w	n	p ~ [1,25]		p ~ [1,50]		p ~ [1,100]		p ~ [1,25]		p ~ [1,50]		p ~ [1,100]		p ~ [1,25]		p ~ [1,50]		p ~ [1,100]
			AF	D&M	AF	D&M	AF	D&M	AF	D&M	AF	D&M	AF	D&M	AF	D&M	AF	D&M	AF	D&M
2	3	6	0.02	0.05	0.01	0.02	0.01	0.02	0.02	0.03	0.01	0.03	0.01	0.05	0.02	0.02	0.01	0.02	0.01	0.02
	4	8	0.02	0.03	0.02	0.03	0.02	0.04	0.02	0.02	0.02	0.03	0.02	0.02	0.02	0.03	0.02	0.02	0.02	0.03
	5	10	0.02	0.03	0.03	0.03	0.03	0.05	0.03	0.03	0.02	0.03	0.02	0.05	0.02	0.03	0.02	0.03	0.03	0.03
	10	20	0.27	3.44	0.19	0.44	0.27	0.71	0.18	0.55	0.19	0.41	0.26	0.43	0.16	0.16	0.22	0.26	0.33	0.27
3	3	9	0.03	0.09	0.02	0.03	0.02	0.04	0.03	0.05	0.02	0.04	0.02	0.07	0.02	0.06	0.02	0.03	0.02	0.03
	4	12	0.04	0.06	0.03	0.06	0.08	0.12	0.03	0.05	0.03	0.05	0.04	0.04	0.03	0.06	0.03	0.03	0.04	0.04
	5	15	0.07	0.11	0.07	0.21	0.11	0.17	0.09	0.15	0.09	0.09	0.1	0.18	0.06	0.08	0.07	0.08	0.11	0.07
	10	30	0.47	3605	1.02	3422	2.61	3606	0.62	3116	0.82	3209	2.14	3604	0.51	2474	0.88	3604	3.96	2458
4	3	12	0.06	0.17	0.03	0.06	0.04	0.1	0.05	0.1	0.02	0.1	0.02	0.18	0.06	0.1	0.02	0.05	0.03	0.04
	4	16	0.04	0.83	0.08	0.77	0.14	0.41	0.06	0.35	0.08	0.29	0.1	0.11	0.07	0.17	0.08	0.13	0.09	0.12
	5	20	0.09	20.28	0.18	14.34	0.25	18.63	0.11	5.3	0.16	12.37	0.24	6.5	0.08	4.86	0.21	3.97	0.24	2.46
5	3	15	0.07	0.13	0.04	0.11	0.08	0.14	0.04	0.11	0.05	0.17	0.06	0.32	0.06	0.07	0.04	0.09	0.03	0.06
	4	20	0.1	13.11	0.13	18.37	0.22	13.58	0.11	4.22	0.12	7.75	0.22	6.54	0.11	2.85	0.15	3.37	0.28	2.24
	5	25	0.23	2601	0.24	3366	0.34	2621	0.11	1399	0.18	1415	0.63	1519	0.18	899	0.32	1858	1.02	874
10	3	30	0.17	986	0.26	3061	0.38	2820	0.2	225	0.22	1020	0.68	2113	0.16	406	0.19	846	0.33	721
Average			0.11	482	0.16	659	0.31	605	0.11	317	0.14	378	0.3	483	0.1	252	0.15	421	0.44	271

illustrates the CPU time each formulation requires to reach the optimal solution, with a maximum time of 3600 s. If a formulation does not achieve the optimal solution within this time, it returns the best available solution.

From Table 5, it is evident that for instances with fewer than 20 jobs, both formulations achieve the optimal solution in under a second, with the AF formulation slightly outperforming in most cases. However, for instances with 20 or more jobs, the time of D&M formulations increases significantly, especially in cases with ratios (n/w) of 3 and 5. In these instances, the D&M often reaches the maximum time limit without achieving optimality, as presented in the previous table (Table 4) of the number of optimal solutions obtained by the AF and D&M formulations.

The arc flow formulation demonstrates a significant advantage in terms of both consistency and efficiency as the problem size increases. Unlike the D&M formulation, which struggles and often reaches the maximum time limit. The arc flow formulation maintains a remarkable level of performance. Even in more challenging scenarios where the number of jobs is 20 or more and the ratios of n/m reach 3 or 5, the arc flow formulation efficiently solves every instance in less than 4 s. This consistent efficiency highlights the robustness of the arc flow approach, making it a preferable choice for large and complex problem instances where minimizing computational time is crucial. The overall average CPU time for every pair of slowness interval and processing time interval also demonstrates the superior performance of the arc flow formulation compared to the D&M formulation. The highest average computational time recorded for the AF formulation is less than 0.5 s, whereas the average CPU time for the D&M formulation ranges from 252.45 to 658.92 s. The average CPU time is presented graphically as shown in Figure 8.

Compared to the De & Morton formulation, the AF formulation showed outperformance and superior scalability, particularly in instances with a high job-to-machine ratio. Unlike the De & Morton formulation, which explicitly considers job-to-machine assignment and sequencing of jobs, leading to a rapid growth of variables and constraints as the problem size increases, the arc flow incorporates arc reduction techniques during graph construction. The combined use of an upper bound obtained by the VNS algorithm, symmetry-breaking rules, minimum completion time for each machine, and arranging jobs in descending order of processing times during graph construction, since the job order on each machine has no influence on makespan for the Q||Cmax problem, significantly reduced the number of variables and constraints. Furthermore, the tight lower and upper bounds narrow the search space of the solver. As a consequence, they improve pruning efficiency and reduce computational time.

Statistical Analysis of the AF and D&M Formulations

This section investigates the statistical significance of the average CPU time of the arc flow formulation against the D&M formulation. The tests were conducted on Minitab 18 statistical software. A normality test of the difference in average CPU times using a Kolmogorov–Smirnov test with a significance level $\alpha =0.05$ resulted in a p-value < 0.010, indicating that the difference is not normal. Therefore, a one-sample Wilcoxon signed-rank test will be used with the following hypotheses:

H₀: Median of differences in average CPU times (D&M-AF) = 0.

H₁: Median of differences in average CPU times (D&M-AF) ≠ 0.

Results show that the Wilcoxon statistic = 7529.00 and p-value = 0.000, indicating a statistical significance in the average CPU time. The 95% confidence interval (0.215, 7.11) suggests that the AF has faster CPU time than the D&M formulation.

Since the D&M formulation struggled significantly with instances involving up to 30 jobs, often failing to find optimal solutions efficiently, whereas the proposed arc flow formulation demonstrates superior performance, it was deemed impractical to test this method for even larger problem sizes. Consequently, for instances with more than 30 jobs, we focused exclusively on the arc flow formulation, which had already demonstrated superior performance. This decision was made to ensure that our analysis remained focused on effective and practical solutions.

4.2. Performance of the Arc Flow Formulation for Larger Instances

The performance of the AF formulation for larger instances with more than 30 jobs is illustrated in this section.

Table 6. Number of optimal solutions obtained by the arc flow formulation.

			Sm ~ [1,3]			Sm ~ [1,5]			Sm ~ [1,7]
n/w	w	n	p ~ [1,25]	p ~ [1,50]	p ~ [1,100]	p ~ [1,25]	p ~ [1,50]	p ~ [1,100]	p ~ [1,25]	p ~ [1,50]	p ~ [1,100]
4	10	40	10	10	10	10	10	10	10	10	10
5	10	50	10	10	10	10	10	10	10	10	10
10	4	40	10	10	10	10	10	10	10	10	10
	5	50	10	10	10	10	10	10	10	10	10
	10	100	10	10	8	10	10	5	10	10	6
20	3	60	10	10	10	10	10	10	10	10	10
	4	80	10	10	8	10	10	7	10	10	8
	5	100	10	10	6	10	10	5	10	10	3
	10	200	9	4	6	10	4	3	9	3	5
30	3	90	10	10	7	10	10	8	10	10	10
	4	120	10	9	5	10	10	3	10	10	1
	5	150	10	4	6	10	4	2	10	5	3
	10	300	9	2	4	4	3	5	4	6	3
	% of solved instances		98.5%	83.8%	76.9%	95.4%	85.4%	67.7%	94.6%	87.7%	68.5%

presents the total optimal solutions achieved by the arc flow formulation and the percentage of solved instances for each combination of (Sm, p).

From the results presented in Table 6, it is obvious that the arc flow formulation can optimally solve instances comprising up to 60 jobs across all combinations of slowness and processing time intervals. However, as both the total jobs and the ratio n/m increase, the efficiency of the AF formulation in solving all instances gradually declines. Out of a total of 360 instances for each ratio n/m = 20 and n/m = 30, the minimum number of solved instances occurs at a ratio of 30, with only 247 instances solved, compared to 300 instances solved when the ratio n/m = 20. The table also shows that, for each slowness interval, the total number of solved instances decreases as the interval of processing time increases, as also shown in Figure 9 with the decreased percentage of solved instances for each value of Sm as the processing time interval increases. The minimum number of solved instances occurs at the largest processing time interval, i.e., p ~ [1,100].

The percentage of solved instances is 84.27%, which increases to 92.70% when considering both large and small instances together. Despite these limitations for unsolved instances, the AF formulation exhibits strong performance, with a maximum optimality gap of only 0.072% for unsolved instances.

Table 7. The average CPU time for the arc flow formulation.

			Sm ~ [1,3]			Sm ~ [1,5]			Sm ~ [1,7]
n/w	w	n	p ~ [1,25]	p ~ [1,50]	p ~ [1,100]	p ~ [1,25]	p ~ [1,50]	p ~ [1,100]	p ~ [1,25]	p ~ [1,50]	p ~ [1,100]
4	10	40	0.51	2.17	13.19	0.63	2.64	14.83	0.58	1.59	12.98
5	10	50	0.75	3.61	19.37	1.34	4.38	49.13	1.54	4.99	56.17
10	4	40	0.33	0.71	5.08	0.40	0.58	3.04	0.35	0.64	1.96
	5	50	0.75	3.40	9.65	0.75	2.42	12.77	0.88	2.75	7.59
	10	100	14.20	114.56	1604.44	14.53	104.36	2257.58	19.37	125.45	2189.36
20	3	60	0.70	2.92	7.61	1.09	2.36	10.15	0.47	3.85	14.08
	4	80	4.46	30.17	1240.54	4.46	16.01	1237.34	3.21	19.94	790.73
	5	100	11.06	66.07	1884.09	17.95	79.89	2086.46	19.00	89.77	2613.22
	10	200	800.00	2842.60	2321.26	419.88	2478.00	2652.21	1034.01	2557.68	2036.52
30	3	90	2.72	12.66	1137.66	3.33	19.25	989.33	2.85	10.71	402.37
	4	120	34.38	522.20	2090.70	19.68	111.70	2556.64	20.35	320.63	3245.15
	5	150	94.15	2748.48	1515.97	71.51	2275.77	2906.61	204.50	2345.32	2548.78
	10	300	2565.08	2999.42	2862.27	2563.62	2716.70	2692.88	2223.23	2052.53	2971.96
Average			271.47	719.15	1131.68	239.94	601.08	1343.77	271.57	579.68	1299.30

presents the average CPU time required by the AF formulation to solve the instances listed in Table 6. For the instances with up to 60 jobs, the average CPU time ranges from 0.33 to 56.17 s. The minimum average CPU time of 0.33 s is observed for the instance with w = 4, n = 40, Sm ~ [1,3], and p ~ [1,25]. In contrast, the maximum average CPU time of 56.17 s is recorded for the instance with w = 10, n = 50, Sm ~ [1,7], and p ~ [1,100].

For the instances with more than 60 jobs, the average CPU time varies depending on whether all instances in each combination of w, n, Sm, and p are solved to optimality. When all instances in a combination are solved to optimality, the average CPU time ranges from 2.27 to 419.88 s. However, for combinations with at least one unsolved instance, the average CPU time increases significantly, reaching up to 3245.15 s. This occurs at n/w = 30 with w = 4, n = 120, Sm ~ [1,7], and p ~ [1,100]. This combination showed the worst performance due to only one instance being solved to optimality.

The overall average CPU time is presented in Figure 10, which shows that, for each speed interval, the overall average CPU time increases as the processing time interval expands.

5. Conclusions and Future Work

This paper proposes an arc flow formulation for makespan minimization in a uniform parallel machine scheduling problem. This problem is considered in the literature as an NP-hard problem. The proposed arc flow formulation incorporates a variable neighborhood search from the literature to provide an efficient upper bound, as well as symmetry-breaking rules to minimize the graph size when constructing the graph that is used in the arc flow formulation. The performance of the arc flow formulation is first evaluated against a well-known mathematical formulation from the literature on small instances with up to 30 jobs. Computational results demonstrate that the arc flow formulation outperforms the existing formulation in terms of both solution optimality and computational time. Moreover, the arc flow formulation is evaluated against a lower bound for larger instances with more than 30 jobs. According to the results, the arc flow formulation solves about 84.27% of the instances to optimality. The maximum optimality gap does not exceed 0.072% for the instances not solved to optimality.

Future work will focus on further improving the arc flow formulation by exploring additional symmetry-breaking rules. Another promising avenue is to consider multi-objective optimization, rather than focusing on a single scheduling criterion. Real-world scheduling problems often involve multiple, sometimes conflicting, objectives such as minimizing makespan, total completion time, and tardiness. Extending the current models to capture these trade-offs would provide more flexible and realistic decision support.