A Simulated Annealing and Variable Neighborhood Search Hybrid for Sequencing Interrelated Activities

Abstract

Determining an appropriate sequence of interrelated activities is one of the keys to developing a complex product. One of the approaches used to sequence activities consists of solving the feedback length minimization problem (FLMP). Several metaheuristic algorithms for this problem have been reported in the literature. However, they suffer from high computational costs when dealing with large-scale problem instances. To address this research gap, we propose a fast hybrid heuristic for the FLMP, which integrates the simulated annealing (SA) technique with the variable neighborhood search (VNS) method. The local search component of VNS relies on a fast insertion neighborhood exploration procedure performing only $O\left(1\right)$ operations per move. Using rigorous statistical tests, we show that the SA-VNS hybrid is superior to both SA and VNS applied individually. We experimentally compare SA-VNS against the insertion-based simulated annealing (ISA) heuristic, which is the state-of-the-art algorithm for the FLMP. The results demonstrate the clear superiority of SA-VNS over ISA. The SA-VNS hybrid technique produces equally good or better results across all tested problem instances. In particular, SA-VNS is able to find better solutions than ISA on all instances of size 150 or more. Moreover, SA-VNS requires two orders of magnitude less CPU time than the ISA algorithm. Thus, SA-VNS achieves excellent performance regarding solution quality and running time.

1. Introduction

Complex product development (PD) projects are typically conceptualized as a network of interconnected activities [1,2,3,4,5]. The activities interact by exchanging information during the PD process. The network of information flows in a PD project may contain activities that are mutually dependent, either directly or indirectly. Figure 1 shows an example of the network represented by a directed graph, in which vertices correspond to activities $A_1,\dots ,A_7$ and arcs indicate information flows. In this example, activities $A_4,A_5,A_6$, and $A_7$ are mutually dependent. They constitute a coupled set of design activities. Suppose that the vertices of the digraph are arranged in a sequence. Then, it may happen that an arc connects a downstream activity with an upstream activity. In such a case, the latter receives feedback information from the former. For the vertex ordering $A_1,\dots ,A_7$ in Figure 1, the only feedback arc is $(A_7,A_4)$. It is intuitively appealing that there is a causal relationship between the number of feedback arcs in a sequence of activities and the PD time and cost. The goal is to have the least amount of feedback information during the PD process.

A well-known approach for modeling and analyzing relations between activities is the design structure matrix (DSM) method introduced by Steward [6]. The DSM is a square matrix of dimension $n\times n$, where n is the number of activities. The off-diagonal entries of the matrix indicate the level of dependency of one activity upon another. An arc connecting vertex s with vertex q in the activity digraph is represented by the entry in row q and column s of the DSM. For example, as shown in Figure 1, the DSM entry corresponding to the arc $(A_7,A_4)$ is $0.2$. Steward [6] used a mark (“×”) instead of numerical values to represent relations between activities. Such a matrix is referred to as binary DSM [7]. Eppinger et al. [7] proposed to use the concept of numerical DSM. Such DSMs allow representing both strong and weak precedence relations between activities. An example of the numerical DSM is shown in Figure 1b. Positive entries below the main diagonal represent forward dependencies for a given sequence of activities, and a single positive entry above the main diagonal represents a feedback dependency. In the figure, blank cells indicate no information dependency between activities. The DSMs were used in many studies devoted to PD process planning [8,9,10,11,12,13,14,15,16]. There are several reviews concerning DSM applications and extensions [17,18,19]. A bibliometric analysis of the DSM literature can be found in the paper of Piccirillo et al. [20].

An important optimization problem arising in the DSM context is to minimize feedback and its scope by sequencing the activities. Over the years, a variety of objective functions have been proposed in the literature to solve this problem [2]. Let us denote the level of dependency of activity q on activity s (the $(q,s)$th entry of the DSM) by $a_{qs}$. One natural objective function is the total feedback expressed as a sum of the superdiagonal entries of the DSM: $F_{\mathrm{feedback}}={\sum }_{q=1}^{n-1}{\sum }_{s=q+1}^n{a}_{qs}$. This objective function was suggested by Steward [6] for binary DSMs and was later used in studies addressing numerical DSMs [21,22]. Gebala and Eppinger [23] proposed an activity sequencing model in which the objective function is the total feedback length as follows:

$$F\left(p\right)=\sum _{i=1}^{n-1}\sum _{j=i+1}^n(j-i)a_{p\left(i\right)p\left(j\right)},$$

(1)

where p is a permutation of activities ($p\left(i\right)$ and $p\left(j\right)$ denote the ith and jth activities in the sequence, respectively). Many researchers [2,7,24,25,26] have reported the significance of the feedback length objective function. Compared with $F_{\mathrm{feedback}}$, the feedback length objective function (1) is better suited for reducing the PD process duration and cost [4]. The related problem is called the feedback length minimization problem (FLMP for short). It can be stated as follows:

$$\underset{p\in \mathrm{\Pi }}{\min }F\left(p\right)=\sum _{i=1}^{n-1}\sum _{j=i+1}^n(j-i)a_{p\left(i\right)p\left(j\right)},$$

(2)

where $\mathrm{\Pi }$ is the set of all n-element permutations.

1.1. Related Work

As shown by Qian and Lin [25], the FLMP can be expressed as a quadratic binary program. These authors have also proposed two ways to linearize this program. They used CPLEX to solve the linear models (named LIP–1 and LIP–2 in [25]). Optimal solutions were obtained for FLMP instances of a size up to 14 activities. A different approach to solve the FLMP exactly was undertaken by Shang et al. [26]. They developed a parallel branch-and-prune algorithm for this problem. To accelerate the search process, the algorithm uses hash functions. Computational results have shown that their algorithm HAPBP (hash address-based parallel branch-and-prune) can find optimal solutions for problem instances with up to 25 interrelated activities.

As was observed by Qian and Lin [25], the FLMP is an NP-hard problem. Therefore, exact methods may be impractical due to problem size and computation time. To obtain good solutions for large FLMP instances, fast heuristic algorithms are needed. Several heuristic techniques have been proposed in the literature for tackling the problem. Altus et al. [27] developed a permutation-based genetic algorithm (GA) for solving (2). However, the authors provided very limited experimental results to support their approach. Another application of GA for (2) was reported by Whitfield et al. [28]. The focus of this paper was to determine the most efficient configuration of the algorithm. Meier et al. [2] proposed an ordering messy GA (OmeGA) hybridized with a local search procedure. The results of computational experiments have shown the effectiveness of this hybrid approach. Lancaster and Cheng [24] presented a fitness differential adaptive parameter control evolutionary algorithm (FDAPCEA) for solving the FLMP. The algorithm was tested on three FLMP benchmarks from the literature. Qian and Lin [25] developed an exchange-based local search heuristic (named EBH) for (2). However, like other local search algorithms, this heuristic can be trapped in a local minimum that is significantly worse than the global one. More recently, Lin et al. [29] proposed an insertion-based simulated annealing algorithm (ISA) and an insertion-based genetic algorithm (IGA) for the FLMP. Both algorithms heavily rely on an insertion-based heuristic, which is a kind of local search procedure. At each iteration of ISA, a swap move for a pair of activities is first performed a certain number of times, and then the obtained solution is improved using the insertion-based heuristic. In the case of IGA, this heuristic is applied to each individual of the initial population and to each offspring created by crossover. If the offspring are too similar to their parents, then an additional mutation step is executed. As experimentally shown by Lin et al. [29], the performances of ISA and IGA are incredibly similar regarding the quality of the solution produced and the time taken. Through the experimental results, it can be concluded that ISA and IGA are state-of-the-art algorithms for solving the FLMP. In a recent paper, Attari-Shendi et al. [5] stated that “the combination of the insertion-based heuristic with simulated annealing has led to an effective approach that outperforms existing approaches in large scales”. Lately, Khanmirza et al. [30] have proposed an imperialist competitive algorithm (ICA) for feedback length minimization. They reported computational results on a small set of FLMP instances. The ICA found equally good or only slightly worse solutions compared with the ISA (see Table VII in [30]). On the other hand, ICA took less time to run than the ISA. Khanmirza et al. [30] also presented a genetic algorithm for the minimization of the feedback length in the DSM. This algorithm, however, showed inferior performance compared with the ICA approach to the problem. In another paper, Yazdanjue and Khanmirza [31] addressed an optimization problem in which they combined two objective functions: one representing the feedback length, and the second one representing the degree of modularity in the modularized DSM. To solve this problem, the authors proposed a metaheuristic algorithm named discrete particle swarm optimization simulated annealing. They reported computational results for a set of small matrices. The main advantages and disadvantages of the different methods proposed in the literature are summarized in

Table 1. Advantages and disadvantages of the existing algorithms for the FLMP.

Algorithm	Advantages	Disadvantages
LIP–1 [25]	Guarantees global optimality	Solves only small-scale instances
LIP–2 [25]	Guarantees global optimality	Solves only small-scale instances
HAPBP [26]	Guarantees global optimality	Particularly long computation time
GA [27]	Flexible in modifying the objective function	Long computation time
GA [28]	Efficient structure of the GA	Long computation time
OmeGA [2]	Uses local search strategies	Takes too long
FDAPCEA [24]	Adaptive parameter control in evolution strategy	Convergence is not fast
EBH [25]	Applies an iterative improvement scheme	Difficult to avoid falling into local optima
ISA [29]	Insertion-based cooling process	Difficult implementation; convergence speed is slow
IGA [29]	Applies insertion-based heuristic to each individual in the population	Difficult implementation; convergence speed is slow
GA [30]	Adaptive parameter tuning	Requires longer computation time
ICA [30]	Strong global search ability	Low degree of search intensification

.

The focus of this paper is on the development of an algorithm for the FLMP that combines simulated annealing (SA) and a variable neighborhood search (VNS) method. The SA component of the approach generates initial solutions for VNS. The latter is used as a powerful technique for search intensification. The choice of the VNS metaheuristic is motivated by its effectiveness, which is demonstrated through its use in developing algorithms for various combinatorial optimization problems. In the past few years, VNS algorithms have been proposed to solve a number of such problems, including the capacitated dispersion problem [32], truck routing within a naval port [33], minimum load coloring [34], integrated production and assembly in smart manufacturing [35], the obnoxious p-median problem [36], electric vehicle routing with simultaneous pickup and delivery [37], the vertex separator problem [38], swap-body vehicle routing [39], the periodic maintenance problem [40], and multi-depot vehicle routing [41]. The VNS metaheuristic was successfully applied to optimization problems whose solutions can be represented as permutations, such as in the case of the FLMP (such as no-delay single machine scheduling [42], the one-commodity pickup-and-delivery traveling salesman problem [43], multi-quays berth allocation and crane assignment [44], bandwidth reduction [45], and the traveling repairman problem with profits [46]).

The algorithm presented in the current paper combines the VNS methodology with the SA heuristic. In the literature, there exist several studies that have applied the VNS algorithm in combination with other approaches. Xiao et al. [47] proposed a VNS-based hybrid algorithm for solving capacitated vehicle routing problems. Their algorithm incorporates SA into the VNS framework. The key idea of this algorithm is to replace the local search step with the solution acceptance rule used in SA. Salehipour and Sepehri [48] presented a different combination of VNS and SA for the traveling repairman problem. Their algorithm uses VNS as a procedure to obtain solutions during the cooling process. Zhou et al. [49] addressed the problem of the joint optimization of storage allocation and order picking for fresh products. The authors developed a particle swarm-guided hybrid genetic-simulated annealing algorithm for solving this problem. They integrated SA with VNS and applied this combination as a local search optimizer. Drezner et al. [50] combined VNS with GA to solve the planar p-median problem. They applied a distribution-based VNS in the final phase of the approach. Irawan et al. [51] proposed a hybrid algorithm for the continuous location and maintenance routing problem for offshore wind farms. In this algorithm, the VNS is embedded in the GA as a functional part. Two versions of the VNS algorithm are used: mini VNS and full VNS. Kocatürk et al. [52] developed an algorithm to address the multi-depot heterogeneous vehicle routing problem with backhauls. Their algorithm integrates the greedy randomized adaptive search procedure (GRASP) and the VNS method. The latter is applied in the local search step of the GRASP. Kong et al. [53] presented a hybrid algorithm for the parallel-batching machine scheduling problem in the unrelated parallel machines environment. They combined a shuffle frog leap algorithm and the VNS technique. In this implementation, VNS is used as a local optimizer. Amaldass et al. [54] developed an algorithm based on VNS and ant colony optimization (ACO) to solve the vector job scheduling problem. The ACO algorithm was used to generate an initial solution for VNS. Simeonova et al. [55] presented a version of VNS for a real-life vehicle routing problem. They hybridized VNS with an adaptive memory procedure. Bouzid et al. [56] proposed a VNS-based heuristic to solve the capacitated vehicle routing problem. The authors integrated a Lagrangian relaxation method, called Lagrangian split, into the VNS scheme. Irawan et al. [57] developed a hybrid algorithm for large unconditional and conditional vertex p-center problems. The algorithm combines the VNS metaheuristic with an exact method. Daza-Escorcia and Álvarez-Martínez [58] introduced a static bike-sharing repositioning problem. To solve it, they proposed a matheuristic procedure combining VNS and integer linear programming techniques. Lan et al. [59] presented an effective hybrid approach to tackle the physician scheduling problem with multiple types of tasks. The approach incorporates VNS and a dynamic programming algorithm.

1.2. Contributions of This Paper

Analysis of the literature shows that there has been considerable interest in developing algorithms for the FLMP. However, these algorithms have been shown to work well for sequencing a relatively small number of interrelated activities. There is a lack of metaheuristic-based approaches capable of producing high-quality solutions for large-scale problem instances. Furthermore, it can be noted that the best existing algorithms are not sufficiently fast. Considering these observations, our motivation is to develop a reasonably fast heuristic algorithm that could perform well on large FLMP instances with several hundreds of activities. The aim of this paper consists of developing a metaheuristic-based algorithm that is capable of producing better solutions in shorter CPU times compared with the ISA algorithm of Lin et al. [29]. Our algorithm is constructed by combining the simulated annealing technique and a variable neighborhood search method. The choice of this combination was motivated by the good results of applying an SA and VNS hybrid for some other optimization problems on permutations, e.g., the profile minimization problem [60] and the bipartite graph crossing minimization problem [61]. To fully capture the benefits of both algorithms, we apply them iteratively. One of the main strengths of SA is its ability to approach global optimality. Meanwhile, the VNS algorithm employs a relatively strong mechanism to intensify the search near local optima. We exploit these strengths by combining the two algorithms. Of course, SA and VNS can be used individually. We experimentally investigated this scenario and compared the SA and VNS algorithms against their hybrid. One particular problem is developing a fast local search (LS) procedure for the FLMP. In this paper, we present an LS procedure that is based on performing activity insertion moves. In each iteration of LS, the entire insertion neighborhood of the current solution is explored in $O\left(n^2\right)$ time, which means that the procedure performs only $O\left(1\right)$ operations per move. The developed SA and VNS hybrid was tested on several FLMP benchmarks and a set of randomly generated DSMs. These problem instances contain up to 500 interrelated activities.

The main contributions of this paper are as follows:

• Hybridization of VNS with SA for solving the FLMP;
• A fast local search procedure for the FLMP;
• Numerical experimentation on FLMP instances of a size up to 500 interrelated activities to validate the effectiveness of the approach;
• Confirmation of the superiority of the hybrid algorithm over SA and VNS when they are used individually.

The rest of this paper is organized as follows. In the next section, we show how SA and VNS are integrated into a single framework. In Section 3 and Section 4, we present the SA and VNS algorithms for the FLMP, respectively. Experimental results of the proposed approach and comparisons with the state-of-the-art are reported in Section 5. Discussion and concluding remarks are given in Section 6 and Section 7, respectively.

2. Integrating SA and VNS

Simulated annealing and variable neighborhood search are two well-known metaheuristic techniques. Each of them was successfully applied to a number of very different optimization problems. SA is famous for its strategy of avoiding becoming stuck in local optima, and VNS provides a high level of intensification of the search process. Our idea is to combine the advantages of these two metaheuristics. We apply them in an iterative fashion. Each iteration is started by executing the SA algorithm. The solution returned is then further optimized using the VNS component of the approach. As is well known [62,63], the general strategy of the VNS algorithm is to explore the neighborhoods of the currently best found solution. If the latter is good enough already at the start of VNS, significant computation time savings can be achieved. Thus, owing to the fact that SA produces solutions of high quality, it is advantageous to run SA first and VNS second.

As mentioned before, the two components of the approach are applied iteratively. Each iteration begins by generating a random initial permutation of activities, which defines the starting state for the SA cooling process. The solution produced by SA is then passed to the VNS algorithm for potential further improvement. The iterations stop once the elapsed time exceeds a predefined timeout value. As is well known, the SA algorithm terminates when the temperature reaches a specified value close to zero. Without imposing a time limit, however, a straightforward implementation of the VNS algorithm can run arbitrarily long. To address this issue, we divide the overall CPU time limit into two parts: one allocated to SA and the other to VNS. If the time required for a single SA execution is known, the expected number of SA invocations during the iterative process can be estimated. To ensure the same number of VNS calls, the time limit for a single VNS run is then computed accordingly.

The proposed SA-VNS framework is designed to balance diversification and intensification within a fixed computational budget. Simulated annealing is used to generate diverse, high-quality starting solutions, while variable neighborhood search exploits these solutions to achieve further improvements. Since VNS may require unpredictable and potentially excessive running times, a time-controlled iterative scheme is adopted. The overall CPU time limit is therefore allocated between SA and VNS in a structured way, allowing multiple SA-VNS cycles to be executed while ensuring fairness and predictability across iterations. This strategy enables an effective exploration-exploitation trade-off and provides a clear, reproducible termination mechanism. Further details are provided in the pseudocode of the main part of the algorithm and its accompanying description.

Algorithm 1 shows the top-level pseudocode of our approach, denoted as SA-VNS. The algorithm iterates through the while-loop in Lines 2–12 until a stopping criterion is met. In our implementation of SA-VNS, the loop terminates when the maximum time limit $t_{\lim }$ is reached. Throughout the search, the algorithm memorizes both the best solution found in the current iteration and the globally best solution obtained thus far. They are denoted by $\tilde{p}$ and $p^{*}$, respectively, and their objective function values are, respectively, $\tilde{f}$ and $f^{*}$. In Line 3 of the pseudocode, a random permutation is generated, and in Line 4, our SA procedure is invoked. It returns solution $\tilde{p}$ and its value $\tilde{f}$, which are later passed to the VNS algorithm (Line 10). After the first execution of SA, the cut-off time for each run of VNS, denoted as $t_{\mathrm{run}\_\mathrm{VNS}}$, is computed. To share the CPU time resources, we use a parameter $\mu$ that ranges from 0 to 1. The running time limit for SA is set to $t_{\lim \_\mathrm{SA}}=\mu t_{\lim }$; for VNS, it is set to $t_{\lim \_\mathrm{VNS}}=(1-\mu )t_{\lim }$. Let $t_{\mathrm{SA}\_\mathrm{it}}$ denote the time taken by SA in the first SA-VNS iteration. Having $t_{\lim \_\mathrm{SA}}$ and $t_{\mathrm{SA}\_\mathrm{it}}$, we can calculate the predicted number of SA-VNS iterations using the formula $\lambda =\lceil t_{\lim \_\mathrm{SA}}/t_{\mathrm{SA}\_\mathrm{it}}\rceil$. Then, $t_{\mathrm{run}\_\mathrm{VNS}}$ is set to $t_{\lim \_\mathrm{VNS}}/\lambda$ (Line 5 of the pseudocode). If a predetermined amount of time expires during the execution of SA, then the SA-VNS iteration is stopped prematurely (Lines 7 and 8). Otherwise, the algorithm tries to improve the solution $\tilde{p}$ by making a call to the VNS procedure (Line 10). If the obtained permutation $\tilde{p}$ is better than $p^{*}$, then the globally best solution and its value are updated (Line 11).

Algorithm 1 Top-level description of SA-VNS.

SA-VNS

1:     $f^{*}:=\infty$

2:     while time limit $t_{\lim }$ not reached do

3:         Randomly generate a permutation $\tilde{p}\in \mathrm{\Pi }$

4:         Apply SA($\tilde{p},\tilde{f},t_{\lim }$)

5:         if $f^{*}=\infty$ then Compute $t_{\mathrm{run}\_\mathrm{VNS}}$ end if

6:         if $t_{\lim }$ expired then

7:             if $\tilde{f}<f^{*}$ then $p^{*}:=\tilde{p}$, $f^{*}:=\tilde{f}$ end if

8:             Stop with the solution $p^{*}$ of value $f^{*}$

9:         end if

10:       Apply VNS($\tilde{p},\tilde{f},t_{\lim },t_{\mathrm{run}\_\mathrm{VNS}}$)

11:       if $\tilde{f}<f^{*}$ then $p^{*}:=\tilde{p}$, $f^{*}:=\tilde{f}$ end if

12:   end while

13:   Stop with the solution $p^{*}$ of value $f^{*}$

We have described an implementation of SA-VNS in which a CPU time-based stopping rule is used. The algorithm has to be slightly modified when other termination criteria are adopted, such as, for example, the maximum number of calls to SA and VNS.

3. Simulated Annealing

In this section, we present our implementation of the SA method for the FLMP. The concept of simulated annealing is inspired by an analogy between the metallurgical process of annealing in thermodynamics and an optimization problem. This analogy was first perceived and exploited for solving combinatorial optimization problems by Kirkpatrick et al. [64] and Černý [65].

Simulated annealing is a stochastic local search method capable of escaping the local minimum by accepting worsening moves with a certain probability. When implementing SA, it is important to define how to move from one solution to a neighboring one. In our SA algorithm, insertion moves are used for this purpose. Given a permutation p on the set of activities, an insertion move removes an activity q from its current position in p and inserts it at a different position. The set of all permutations that can be obtained from p by applying this operation is called the insertion neighborhood of p. We denote it by $N\left(p\right)$. Suppose that the current position of q is k and the target position is l; then let $p^{\prime }$ denote the solution obtained from p by relocating activity q from position k to position l. The resulting change in cost $\mathrm{\Delta }(p,p^{\prime })=F\left(p^{\prime }\right)-F\left(p\right)$ is called the move gain. First, let us consider the case where $k<l$. One can interpret the insertion move as performing $l-k$ times a pairwise exchange operation in which the activity q is interchanged with its current right neighbor in the permutation p. After the ith step of this process, the activity q appears to be temporarily placed in position $k+i$. Let the change in the objective function value with this step be denoted by ${\mathrm{\Delta }}_{k+i}$. Thus, $\mathrm{\Delta }(p,p^{\prime })={\sum }_{m=k+1}^l{\mathrm{\Delta }}_m$. A step of the insertion move is illustrated in Figure 2, where $k⩽3$, $l⩾4$, $m=4$, and s is the right neighbor of q. In this figure, the arc for a DSM entry $a_{vw}$ is directed from v to w. To efficiently compute the gain $\mathrm{\Delta }(p,p^{\prime })$, we maintain arrays $L=\left(L\right(1),\dots ,L(n\left)\right)$ and $R=\left(R\right(1),\dots ,R(n\left)\right)$, which are defined as follows: Let Q denote the set of activities. Suppose $q\in Q$ is such that $p\left(k\right)=q$. Then, $L\left(q\right)={\sum }_{i=1}^{k-1}{a}_{p\left(i\right)q}$ and $R\left(q\right)={\sum }_{i=k+1}^n{a}_{qp\left(i\right)}$. In our example, the caption of Figure 2 lists the entries of L and R for the activities q and s. The objective function (1) can be rewritten as $F\left(p\right)={\sum }_{u=1}^{n-1}{C}_u\left(p\right)$, where $C_u\left(p\right)={\sum }_{i=1}^u{\sum }_{j=u+1}^n{a}_{p\left(i\right)p\left(j\right)}$. The sums $C_u\left(p\right)$ can be calculated recursively as

$$C_u\left(p\right)=C_{u-1}\left(p\right)+R\left(p\left(u\right)\right)-L\left(p\left(u\right)\right),$$

(3)

assuming by convention that $C_0\left(p\right)=0$. Let us continue to assume that $k<l$. When performing an insertion operation, the activity q is moved from left to right. Accordingly, the corresponding entry of the array L, as well as R, is changing. First, consider the case where $l=k+1$, and then denote by $s=p\left(l\right)$ the right neighbor of $q=p\left(k\right)$. Then, it is easy to see that $C_u\left(p^{\prime }\right)=C_u\left(p\right)$ for $u=1,\dots ,k-1,k+1,\dots ,n-1$. Thus, $\mathrm{\Delta }(p,p^{\prime })=F\left(p^{\prime }\right)-F\left(p\right)=C_k\left(p^{\prime }\right)-C_k\left(p\right)$. From (3), we find that $C_k\left(p\right)=C_{k-1}\left(p\right)+R\left(q\right)-L\left(q\right)$ and $C_k\left(p^{\prime }\right)=C_{k-1}\left(p^{\prime }\right)+R\left(s\right)+a_{sq}-(L\left(s\right)-a_{qs})$. Consequently,

$$\mathrm{\Delta }(p,p^{\prime })={\mathrm{\Delta }}_l=R\left(s\right)-L\left(s\right)+L\left(q\right)+a_{sq}-(R\left(q\right)-a_{qs}).$$

(4)

It can be observed that $L\left(q\right)+a_{sq}$ is the value of $L\left(q\right)$ in the permutation $p^{\prime }$. Similarly, $R\left(q\right)-a_{qs}$ is the value of $R\left(q\right)$ in the same permutation. To represent the current $L\left(q\right)$ and $R\left(q\right)$ values while computing ${\mathrm{\Delta }}_m$ for all $m\in \{k+1,\dots ,l\}$, we use auxiliary variables x and y. At the beginning, they are initialized with $L\left(q\right)$ and $R\left(q\right)$, respectively. The step gains ${\mathrm{\Delta }}_m$, $m=k+1,\dots ,l$, are calculated incrementally by first setting

$$x=x+a_{sq},y=y-a_{qs}$$

(5)

and then using the following equation reformulated from (4):

$${\mathrm{\Delta }}_m=R\left(s\right)-L\left(s\right)+x-y,$$

(6)

where $s=p\left(m\right)$. In our example in Figure 2, initially $x=L\left(q\right)=3$ and $y=R\left(q\right)=12$. Applying (5) and (6), we obtain the following: $x=x+a_{sq}=3+3=6$, $y=y-a_{qs}=12-5=7$, and ${\mathrm{\Delta }}_m={\mathrm{\Delta }}_4=2-8+6-7=-7$.

Suppose now that $k>l$. In this case, initially, $x=R\left(q\right)$ and $y=L\left(q\right)$. Additionally, the computation of ${\mathrm{\Delta }}_m$ is slightly different. The analogs of (5) and (6) take the following form:

$$x=x+a_{qs},y=y-a_{sq},$$

(7)

$${\mathrm{\Delta }}_m=L\left(s\right)-R\left(s\right)+x-y,$$

(8)

where $s=p\left(m\right)$ as before. The step gain ${\mathrm{\Delta }}_m$ is computed for decreasing values of m, starting with $m=k-1$.

The pseudocode of computing $\mathrm{\Delta }(p,p^{\prime })$ is shown in Algorithm 2. The activity q is moved from position k in the permutation p to position l. Loops 4–10 compute the gain $\mathrm{\Delta }$ when activity q is moved to the right, and Loops 12–18 compute $\mathrm{\Delta }$ when q is moved to the left. The gain $\mathrm{\Delta }$ is obtained by summing up the step gains ${\mathrm{\Delta }}_m$, which are computed either by (6) or (8). In the pseudocode, s stands for the closest neighbor of q in the moving direction. The arrays L and R are initialized and updated outside of the procedure get_gain. Clearly, the time complexity of this procedure is $O\left(n\right)$.

Algorithm 2 Computing the insertion gain.

get_gain($q,l,p$)

1:     $k:=p^{-1}\left(q\right)$ // $p^{-1}$ is the inverse permutation of p

2:     $\mathrm{\Delta }:=0$

3:     if $k<l$ then

4:        $x:=L\left(q\right)$

5:        $y:=R\left(q\right)$

6:        for $m=k+1,\dots ,l$ do

7:           $s:=p\left(m\right)$

8:           Update $x,y$ by (5) and compute ${\mathrm{\Delta }}_m$ by (6)

9:           $\mathrm{\Delta }:=\mathrm{\Delta }+{\mathrm{\Delta }}_m$

10:      end for

11:   else

12:      $x:=R\left(q\right)$

13:      $y:=L\left(q\right)$

14:      for $m=k-1$ to l by $-1$ do

15:         $s:=p\left(m\right)$

16:         Update $x,y$ by (7) and compute ${\mathrm{\Delta }}_m$ by (8)

17:         $\mathrm{\Delta }:=\mathrm{\Delta }+{\mathrm{\Delta }}_m$

18:      end for

19:   end if

20:   return $\mathrm{\Delta }$

Having the gain computation procedure, we can present the main part of our SA algorithm. Its pseudocode is given in Algorithm 3. The input to SA includes three parameters: the cooling factor $\alpha$, the final temperature $T_{\min }$, and the number of moves I to be attempted at each temperature level. The initial temperature $T_{\max }$ is computed as $T_{\max }={\max }_{p^{\prime }\in N^{\prime }}\left|\mathrm{\Delta }(p,p^{\prime })\right|$, where p is a starting random permutation generated in Line 3 of Algorithm 1, and $N^{\prime }$ is a sample of permutations chosen randomly from the insertion neighborhood $N\left(p\right)$. Using temperatures $T_{\max }$, $T_{\min }$, and factor $\alpha$, the number of temperature levels $\overline{\gamma }$ can be calculated (Line 6). Both $T_{\max }$ and $\overline{\gamma }$ are computed during the first SA-VNS iteration and reused in subsequent iterations. Before starting the annealing process, the arrays L and R are initialized (Line 3). This step takes $O\left(n^2\right)$ operations. The arrays L and R are updated by the procedure insert (Line 15). The main part of SA is a double-nested loop (Lines 9–21). Inside the inner loop, the algorithm calls get_gain and, if the move is accepted, triggers the procedure insert (Line 15). Provided $f<\tilde{f}$, the best solution is updated in Line 16. The outer loop of SA is equipped with a time-based stop condition to terminate the search prematurely. If this condition fails, the temperature is gradually reduced by a geometric cooling schedule $T:=\alpha T$ (Line 20) until the final temperature $T_{\min }$ is reached.

Algorithm 3 Simulated annealing.

SA($\tilde{p},\tilde{f},t_{\lim }$)

// $\alpha$, $T_{\min }$ and I are parameters of the algorithm

1:     $p:=\tilde{p}$

2:     $\tilde{f}=f:=F\left(p\right)$

3:     Construct arrays L and R

4:     if first call to SA then

5:         Compute $T_{\max }$

6:         $\overline{\gamma }:=\lfloor (log\left(T_{\min }\right)-log\left(T_{\max }\right))/log\alpha \rfloor$

7:     end if

8:     $T:=T_{\max }$

9:     for $\gamma =1,\dots ,\overline{\gamma }$ do

10:       for $i=1,\dots ,I$ do

11:           Pick activity q and its new position l at random

12:           get_gain($q,l,p$)

13:           if $\mathrm{\Delta }⩽0$ or $exp(-\mathrm{\Delta }/T)⩾$ random($0,1$) then

14:               $f:=f+\mathrm{\Delta }$

15:               Update $p,L$ and R by invoking insert($q,l,p$)

16:               if $f<\tilde{f}$ then $\tilde{p}:=p$, $\tilde{f}:=f$ end if

17:           end if

18:       end for

19:       if elapsed time $⩾t_{\lim }$ then return

20:       $T:=\alpha T$

21:   end for

22:   return

Algorithm 4 gives the pseudocode of the procedure insert. The insertion operation is accompanied by updating the arrays L and R. The current position of activity q in the permutation p is denoted by k. The entries of L and R are updated for all activities placed in the positions of p between k and l inclusively. At the end, the procedure assigns q to the target position l (Line 17).

Algorithm 4 Performing an insertion move.

insert($q,l,p$)

1:     $k:=p^{-1}\left(q\right)$ // $p^{-1}$ is the inverse permutation of p

2:     if $k<l$ then

3:        for $m=k+1,\dots ,l$ do

4:           $s:=p\left(m\right)$

5:           Add $a_{sq}$ to both $R\left(s\right)$ and $L\left(q\right)$

6:           Subtract $a_{qs}$ from both $L\left(s\right)$ and $R\left(q\right)$

7:           $p(m-1):=s$

8:        end for

9:     else

10:      for $m=k-1$ to l by $-1$ do

11:         $s:=p\left(m\right)$

12:         Add $a_{qs}$ to both $L\left(s\right)$ and $R\left(q\right)$

13:         Subtract $a_{sq}$ from both $R\left(s\right)$ and $L\left(q\right)$

14:         $p(m+1):=s$

15:      end for

16:   end if

17:   $p\left(l\right):=q$

18:   return

From Algorithm 4, it is obvious that the running time of insert is linear in n. As already remarked, the same is true for the procedure get_gain. Then, the computational complexity of SA can be evaluated as $O\left(n\overline{\gamma }I\right)$. Typically, in SA algorithms, I is within a constant factor of n. In such a case, the complexity expression simplifies to $O\left(n^2\overline{\gamma }\right)$, where $\overline{\gamma }$ is the number of temperature levels. This number depends on the initial temperature (calculated in Line 5 of Algorithm 3) and the SA parameters $\alpha$ and $T_{\min }$.

4. Variable Neighborhood Search

One of the weaknesses of SA is that it is always possible to become stuck at a local minimum that could be significantly worse than the global minimum. Therefore, if the time limit permits, we try to improve the solution returned by SA by applying the variable neighborhood search procedure. The VNS method is a metaheuristic technique introduced by Mladenović and Hansen [66] for solving optimization problems. The basic principle of VNS is to iteratively apply a neighborhood change mechanism and a local search procedure.

For better readability, we first provide a brief high-level overview of the proposed VNS approach. The algorithm iteratively explores the space of permutations by alternating between diversification and intensification phases. Diversification is achieved through a shaking mechanism that perturbs the current best solution (permutation), while intensification is performed via a local search that refines solutions toward local minima. This structure enables an effective balance between exploration of the solution space and exploitation of high-quality regions.

In our implementation of VNS, we use neighborhood structures that are appropriate for permutation-based combinatorial optimization problems. Given a permutation $p\in \mathrm{\Pi }$, we define the neighborhood ${\tilde{N}}_r\left(p\right)$, $r\in \{1,\dots ,r_{\max }\}$, as a set of all permutations that can be obtained from p by performing r pairwise interchanges of activities subject to the condition that no activity is moved more than once.

The pseudocode of the VNS algorithm for the FLMP is presented in Algorithm 5. As mentioned previously, VNS starts from the solution produced by the SA method. The input to VNS includes parameter $r_{\min }$, which defines the size of the neighborhood each iteration of the search is started from. At the beginning of each iteration, the maximum possible size of the neighborhood, $r_{\max }$, and the size change step $r_{\mathrm{step}}$ are calculated. The value of $r_{\max }$ is an integer number drawn uniformly at random from the range $[{\eta }_{1}n,{\eta }_{2}n]$, where ${\eta }_1$ and ${\eta }_2⩾{\eta }_1$ are parameters of the algorithm. To define $r_{\mathrm{step}}$, we use the scaling factor $\beta >0$. We set $r_{\mathrm{step}}$ to $\max (\lfloor r_{\max }/\beta \rfloor ,1)$. The inner loop of the algorithm iteratively applies three procedures: (a) shake (Algorithm 6), which generates a solution $p\in {\tilde{N}}_r\left(\tilde{p}\right)$ by performing r pairwise interchanges of activities; (b) LS, which returns a locally optimal solution p; and (c) neighborhood_change (Algorithm 7), which chooses the neighborhood structure to continue the search and memorizes the best solution found thus far.

Algorithm 5 Variable neighborhood search.

VNS($\tilde{p},\tilde{f},t_{\lim },t_{\mathrm{run}\_\mathrm{VNS}}$)

// $r_{\min }$ is a parameter of the algorithm

1:     $p:=\tilde{p}$

2:     $f:=$LS(p)

3:     if $f<\tilde{f}$ then $\tilde{p}:=p$, $\tilde{f}:=f$ end if

4:     while time limit for VNS run, $t_{\mathrm{run}\_\mathrm{VNS}}$, not reached do

5:        $r:=r_{\min }$

6:        Compute $r_{\max }$ and $r_{\mathrm{step}}$

7:        while $r⩽r_{\max }$ do

8:           $p:=$shake($\tilde{p},r$)

9:           $f:=$LS(p)

10:         $r:=$neighborhood_change$(p,\tilde{p},f,\tilde{f},r,r_{\min },r_{\mathrm{step}})$

11:         if $t_{\lim }$ expired then return end if

12:      end while

13:   end while

14:   return

Algorithm 6 Shake function.

shake($\tilde{p},r$)

1:     $p:=\tilde{p}$

2:     $U:=\{1,\dots ,n\}$

3:     for r times do

4:        Randomly select activities $q,s\in U$

5:        Swap positions of q and s in p

6:        $U:=U\setminus \{q,s\}$

7:     end for

8:     return p

The local search procedure is at the heart of the VNS metaheuristic. Our implementation of this procedure, denoted as LS, is based on the exploration of the insertion neighborhood. At a high level, the proposed local search explores the solution space by systematically relocating each activity within the current permutation. For every iteration, all possible insertion positions of each activity are evaluated to identify the move that yields the greatest improvement in the objective function value. The search proceeds by repeatedly applying the best improving insertion move until no further improvement is possible, at which point a locally optimal solution is reached. Since each activity has $n-1$ possible relocation positions in the permutation, a total of $n(n-1)$ solutions in the insertion neighborhood are examined at each iteration.

Algorithm 7 Neighborhood change function.

neighborhood_change($p,\tilde{p},f,\tilde{f},r,r_{\min },r_{\mathrm{step}}$)

1:   if $f<\tilde{f}$ then

2:       $\tilde{p}:=p$

3:       $\tilde{f}:=f$

4:       $r:=r_{\min }$

5:   else

6:       $r:=r+r_{\mathrm{step}}$

7:   end if

8:   return r

The pseudocode of LS is given in Algorithm 8. The procedure starts by initializing the arrays L and R, which are used to calculate the gain of performing an insertion move. Then, for each activity q (taken in Line 6 of the pseudocode), two loops are executed (Lines 9–17 and 20–28). The gain $\mathrm{\Delta }$ inside these loops is computed in exactly the same way as in the procedure get_gain. To keep track of the current best move, LS maintains a triplet $({\mathrm{\Delta }}^{*},q^{*},l)$ consisting of the best gain ${\mathrm{\Delta }}^{*}$, the activity $q^{*}$ for which this gain is achieved, and the new position l for $q^{*}$ in the current permutation. If ${\mathrm{\Delta }}^{*}<0$ after processing all activities, then the procedure insert (given in Algorithm 4) is triggered. We conclude this section with an observation regarding the complexity of LS. From the pseudocode in Algorithm 8, it is clear that an iteration of LS (Lines 4–33) takes $O\left(n^2\right)$ time. Indeed, first, all the statements within the inner loops (including those in Lines 11 and 22) execute a constant number of iterations. Second, from Algorithm 4, it can be seen that the complexity of insert is $O\left(n\right)$.

Algorithm 8 Local search.

LS(p)

1:     Construct arrays L and R and compute $f=F\left(p\right)$

2:     ${\mathrm{\Delta }}^{*}:=-1$

3:     while ${\mathrm{\Delta }}^{*}<0$ do

4:         ${\mathrm{\Delta }}^{*}:=0$

5:         for $k=1,\dots ,n$ do

6:           $q:=p\left(k\right)$

7:           $\mathrm{\Delta }:=0$

8:           $x:=L\left(q\right)$, $y:=R\left(q\right)$

9:           for $m=k+1,\dots ,n$ do

10:             $s:=p\left(m\right)$

11:             Update x and y using (5) and compute ${\mathrm{\Delta }}_m$ using (6)

12:             $\mathrm{\Delta }:=\mathrm{\Delta }+{\mathrm{\Delta }}_m$

13:             if $\mathrm{\Delta }<{\mathrm{\Delta }}^{*}$ then

14:                ${\mathrm{\Delta }}^{*}:=\mathrm{\Delta }$

15:                $q^{*}:=q$, $l:=m$

16:             end if

17:           end for

18:           $\mathrm{\Delta }:=0$

19:           $x:=R\left(q\right)$, $y:=L\left(q\right)$

20:           for $m=k-1$ to 1 by $-1$ do

21:             $s:=p\left(m\right)$

22:             Update x and y using (7) and compute ${\mathrm{\Delta }}_m$ using (8)

23:             $\mathrm{\Delta }:=\mathrm{\Delta }+{\mathrm{\Delta }}_m$

24:             if $\mathrm{\Delta }<{\mathrm{\Delta }}^{*}$ then

25:                ${\mathrm{\Delta }}^{*}:=\mathrm{\Delta }$

26:                $q^{*}:=q$, $l:=m$

27:             end if

28:           end for

29:       end for

30:       if ${\mathrm{\Delta }}^{*}<0$ then

31:           insert($q^{*},l,p$)

32:           $f:=f+{\mathrm{\Delta }}^{*}$

33:       end if

34:   end while

35:   return f

5. Computational Experiments

In this section, we report on the results of computational tests to assess the performance of the proposed simulated annealing and variable neighborhood search hybrid for solving the FLMP. The effectiveness of the approach is evaluated by conducting two major experiments. In the first experiment, we compare SA-VNS against the insertion-based simulated annealing algorithm proposed by Lin et al. [29]. This algorithm is a state-of-the-art method for the FLMP. In the second experiment, we compare the SA-VNS algorithm with its components, SA and VNS, on a set of large-scale FLMP instances. In addition, we carry out an experiment aimed at comparing the running time between our LS procedure and the local search algorithm of Lin et al. [29].

5.1. Experimental Setup

The algorithm described in the preceding sections was coded in the C++ programming language. For the sake of comparison, we also coded the insertion-based simulated annealing algorithm of Lin et al. [29]. The experiments were performed on a laptop with an Intel Core i5-6200U CPU running at 2.30 GHz.

We ran the algorithms on the seven benchmark instances from the literature, as well as on a set of randomly generated FLMP instances. We used the following benchmark DSMs that were considered in previous studies: steward’81 [6], kusiak’91 [67], austin’96 [68], and qian’14 [25]. In addition, we tested the algorithms on the three DSMs from the book of Eppinger and Browning [4] as follows:

• microprocessor (this matrix represents Intel’s existing product development process in 1992);
• strategy (this matrix models the research program strategy development process in Meat & Livestock Australia Ltd. (North Sydney, Australia));
• automobile (this DSM represents Ford’s baseline hood development process in 1999).

However, the above-listed benchmark matrices are sparse and relatively small. The FLMP with these matrices is particularly easy to solve by metaheuristic algorithms, like those presented in [29]. We, therefore, randomly generated 60 extra matrices of dimensions ranging from 30 to 500. We adopted the same generation method as in [29]. The nonzero entries of each matrix are drawn uniformly at random from the interval $(0,1)$. The matrix density is set to one of the following values: $10\%$, $20\%$, $30\%$, $40\%$, or $50\%$. The new matrices, as well as the source code of our algorithm, have been made publicly available (https://drive.google.com/drive/folders/1md2vyj3nQcwo1EakmJwrQT7JNyD4W2oJ?usp=sharing (accessed on 07 January 2026)).

Table 2. CPU time limits for random instances.

n	Seconds
30	3
60	3
100	20
150	120
200	300
250	600
300	900
350	1200
400	1800
500	3600

shows the maximum CPU time allowed for a run of the SA-VNS algorithm on random FLMP instances. For benchmark DSMs, SA-VNS was stopped after 1 s of CPU time. To be able to apply the same cut-off times for the insertion-based simulated annealing algorithm of Lin et al. [29], we implemented it as a multi-start procedure. We, however, allowed completing the first start of this algorithm, even if the maximum allotted time had elapsed. The performance of the algorithms was measured by the objective function value of the best solution found during the search, the average objective function value, and the average time taken to find the best solution in a run.

5.2. Parameter Settings

The main parameters of our simulated annealing implementation were the cooling factor $\alpha$ and the number of iterations I, which were executed at each temperature. Based on the recommendations from the SA literature [69,70], we used the following values for these parameters: $\alpha =0.95$ and $I=100n$.

Our VNS algorithm was configured by setting the values of parameters $r_{\min }$, ${\eta }_1$, and ${\eta }_2$, which define the minimum and maximum size of the neighborhood, and the parameter $\beta$, which controls switching to the next neighborhood. We conducted some experiments to find good settings for the VNS parameters. We examined the performance of SA-VNS on a training dataset consisting of five problem instances of size 100 and five instances of size 200. These instances were generated randomly using the same procedure as described in Section 5.1. Certainly, the training sample was disjoint from the set of instances used in the main experiments. We did not include large instances (e.g., with $n⩾300$) in the training dataset. This decision was motivated by two reasons. First, our comparison of the SA-VNS algorithm with state-of-the-art methods was limited to instances containing at most 200 activities. Second, incorporating large-scale instances into the parameter tuning of SA-VNS would require substantial computational resources. Our parameter sensitivity analysis was based on a simple procedure. We tested a number of predefined values of one parameter while fixing the other VNS parameters at reasonable values, which were chosen during preliminary experimentation. For each parameter setting and each instance, we performed 10 independent runs of SA-VNS and computed the average objective function value over these runs. The time limit per run was set to 5 s for $n=100$ and 20 s for $n=200$. The experimental results show that VNS is robust in finding good solutions for a rather wide range of parameter values. Our first step in parameter tuning was to select a good value for ${\eta }_2$. We ran SA-VNS with ${\eta }_2\in \{0.2,0.3,0.4,0.5\}$ (note that ${\eta }_2$ cannot exceed $0.5$). Good quality solutions were obtained for ${\eta }_2\in \{0.3,0.4,0.5\}$. A slightly better performance was observed for ${\eta }_2=0.4$. SA-VNS with ${\eta }_2=0.4$ obtained the best average values for 7 (out of 10) instances. Results of this kind for other values of ${\eta }_2$ were worse: 0, 3, and 4 instances for ${\eta }_2=0.2$, ${\eta }_2=0.3$, and ${\eta }_2=0.5$, respectively. We thus fixed ${\eta }_2$ at $0.4$. Next, we examined the following values of the parameter ${\eta }_1$: $0.01,0.02,0.05,0.1,0.2,0.3$, and $0.4$ (we remind that ${\eta }_1⩽{\eta }_2$). The results were incredibly similar for the ${\eta }_1$ values between $0.1$ and $0.4$. The algorithm with ${\eta }_1<0.1$ performed equally well for instances with $n=100$ and marginally worse for instances with $n=200$. We decided to fix ${\eta }_1$ at $0.2$. Furthermore, we evaluated the effect of the parameter $r_{\min }$ on the performance of SA-VNS. We experimented with the following values for $r_{\min }$: $1,5,10,20$, and 50. The results have shown that SA-VNS is not sensitive to the values of $r_{\min }$ in the range 1 to 20. The performance of SA-VNS started to deteriorate at $r_{\min }=50$. Based on these findings, we pretty arbitrarily set $r_{\min }$ to 5. In the next experiment, we assessed the influence of the parameter $\beta$ on the quality of solutions. We ran SA-VNS with $\beta \in \{1,2,3,4,5,10,20,50\}$. We found that the algorithm is fairly robust for $\beta$ values in the range 3 to 20. The performance of SA-VNS decreased for $\beta =2$ and $\beta =50$. Its performance rapidly declined for $\beta =1$. Based upon these results, we set $\beta$ to 5, which is the middle element in the list $3,4,5,10$, and 20.

To finish configuring our SA and VNS hybrid, we needed to set the CPU quota parameter $\mu$. This parameter serves for dividing the processor time resources between the SA and VNS algorithms (see Section 2). To choose a proper value of $\mu$, we ran SA-VNS on the same set of instances as before. We varied $\mu$ from 0 to 1 in increments of $0.1$. For each FLMP instance in the training set, the accuracy of solutions produced by SA-VNS was measured using the difference between the average objective function value over 10 runs and the value of the best solution obtained from all runs of SA-VNS for all values of $\mu$. Let us denote by $\mathrm{\Delta }{F}_{\mathrm{av}}$ this difference averaged over all instances in the set. In Figure 3, $\mathrm{\Delta }{F}_{\mathrm{av}}$ is plotted as a function of $\mu$. We note that the pure VNS algorithm is obtained by setting $\mu$ to 0, and the pure multi-start SA algorithm is activated by setting $\mu$ to 1. As shown in Figure 3, we see that the pure VNS is the least efficient SA-VNS configuration. However, the pure multi-start SA is not the best choice either. We observe that reasonable values of the parameter $\mu$ fall in the interval $[0.4,0.7]$. With these results, we fixed $\mu$ to $0.5$, thus giving $50\%$ of the time limit to each of the two components of the hybrid algorithm.

5.3. Numerical Results

We now provide computational comparisons between our hybrid heuristic and state-of-the-art algorithms for the FLMP. One such algorithm is the insertion-based simulated annealing algorithm of Lin et al. [29]. These authors use the name ISA to refer to this algorithm. We decided to keep this name. Lin et al. [29] also proposed an insertion-based genetic algorithm (IGA) for solving the FLMP. According to the computational experiments in [29], both algorithms, ISA and IGA, performed equally well. For comparison purposes, we implemented the ISA algorithm. During the implementation, we strictly followed the description provided in [29], particularly the pseudocode presented in Tables I and III of that paper. Both the SA-VNS and ISA algorithms were executed on the same hardware under single-threaded settings. We note that our SA-VNS algorithm and IGA can be indirectly compared by confronting the results of this section with those presented by Lin et al. [29]. The comparison also includes the imperialist competitive algorithm of Khanmirza et al. [30].

By running SA-VNS and ISA on the same hardware platform (Intel Core i5-6200U CPU), we ensured the consistency of the computational conditions. For large-scale problem instances, the ISA algorithm was observed to require substantially longer runtimes to converge to a reasonable solution. Therefore, while a fixed maximum CPU time was imposed on our method, ISA was allowed to run until its own termination criterion was met, which in many cases exceeded the imposed time limit. This choice was made to avoid penalizing ISA due to premature termination and to provide a conservative and fair comparison.

The results of solving the benchmark FLMP instances from the literature are reported in

Table 3. Comparison of the SA-VNS algorithm with the ICA of Khanmirza et al. [30] and ISA of Lin et al. [29].

Instance	n	ICA [30]				ISA [29]				SA-VNS
		${\mathit{F}}_{\mathrm{best}}$	${\mathit{F}}_{\mathrm{av}}$	Time(s)		${\mathit{F}}_{\mathrm{best}}$	${\mathit{F}}_{\mathrm{av}}$	Time(s)		${\mathit{F}}_{\mathrm{best}}$	${\mathit{F}}_{\mathrm{av}}$	Time(s)
kusiak’91	12	6	6	<0.1		6	6	<0.1		6	6	<0.1
steward’81	20	24	24	0.3		24	24	0.4		24	24	<0.1
automobile	46	–	–	–		451	451	15.0		451	451	0.3
qian’14	48	–	–	–		106	106	10.5		106	106	0.4
austin’96	51	133	133.2	9.8		133	133	27.4		133	133	0.3
microprocessor	60	–	–	–		386	386	33.4		386	386	0.3
strategy	62	–	–	–		71	71	82.2		71	71	0.3

. They were obtained by running each of the three algorithms 30 times per instance. The second column of the table gives the number of activities. The next nine columns contain the results of the ICA, ISA, and SA-VNS algorithms. The value of the best solution out of 30 runs is denoted by $F_{\mathrm{best}}$, and the average value of 30 solutions found by an algorithm is denoted by $F_{\mathrm{av}}$. Columns labeled “Time” show the average running time (in seconds) to the best solution in a run of an algorithm. The results of the ICA (Columns 3–5 of Table 3) are taken from the paper of Khanmirza et al. [30]. These authors ran ICA on a computer with an Intel Core i7 (3.70 GHz) processor. (Intel Corporation, Santa Clara, CA, USA) However, they provided only an Intel Core brand modifier i7, and not the full processor name. Therefore, the comparison of SA-VNS and ICA is somewhat complicated. The single-thread rating of our PC (Intel Core i5-6200U, 2.30 GHz (Intel Corporation, Santa Clara, CA, USA)) is 1575 (for example, these data are available from https://www.cpubenchmark.net/singleCompare.php (accessed on 7 January 2026)). One might expect that the single-thread performance of the computer used by Khanmirza et al. [30] is comparable with, or better than, our laptop’s CPU. If so, our system would have no speed advantage over the computer used in [30]. In any case, since an exact comparison is not possible, the reported running times are provided in Table 3 solely for reference.

We see from Table 3 that all the algorithms performed well on the benchmark problems. They easily achieved the best result in all runs for each problem instance (except ICA for austin’96, for which $F_{\mathrm{av}}=133.2$). It can also be observed that SA-VNS took much less time than ISA for the five larger instances. The overall conclusion from the experiment is that the benchmark FLMP instances were incredibly easy to solve.

Table 4. Comparison of SA-VNS with the state-of-the-art algorithm ISA from Lin et al. [29] on the FLMP instances with $n⩽200$—best solution values (SR denotes the success rate).

Instance	Density (%)	ISA [29]			SA-VNS
		${\mathit{F}}_{\mathrm{best}}$	SR		${\mathit{F}}_{\mathrm{best}}$	SR
fp-30-1	10	49.21	10/10		49.21	10/10
fp-30-2	10	40.36	10/10		40.36	10/10
fp-30-3	20	133.78	10/10		133.78	10/10
fp-30-4	20	169.23	10/10		169.23	10/10
fp-30-5	30	323.52	10/10		323.52	10/10
fp-30-6	30	306.51	10/10		306.51	10/10
fp-30-7	40	487.37	10/10		487.37	10/10
fp-30-8	40	484.75	10/10		484.75	10/10
fp-30-9	50	835.37	10/10		835.37	10/10
fp-30-10	50	687.07	10/10		687.07	10/10
fp-60-1	10	684.39	10/10		684.39	10/10
fp-60-2	10	569.65	8/10		569.65	10/10
fp-60-3	20	2134.64	8/10		2134.64	10/10
fp-60-4	20	1794.06	9/10		1794.06	10/10
fp-60-5	30	3126.51	10/10		3126.51	10/10
fp-60-6	30	3197.11	10/10		3197.11	10/10
fp-60-7	40	5381.64	8/10		5381.64	10/10
fp-60-8	40	5317.66	9/10		5317.66	10/10
fp-60-9	50	6734.01	10/10		6734.01	10/10
fp-60-10	50	6886.26	5/10		6886.26	10/10
fp-100-1	10	3795.32	6/10		3795.32	10/10
fp-100-2	20	10,379.05	4/10		10,379.05	10/10
fp-100-3	30	18,182.62	3/10		18,182.38	10/10
fp-100-4	40	26,072.53	1/10		26,072.20	10/10
fp-100-5	50	33,721.92	1/10		33,721.90	10/10
fp-150-1	10	16,192.93	1/10		16,192.50	8/10
fp-150-2	20	39,215.61	1/10		39,215.16	9/10
fp-150-3	30	63,833.26	1/10		63,831.99	10/10
fp-150-4	40	88,498.23	1/10		88,498.16	10/10
fp-150-5	50	118,012.66	1/10		118,010.53	10/10
fp-200-1	10	42,719.40	1/10		42,718.98	1/10
fp-200-2	20	98,504.32	1/10		98,502.94	10/10
fp-200-3	30	159,114.79	1/10		159,109.90	8/10
fp-200-4	40	227,074.66	1/10		227,060.86	10/10
fp-200-5	50	289,344.14	1/10		289,343.49	10/10

and

Table 5. Comparison of SA-VNS with the state-of-the-art algorithm ISA from Lin et al. [29] on the FLMP instances with $n⩽200$—average results ($\sigma$ denotes the standard deviation).

Instance	Density (%)	ISA [29]				SA-VNS
		${\mathit{F}}_{\mathrm{av}}$	$\mathit{\sigma }$	Time (s)		${\mathit{F}}_{\mathrm{av}}$	$\mathit{\sigma }$	Time (s)
fp-30-1	10	49.21	0	2.9		49.21	0	0.2
fp-30-2	10	40.36	0	2.3		40.36	0	0.1
fp-30-3	20	133.78	0	3.4		133.78	0	1.5
fp-30-4	20	169.23	0	2.2		169.23	0	0.2
fp-30-5	30	323.52	0	2.9		323.52	0	0.2
fp-30-6	30	306.51	0	2.6		306.51	0	0.3
fp-30-7	40	487.37	0	7.0		487.37	0	0.1
fp-30-8	40	484.75	0	4.8		484.75	0	0.1
fp-30-9	50	835.37	0	4.6		835.37	0	0.2
fp-30-10	50	687.07	0	3.5		687.07	0	0.1
fp-60-1	10	684.39	0	56.2		684.39	0	0.8
fp-60-2	10	569.69	0.08	37.1		569.65	0	0.8
fp-60-3	20	2134.67	0.08	58.4		2134.64	0	0.8
fp-60-4	20	1794.08	0.05	37.9		1794.06	0	0.6
fp-60-5	30	3126.51	0	46.4		3126.51	0	0.7
fp-60-6	30	3197.11	0	16.5		3197.11	0	0.6
fp-60-7	40	5381.65	0.02	25.8		5381.64	0	0.5
fp-60-8	40	5317.70	0.11	19.8		5317.66	0	0.9
fp-60-9	50	6734.01	0	31.8		6734.01	0	0.5
fp-60-10	50	6886.30	0.04	89.8		6886.26	0	0.7
fp-100-1	10	3795.38	0.07	742.6		3795.32	0	1.8
fp-100-2	20	10,379.14	0.16	1203.4		10,379.05	0	2.6
fp-100-3	30	18,182.79	0.22	863.8		18,182.38	0	1.7
fp-100-4	40	26,072.91	0.32	763.8		26,072.20	0	1.8
fp-100-5	50	33,722.48	0.32	1142.7		33,721.90	0	2.8
fp-150-1	10	16,194.01	0.59	6138.2		16,192.60	0.21	49.6
fp-150-2	20	39,217.16	0.80	5648.9		39,215.18	0.07	31.8
fp-150-3	30	63,836.63	2.22	8536.0		63,831.99	0	9.8
fp-150-4	40	88,499.39	0.87	6119.7		88,498.16	0	11.7
fp-150-5	50	118,014.57	1.40	5153.8		118,010.53	0	5.1
fp-200-1	10	42,720.96	1.23	34,197.0		42,720.37	1.29	92.7
fp-200-2	20	98,504.97	1.31	29,276.7		98,502.94	0	31.3
fp-200-3	30	159,117.88	3.36	21,657.1		159,109.91	0.02	127.0
fp-200-4	40	227,078.84	3.93	22,753.3		227,060.86	0	120.5
fp-200-5	50	289,350.91	4.54	24,071.2		289,343.49	0	85.6

summarize the results of SA-VNS and ISA on the randomly generated problem instances of a size up to $n=200$. The first column of the tables contains the names of the instances. The first number within the name denotes the number of activities. The second column shows the density of the input DSM. The $F_{\mathrm{best}}$ values in Table 4 are obtained from 10 independent runs of ISA (Column 3) and SA-VNS (Column 5). We also provide, for each algorithm, the success rate (denoted as SR), which is the fraction of times the algorithm outputs a solution of value $F_{\mathrm{best}}$ (Columns 4 and 6 in Table 4). Table 5 shows the $F_{\mathrm{av}}$ value, the standard deviation of the objective function values, $\sigma$, and the average running time (in seconds) to the best solution in a run for ISA (Columns 3–5) and for SA-VNS (Columns 6–8). Boldface is used to highlight those cases where SA-VNS obtained better $F_{\mathrm{best}}$ (Table 4) or better $F_{\mathrm{av}}$ (Table 5) values than ISA. We can observe from the tables that our algorithm demonstrates a good performance. Compared with ISA regarding $F_{\mathrm{best}}$, SA-VNS outperformed in 13 cases and tied in the remaining 22 cases. Notably, SA-VNS achieved a perfect success rate of 10/10 for a larger number of instances than ISA (31 vs. 14). From Table 5, we can see that the dominance of SA-VNS is even more pronounced regarding the mean performance. It produced better average results than ISA for 21 problem instances, including all instances of size 100 and more. We notice that for $n=30$ and the four instances with $n=60$, both algorithms found the best solution in each of the 10 runs. For illustration purposes, as shown in Figure 4, we show the plots of the objective function value versus the run number for the two problem instances used in the experiment: fp-150-2 and fp-200-5. As can be seen, SA-VNS consistently yielded better quality solutions than the ISA algorithm. The results in Table 5 also indicate that the SA-VNS algorithm outperformed ISA with generally smaller standard deviations of the objective values.

Comparing the running times, we observe the overwhelming superiority of SA-VNS. Figure 5 shows the convergence speed comparison between the two algorithms for a couple of problem instances: fp-60-8 and fp-100-1. We see that SA-VNS identifies the best solution particularly quickly, whereas ISA needs a much longer time to do so. For instances with $n=200$, the average time taken by ISA and SA-VNS is $\mathrm{26,391.1}$ s and $91.4$ s, respectively. The speed-up factor of 288 on this subset of instances was achieved.

When the size of the FLMP increases beyond 200 activities, the execution time of the ISA algorithm becomes unreasonably long. Therefore, we did not try to include ISA in our experiments with problem instances of a size greater than 200. Instead, for the sake of comparison, we ran SA and VNS algorithms on these instances. The results are presented in

Table 6. Best results obtained by the SA-VNS, SA, and VNS algorithms on the FLMP instances with $n\in \{250,300,350,400,500\}$ (SR denotes the success rate).

Instance	Density (%)	SA			VNS			SA-VNS
		${\mathit{F}}_{\mathrm{best}}$	SR		${\mathit{F}}_{\mathrm{best}}$	SR		${\mathit{F}}_{\mathrm{best}}$	SR
fp-250-1	10	83,963.14	1/10		83,961.92	1/10		83,962.00	1/10
fp-250-2	20	199,922.69	1/10		199,921.97	3/10		199,922.61	2/10
fp-250-3	30	320,662.68	1/10		320,678.30	1/10		320,662.56	5/10
fp-250-4	40	441,299.40	1/10		441,298.62	1/10		441,299.17	1/10
fp-250-5	50	563,247.92	1/10		563,247.65	2/10		563,247.65	6/10
fp-300-1	10	154,330.57	1/10		154,331.09	1/10		154,331.39	1/10
fp-300-2	20	356,043.84	1/10		356,039.22	1/10		356,040.62	1/10
fp-300-3	30	565,490.48	1/10		565,489.45	1/10		565,489.63	1/10
fp-300-4	40	783,711.26	1/10		783,709.32	3/10		783,709.91	1/10
fp-300-5	50	1,000,625.73	1/10		1,000,625.45	2/10		1,000,625.49	1/10
fp-350-1	10	249,112.84	1/10		249,114.28	1/10		249,110.44	1/10
fp-350-2	20	562,954.23	1/10		562,951.61	3/10		562,952.56	1/10
fp-350-3	30	911,284.92	1/10		911,282.29	1/10		911,282.43	1/10
fp-350-4	40	1,231,392.42	1/10		1,231,391.95	9/10		1,231,392.08	3/10
fp-350-5	50	1,613,558.41	1/10		1,613,566.90	1/10		1,613,556.83	1/10
fp-400-1	10	386,653.47	1/10		386,743.34	1/10		386,654.21	1/10
fp-400-2	20	876,251.03	1/10		876,397.39	1/10		876,249.84	1/10
fp-400-3	30	1,364,351.72	1/10		1,364,350.19	1/10		1,364,351.24	1/10
fp-400-4	40	1,891,287.22	1/10		1,891,288.12	1/10		1,891,286.00	1/10
fp-400-5	50	2,402,178.53	1/10		2,402,201.11	1/10		2,402,177.33	1/10
fp-500-1	10	786,842.68	1/10		786,969.73	1/10		786,842.67	1/10
fp-500-2	20	1,758,886.55	1/10		1,759,030.41	1/10		1,758,877.46	1/10
fp-500-3	30	2,761,373.74	1/10		2,761,365.07	1/10		2,761,360.16	1/10
fp-500-4	40	3,743,210.09	1/10		3,743,215.54	1/10		3,743,207.96	1/10
fp-500-5	50	4,769,878.64	1/10		4,769,890.27	1/10		4,769,865.88	1/10
						1/10
Average		1,191,140.57	1/10		1,191,162.45	1.64/10		1,191,138.32	1.48/10

and

Table 7. Average results of the SA-VNS, SA, and VNS algorithms on the FLMP instances with $n\in \{250,300,350,400,500\}$ ($\sigma$ denotes the standard deviation).

Instance	SA				VNS				SA-VNS
	${\mathit{F}}_{\mathrm{av}}$	$\mathit{\sigma }$	Time (s)		${\mathit{F}}_{\mathrm{av}}$	$\mathit{\sigma }$	Time (s)		${\mathit{F}}_{\mathrm{av}}$	$\mathit{\sigma }$	Time (s)
fp-250-1	83,972.41	9.69	309.1		83,989.08	24.31	136.0		83,974.56	9.74	244.9
fp-250-2	199,923.74	0.75	311.8		199,928.60	9.58	213.0		199,922.82	0.18	225.5
fp-250-3	320,663.10	0.29	262.2		320,708.82	15.33	168.2		320,662.58	0.02	294.8
fp-250-4	441,304.60	3.96	346.7		441,348.15	39.02	151.5		441,305.04	4.68	273.5
fp-250-5	563,248.58	0.55	313.9		563,256.91	17.61	265.7		563,247.91	0.43	232.8
fp-300-1	154,334.36	1.75	415.5		154,371.06	39.30	372.6		154,332.71	0.84	448.9
fp-300-2	356,050.91	4.20	447.8		356,096.58	30.29	263.2		356,049.30	8.48	448.3
fp-300-3	565,494.19	3.64	450.4		565,562.22	78.81	346.5		565,491.61	3.70	494.3
fp-300-4	783,712.53	1.35	519.8		783,736.29	35.46	400.7		783,719.28	11.83	501.1
fp-300-5	1,000,626.47	0.60	372.3		1,000,664.64	22.00	314.6		1,000,625.63	0.08	379.9
fp-350-1	249,116.40	2.01	628.0		249,159.59	61.47	756.2		249,114.50	2.24	845.7
fp-350-2	562,956.08	1.10	646.9		562,952.49	0.87	788.0		562,953.91	0.83	516.4
fp-350-3	911,290.26	3.48	511.5		911,467.91	85.92	619.8		911,286.78	5.07	690.4
fp-350-4	1,231,394.27	1.76	402.5		1,231,414.31	67.08	302.1		1,231,392.97	1.83	565.7
fp-350-5	1,613,563.93	3.35	629.8		1,613,713.99	176.64	643.8		1,613,560.33	2.77	696.6
fp-400-1	386,658.48	3.23	695.9		386,856.75	93.29	1196.6		386,658.05	2.89	1092.5
fp-400-2	876,254.97	2.70	894.4		876,564.70	164.65	1060.9		876,253.50	1.92	916.2
fp-400-3	1,364,357.17	2.89	841.7		1,364,492.14	110.10	1138.9		1,364,356.55	2.77	941.0
fp-400-4	1,891,293.04	4.25	1046.7		1,891,422.22	91.23	847.8		1,891,292.63	8.05	1063.2
fp-400-5	2,402,186.23	4.66	629.5		2,402,373.64	207.91	1147.8		2,402,186.21	5.89	852.6
fp-500-1	786,849.44	3.38	1564.4		787,245.14	185.07	2827.8		786,848.76	4.09	2209.5
fp-500-2	1,758,894.28	6.16	2356.0		1,759,277.74	136.88	2164.1		1,758,892.14	6.15	1499.0
fp-500-3	2,761,399.54	19.64	1774.5		2,761,692.28	249.29	3014.6		2,761,401.62	23.86	2320.4
fp-500-4	3,743,219.78	6.21	1772.8		3,744,446.32	1144.43	2624.6		3,743,218.69	7.62	1748.6
fp-500-5	4,769,888.93	6.08	2048.1		4,770,378.26	420.46	2095.6		4,769,888.73	11.21	2007.1
Average	1,191,146.15	3.91	805.7		1,191,324.79	140.28	954.4		1,191,145.47	5.09	860.3

. Their first column identifies the problem instance. The labels of the columns for each algorithm (SA, VNS, and SA-VNS) have the same meaning as those for the algorithms in Table 4 and Table 5. The bottom row of each table shows the results averaged over all 25 instances. The best value of $F_{\mathrm{best}}$ in Table 6 and $F_{\mathrm{av}}$ in Table 7 for each instance is highlighted in bold. From the tables, we can see that SA-VNS outperformed the other two algorithms. Both SA-VNS and VNS were able to produce the best solution for 12 problem instances. However, SA-VNS achieved the best average result for 20 instances, whereas VNS performed this for one instance only (as highlighted in Table 7). Inspecting Table 6, one can see that the success rate of the algorithms for most instances (in the case of SA, for all of them) was 1. This suggests that the FLMP instances containing 250 or more activities were quite difficult for the algorithms involved in our experiments. We also observe that the SA algorithm found the best solution and the best average cost solution for 2 and 4 instances, respectively. It can be concluded that both SA-VNS and SA have the ability to obtain better average results than VNS. Moreover, SA and SA-VNS exhibited much smaller standard deviation values compared with those obtained from VNS. Another observation is that all three algorithms are comparable with respect to computation time. This is illustrated by the plots in Figure 6, which show the average computation time as a function of the number of activities. For larger problem instances, the VNS algorithm is only slightly slower than SA and SA-VNS. Overall, we can conclude from the tables that the combination of the variable neighborhood search method with the simulated annealing technique resulted in a promising framework for solving the FLMP.

To ensure a more accurate assessment of the results, we applied the Wilcoxon signed-rank test for each pair of algorithms. The pairwise comparison results are summarized in

Table 8. Summary of the results obtained by the tested algorithms for large-scale instances.

Algorithm Pair	OFV	#Wins	#Ties	#Losses	p-Value	Statistical Significance
SA-VNS vs. SA	Best	23	0	2	<0.001	Yes
	Average	21	0	4	$0.01$	Yes
SA-VNS vs. VNS	Best	12	1	12	$0.05$	Yes
	Average	24	0	1	<0.001	Yes
SA vs. VNS	Best	12	0	13	>0.2	No
	Average	24	0	1	<0.001	Yes

. The column labeled OFV indicates which objective function values were compared: best solution values ($F_{\mathrm{best}}$ in Table 6) in the first row for each pair of algorithms and average solution values ($F_{\mathrm{av}}$ in Table 7) in the second row. The next three columns report the number of instances on which the first algorithm in the pair found a better (#wins), an equally good (#ties), or an inferior (#losses) solution when compared with the second algorithm. The penultimate column of the table shows the p-values obtained using the Wilcoxon test. For the last column, we used a standard significance level of $0.05$ to declare whether a significant difference existed or not. The value “Yes” means that the results of the first algorithm were better than those of the second algorithm, while the value “No” means that there was no statistical difference between the results of the two algorithms. A quick inspection of Table 8 shows that our SA-VNS hybrid technique was superior to the SA and VNS algorithms. The latter, in particular, exhibited poor performance regarding the average objective function value. These conclusions echo the findings in Section 5.2 (see Figure 3). We also applied the Friedman test followed by the Nemenyi post hoc test at a significance level of $0.05$. The computed Friedman statistics were $9.26$ and $38.32$ for the results reported in Table 6 and Table 7, respectively, both of which exceeded the critical value of $6.08$. Therefore, we conclude that the objective values obtained by the compared algorithms were statistically significantly different. The Nemenyi post hoc test further confirmed statistically significant pairwise differences between SA, VNS, and SA-VNS. Specifically, the ranking from best to worst was SA-VNS, VNS, and SA for the best objective values, and SA-VNS, SA, and VNS for the average objective values.

As shown in Figure 7, we illustrated the performance of SA-VNS on a couple of FLMP instances, fp-200-1 and fp-500-2, from our testbed. In each iteration of SA-VNS, the SA algorithm was first applied. Let us assume that the objective function value achieved by SA is denoted by $F_{\mathrm{SA}}$. In the second stage of the iteration, the SA solution can be improved by executing the VNS algorithm. We denote the objective function value of the resulting solution by $F_{\mathrm{SA}+\mathrm{VNS}}$ (thus, the objective function value achieved by SA-VNS equals the minimum of $F_{\mathrm{SA}+\mathrm{VNS}}$ when it has taken over all SA-VNS iterations). Figure 7 depicts the plots of $F_{\mathrm{SA}}-F_{\mathrm{SA}+\mathrm{VNS}}$ versus the SA-VNS iteration number. The average values of $F_{\mathrm{SA}}-F_{\mathrm{SA}+\mathrm{VNS}}$ are 3.29 and 7.05 for fp-200-1 and fp-500-2, respectively. They are calculated over 22 SA-VNS iterations for fp-200-1 and 39 SA-VNS iterations for fp-500-2. The SA-VNS algorithm found the best solution for fp-200-1 in Iteration No. 9 and the best solution for fp-500-2 in Iteration No. 19. The corresponding values of $F_{\mathrm{SA}}-F_{\mathrm{SA}+\mathrm{VNS}}$ in the figure are designated by a dot enclosed in a circle.

The two key components of the VNS algorithm are the shaking and local search mechanisms. To assess the contribution of each component, we conducted an additional experiment. In one variant of the SA-VNS algorithm, the shaking procedure was removed; instead, each VNS iteration started from a randomly generated permutation (we refer to this variant as SA-VNS-v1). In another variant, we replaced our fast local search technique (described in Algorithm 8) with a straightforward local search implementation, in which the objective function values of the examined solutions were computed directly using Equation (1). In this version, denoted SA-VNS-v2, the shaking mechanism was retained.

We compared the original algorithm and its two variants on a set of FLMP instances containing between 150 and 300 activities. The experimental results are reported in

Table 9. Performance comparison of SA-VNS and its two versions SA-VNS-v1 and SA-VNS-v2.

Instance	SA-VNS-v1			SA-VNS-v2			SA-VNS
	${\mathit{F}}_{\mathrm{best}}$	${\mathit{F}}_{\mathrm{av}}$		${\mathit{F}}_{\mathrm{best}}$	${\mathit{F}}_{\mathrm{av}}$		${\mathit{F}}_{\mathrm{best}}$	${\mathit{F}}_{\mathrm{av}}$
fp-150-1	16,192.51	16,193.12		16,193.03	16,193.81		16,192.50	16,192.60
fp-150-2	39,215.16	39,215.69		39,215.16	39,215.92		39,215.16	39,215.18
fp-150-3	63,831.99	63,832.45		63,832.32	63,833.16		63,831.99	63,831.99
fp-150-4	88,498.16	88,498.19		88,498.16	88,498.21		88,498.16	88,498.16
fp-150-5	118,010.53	118,010.54		118,010.53	118,010.61		118,010.53	118,010.53
fp-200-1	42,719.48	42,721.48		42,719.48	42,723.03		42,718.98	42,720.37
fp-200-2	98,502.94	98,503.06		98,502.94	98,503.14		98,502.94	98,502.94
fp-200-3	159,109.90	159,110.33		159,109.90	159,111.40		159,109.90	159,109.91
fp-200-4	227,060.86	227,061.23		227,060.86	227,065.34		227,060.86	227,060.86
fp-200-5	289,343.51	289,345.31		289,343.51	289,353.14		289,343.49	289,343.49
fp-250-1	83,963.22	83,976.66		83,963.22	83,980.23		83,962.00	83,974.56
fp-250-2	199,923.34	199,924.11		199,923.34	199,926.26		199,922.61	199,922.82
fp-250-3	320,662.68	320,663.38		320,662.68	320,665.49		320,662.56	320,662.58
fp-250-4	441,300.59	441,306.46		441,308.64	441,318.96		441,299.17	441,305.04
fp-250-5	563,247.97	563,248.73		563,248.50	563,250.00		563,247.65	563,247.91
fp-300-1	154,333.13	154,334.78		154,334.05	154,342.15		154,331.39	154,332.71
fp-300-2	356,043.84	356,054.91		356,046.64	356,067.14		356,040.62	356,049.30
fp-300-3	565,490.48	565,496.49		565,493.30	565,513.26		565,489.63	565,491.61
fp-300-4	783,711.26	783,723.82		783,711.26	783,750.34		783,709.91	783,719.28
fp-300-5	1,000,625.73	1,000,626.95		1,000,626.81	1,000,632.56		1,000,625.49	1,000,625.63

and Figure 8. The results indicate that SA-VNS-v1 and SA-VNS-v2 achieved the same $F_{\mathrm{best}}$ values as SA-VNS for only 7 and 6 out of 20 instances, respectively; for the remaining instances, they failed to match the performance of SA-VNS. An examination of the $F_{\mathrm{av}}$ values shows that SA-VNS consistently outperformed SA-VNS-v1 on average, while SA-VNS-v1, in turn, outperformed SA-VNS-v2 across all problem instances in the dataset. Part (a) of Figure 8 shows that SA-VNS-v2 exhibited a larger standard deviation of objective function values compared with SA-VNS and SA-VNS-v1, whereas the latter two algorithms are comparable regarding this metric. As shown in part (b) of Figure 8, all three algorithms required very similar computation times. Overall, these results demonstrate that SA-VNS significantly outperforms its variants SA-VNS-v1 and SA-VNS-v2.

5.4. Local Search Experiments

The performance of both our VNS heuristic and the ISA algorithm of Lin et al. [29] heavily depends on the local search technique used. To evaluate the convergence of the local search components of these algorithms, we conducted an experiment on a subset of random FLMP instances of various sizes. The local search procedure in ISA is called insertion-based heuristic [29]. We use the abbreviation IBH to refer to this heuristic. We ran both IBH and our LS procedure (shown in Algorithm 8) 100 times on each instance of size $n⩽100$ and 10 times on each instance of size $n>100$. The results are shown in

Table 10. Time comparison between LS and the local search algorithm of Lin et al. [29] (in seconds).

Instance	#Number of Runs	IBH [29]	LS	Time Ratio
fp-30-1	100	0.2	<0.1	12.7
fp-60-1	100	4.3	0.2	21.2
fp-100-1	100	44.3	1.1	40.6
fp-150-1	10	27.8	0.4	66.0
fp-200-1	10	107.5	1.2	89.3
fp-250-1	10	273.1	2.7	102.3
fp-300-1	10	658.7	5.2	126.2
fp-350-1	10	1222.6	9.0	136.6
fp-400-1	10	2157.1	13.7	157.9
fp-500-1	10	5743.0	33.4	172.2

. In each run, the algorithms started from a random initial solution. The efficiency of algorithms is measured regarding the average running time. We did not take into account the quality of the local minima the algorithm arrived at. We note that the IBH and LS algorithms were quite different from each other. Therefore, in general, they produced different solutions. However, the average objective function values obtained by these algorithms were very similar.

The results of the tested local search procedures were compared, as shown in Table 10. The problem instances selected for the experiment are listed in the first column. The second column shows the number of independent runs of the algorithms. The next two columns report the running time averaged over all runs for IBH and LS, respectively. The last column gives the ratio of the running times of IBH and LS. The table clearly shows that LS reached a local minimum much faster than IBH. Essentially, we see that, from the last column, LS took two orders of magnitude less computational time than the IBH procedure. Lin et al. [29] embedded IBH into their ISA algorithm. Based on this fact and the results of our experiment, one could argue that the slowness of IBH is the main reason why the ISA algorithm takes a much greater computation time in comparison with our SA-VNS hybrid approach.

6. Discussion

The design structure matrix has become an important modeling tool for managing complexity in product development projects. By representing process activities and their dependencies in a compact, square matrix, the DSM enables engineers and project managers to visualize the structure of information flows and to identify opportunities for process improvement. Its strength lies in highlighting feedback loops, i.e., iterations in which upstream activities require information from downstream activities. Such loops often disproportionately contribute to schedule delays and increased development costs. Two optimization problems arising from DSM analysis, the feedback minimization problem and the feedback length minimization problem (as given by Equation (2)), aim to reorder activities (or tasks) to reduce the impact of such iterative cycles. The FMP focuses on minimizing the number of feedback marks above the main diagonal of the DSM. This is useful for identifying activity sequences that achieve a more acyclic or feed-forward structure. However, minimizing the count of feedback alone may not fully capture the practical consequences of dealing with feedback loops. A single long-range feedback that spans many activities can be far more disruptive than several short-range ones. This limitation motivates the FLMP, which extends the feedback minimization problem by incorporating the length of feedback into the objective function. Feedback length corresponds to the distance between dependent activities in the chosen sequencing, which more directly reflects the expected duration and cost implications of rework or information iteration. As a result, the FLMP provides a more realistic basis for optimizing activity order in PD projects, especially in complex or tightly coupled engineering environments. By focusing on the reduction in long feedback loops, the FLMP aligns more closely with project management goals, such as shortening development time, reducing risk, and improving overall process efficiency. In practice, DSM-based optimization, using algorithms for the FLMP, supports decision makers in reorganizing processes to reduce iteration and uncertainty.

However, the FLMP is combinatorial and NP-hard, requiring heuristic or metaheuristic solution strategies for realistic PD project sizes. In this paper, we propose a hybrid approach that combines the strengths of the SA and VNS metaheuristics. The resulting SA-VNS algorithm compared very favorably with existing methods. Several factors contributed to its superior performance. First, the algorithm repeatedly applied both SA and VNS components, enabling effective exploration of the solution space. Second, SA produced high-quality initial solutions for the VNS phase, allowing VNS to focus immediately on the promising regions of the solution space. Third, VNS incorporated a fast local search procedure that significantly enhanced the algorithm’s exploitation capabilities.

The proposed method, however, has several limitations. First, SA is not a fast-converging metaheuristic; therefore, SA-VNS may require long computation times for particularly large-scale FLMP instances. Second, SA-VNS is a single-solution algorithm and does not use a population of individuals. In some cases, algorithms employing evolutionary strategies may achieve better performance.

7. Concluding Remarks

In this paper, we implemented an idea to integrate the two metaheuristics, simulated annealing and variable neighborhood search, into a single approach for solving the FLMP. During a run of the hybrid algorithm, its components SA and VNS were executed iteratively. At each iteration, starting from a randomly generated initial permutation, SA produced an improved solution and submitted it to VNS for possible further improvement. The key point of the VNS algorithm is the use of a fast insertion neighborhood exploration procedure. The computational complexity of this procedure is proportional to the size of the neighborhood and, thus, is the smallest possible up to a constant factor.

We conducted computational experiments to compare the performance of our SA-VNS hybrid and the insertion-based simulated annealing heuristic, ISA, which is the state-of-the-art algorithm for the FLMP. The experimental results demonstrate a clear superiority of our approach over ISA. On the one hand, SA-VNS required two orders of magnitude less CPU time than the ISA algorithm. On the other hand, SA-VNS produced equally good or better results across all tested problem instances. In particular, SA-VNS was able to find better solutions than ISA on all instances of size 150 or more. Our secondary aim was to compare the SA-VNS hybrid technique against the SA and VNS heuristics when treated as stand-alone algorithms. Using rigorous statistical tests, our results show that SA-VNS is superior to each of SA and VNS when running alone. We also carried out an experiment to assess the performance of local search procedures employed in the SA-VNS and ISA algorithms. From the results, it can be concluded that our LS procedure is particularly fast and well suited for implementation in the VNS algorithm. Despite the good performance of the SA-VNS algorithm, several limitations can be identified. First, as the problem size increases, the SA component struggles to obtain high-quality solutions within a short time, which may negatively affect the overall performance of the algorithm. Second, the VNS component may fail to efficiently explore the solution space for large-scale problem instances. These observations are supported by the experimental results, which show relatively large standard deviation values for the VNS method. Overall, the performance of SA-VNS deteriorates for FLMP instances with $n⩾250$. This can be seen in Table 6, where the success rate was the lowest possible, i.e., 1/10, in the majority of cases.

Future work may involve the development of reasonably fast metaheuristic-based algorithms capable of obtaining high-quality solutions for very large instances of the FLMP (say, with thousands of activities). An intriguing direction would be to apply evolutionary computing techniques (such as memetic algorithms) for solving the FLMP. Evolutionary algorithms can use the proposed local search procedure as a suitable mechanism for search intensification. Another important avenue for future work is to investigate the applicability of an SA and VNS hybrid algorithm for solving other optimization problems defined on permutations. In this line, it would be interesting to consider other DSM sequencing problems arising in the PD field. Important recent examples of such problems are scheduling interrelated activities in complex projects under high-order rework [71] and task sequencing to minimize project duration [72].