Next Article in Journal
Construction of Two-Derivative Runge–Kutta Methods of Order Six
Previous Article in Journal
A Novel Deep Learning Segmentation and Classification Framework for Leukemia Diagnosis
Previous Article in Special Issue
A Hybrid Optimization Framework with Dynamic Transition Scheme for Large-Scale Portfolio Management
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

An Efficient Closed-Form Formula for Evaluating r-Flip Moves in Quadratic Unconstrained Binary Optimization

1
School of Business Administration, The University of Mississippi, University, Oxford, MS 38677, USA
2
A.R. Sánchez Jr. School of Business, Texas A&M International University, Laredo, TX 78041, USA
3
Department of Management and Marketing, Southern University and A&M College, Baton Rouge, LA 70807, USA
*
Author to whom correspondence should be addressed.
Algorithms 2023, 16(12), 557; https://doi.org/10.3390/a16120557
Submission received: 11 November 2023 / Revised: 28 November 2023 / Accepted: 2 December 2023 / Published: 5 December 2023
(This article belongs to the Special Issue Metaheuristics)

Abstract

:
Quadratic unconstrained binary optimization (QUBO) is a classic NP-hard problem with an enormous number of applications. Local search strategy (LSS) is one of the most fundamental algorithmic concepts and has been successfully applied to a wide range of hard combinatorial optimization problems. One LSS that has gained the attention of researchers is the r-flip (also known as r-Opt) strategy. Given a binary solution with n variables, the r-flip strategy “flips” r binary variables to obtain a new solution if the changes improve the objective function. The main purpose of this paper is to develop several results for the implementation of r-flip moves in QUBO, including a necessary and sufficient condition that when a 1-flip search reaches local optimality, the number of candidates for implementation of the r-flip moves can be reduced significantly. The results of the substantial computational experiments are reported to compare an r-flip strategy-embedded algorithm and a multiple start tabu search algorithm on a set of benchmark instances and three very-large-scale QUBO instances. The r-flip strategy implemented within the algorithm makes the algorithm very efficient, leading to very high-quality solutions within a short CPU time.

1. Introduction

Quadratic unconstrained binary optimization is a classic NP-hard problem that has been used as a unifying approach to many combinatorial optimization problems [1,2]. Due to its practicality, as well as theoretical interest, over the years researchers have proposed many theoretical results as well as simple and sophisticated approaches as solution procedures [3,4,5,6,7,8,9,10]. However, due to the complexity and practicality of QUBO, it is still necessary to provide results suitable for solving large-scale problems. In recent years, researchers have developed theoretical results to reduce the algorithmic implementation difficulty of QUBO, [11,12,13,14,15,16]. Our results in this paper also help to reduce the size and difficulty of the algorithmic implementation of these problems.
Quadratic unconstrained binary optimization (QUBO) can be formulated as:
M a x   f x = i = 1 n q i x i + 1 2 i = 1 n j i n q i , j x i x j ,   s . t . x i 0,1 , i = 1 , , n
In Equation (1), 1 2 q i , j is the i,j-th entry of a given n by n symmetric matrix Q. QUBO is often referred to as the x T Q x model [17]. Since x i 2 = x i     f o r     x i = 0,1 , and Q may be written as an upper triangular matrix by doubling each entry of the upper triangle part of the matrix and letting q i , i = q i , then we can write Equation (1) as Equation (2).
M a x   f x = i = 1 n j i n q i , j x i x j = x T Q x ,   s . t . x _ i { 0,1 } , i = 1 , , n
Local search strategy (LSS) is one of the most fundamental algorithmic concepts and has been successfully applied to a wide range of hard combinatorial optimization problems. The basic ingredient of almost all sophisticated heuristics is some variation of LSS. One LSS that has been used by many researchers as a stand-alone or as a basic component of more sophisticated algorithms is the r-flip (also known as r-Opt) strategy [11,18,19,20,21,22]. In Table A4, we present a comprehensive review of r-flip strategies applied to QUBO. Let N = {1, 2, …, n}. Given a binary solution, x = x 1 , , x n of x T Q x , the r-flip search chooses a subset, S N , with S r , and builds a new solution, x , where x i = 1 x i for all i S . If x improves the objective function, it is called an improving move (or improving subset S). The r-flip search starts with a solution x, chooses an improving subset S, and flips all elements in S. The process continues until there is no subset S with S r that improves the objective function. The result is called a locally optimal solution with respect to the r-flip move (or r-Opt).
Often in strategies where variable neighborhood searches, such as fan-and-filter (F&F) [23,24], variable neighborhood search (VNS) [25,26], and multi-exchange neighborhood search (MENS) [18,19,20,21,22] are used, the value of r dynamically changes as the search progresses. Generally, there are two reasons for a dynamically changing search space strategy.
(a)
The execution of an implementation of an r-flip local search, for a larger value of r, can be computationally expensive to execute. This is because the size of the search space is of order n chosen r, and for fixed values of n, it grows quickly in r for the value of r n / 2 . Hence, smaller values of r, especially r equal to 1 and 2, have shown considerable success.
(b)
In practice, an r-flip local search process with a small value of r (e.g., r = 1) can quickly reach local optimality. Thus, as a way to escape 1-flip local optimality, researchers have tried to dynamically change the value of r as the search progressed. This offers an opportunity to expand the search to a more diverse solution space.
A clever implementation of (a) and (b) in an algorithm can not only save computational time but also possibly reach better solutions because the larger values of r provide an opportunity to search a more diverse part of the solution space.

Previous Works

The development of closed-form formulas for r-flip moves is desirable for developing heuristics for solving very-large-scale problem instances because it can reduce computational time consumed by the implementation of an algorithm. Alidaee and Kochenberger [11] introduced several theorems showing closed-form r-flip formulas for general pseudo-Boolean optimization. The authors in [12,13] recently provided closed-form formulas for evaluating r-flip rules in QUBO. In particular, Theorem 6 in [11] is specific to the f x = x T Q x problem. To explain the closed-form formula for the r-flip rule in x T Q x , we first introduce a few definitions. Refer to Table A4 for an exhaustive list of literature on r-flip rules applied to QUBO.
Given a solution x = x 1 , , x n , the derivative of f(x) with respect to x i is defined as:
E x i = q i + j < i q j , i x j + j > i q i , j x j ,   i = 1 , , n
Fact 1. Given a solution vector x = x 1 , , x i , , x n , and a solution x = x 1 , , 1 x i , , x n obtained by flipping the i-th element of x, we have:
f = f x f x = x i x i E x i .
It is well known that any locally optimal solution to an instance of the QUBO problem with respect to a 1-flip search satisfies
E i t h e r   ( x i = 0   i f f   E x i < 0 )   o r   x i = 1   i f f   E x i 0 ,   f o r   i = 1 , , n
Furthermore, after changing x to x′, the update for E x j , j = 1, …, n, can be calculated as follows:
j < i , E x j E x j + q j , i x i x i j > i , E x j E x j + q i , j x i x i = ,     E x j E x j       j = 1 , , n
Note that x i x i may be written as 1 2 x i , which can simplify the implementation process. A simple 1-flip search is provided in Algorithm 1. Note that in line 3 we chose a sequence to implement Fact 1. Using such a strategy has experimentally proven to be very effective in several recent studies [27].
Before we present the algorithms in this study for the r-flip strategy, the notations used are given as follows:
  • n: The number of variables;
  • x: A starting feasible solution;
  • x*: The best solution found so far by the algorithm;
  • K: The largest value of k for r-flip, k r;
  • Π(i): The i-th element of x in the order π(1)⋯π(n);
  • S: = {i:xi is tentatively chosen to receive a new value to produce a new solution xi′} restricting consideration to |S| = r;
  • D: The set of candidates for an improving move;
  • Tabu_ten: The maximum number of iterations for which a variable can remain tabu;
  • Tabu(i): A vector representing tabu status of x;
  • E ( x i ) : Derivative of f(x) with respect to x i ;
  • E ( x ) = ( E ( x 1 ) , , E ( x n ) ) The vector of derivatives;
  • X(.): A vector representing the solution of x;
  • E(.): A vector representing the value of derivative E ( x i ) .
Algorithm 1: 1-flip local search.
Initialize: n, x, evaluate the vector E(x)
Flag = 1
1  Do while (Flag = 1)
2        Flag = 0
3        Randomly choose a sequence  π ( 1 ) , , π ( n )  of integers 1,…,n.
4        Do I =  π ( 1 ) , , π ( n )
5               If  ( E ( x i ) < 0   and   x i = 1 )   or   ( E ( x i ) > 0   and   x i = 0 ):
x i = 1 x i , update the vector E(x) using Equation (6), Flag = 1
6        End do
7  End while
The result of Fact 1 was extended to the r-flip search, given below.
(Theorem 6, Alidaee and Kochenberger [11]) Let x be a given solution of QUBO and x′ obtained from x by the r-flip move (for a chosen set S), where S N , |S| = r. The change in the value of the objective function is:
f = f ( x ) f ( x ) = i S ( x i x i ) E ( x i ) + i , j S , i < j ( x i x i ) ( x j x j ) q i , j
Furthermore, after changing x to x′, the update for E ( x j ) , j = 1, , n, can be calculated as follows:
j N \ S , E x j E x j + i S x i x i q i , j j S , E x j E x j + i S \ { j } x i x i q i , j
As explained in [11], the evaluation of change in the objective function of Equation (7) can be done in O ( r 2 ) , i.e., evaluating f(x′) from f(x). The update in Equation (8) requires r calculations for each j in N\S, and r − 1 calculations for each j in S. Thus, overall, the update for all n variables can be performed in O(nr).
Note that for any two elements i,j = 1, …, n, and i < j, we can define:
E x i = E x i q i q i , j x j , E ( x j ) = E ( x j ) q j q i , j x i .
Using Equation (9), a useful way to express Equation (7) is Equation (10).
f = i S 1 2 x i E x i + j S , j i 1 x i x j q i , j                                              
A simple exhaustive r-flip search is provided in Algorithm 2. The complexity of the problem indicates that the use of a larger value of r in the r-flip local search can make the implementation of the search process more time consuming. Meanwhile, the larger value of r can provide an opportunity to search a more diverse area of search space and thus possibly reach better solutions. To overcome such conflicts, researchers often use r = 1 (and occasionally r = 2) as the basic components of their more complex algorithms, such as F&F, VNS, and MENS. Below, in Theorem 1 and Proposition 1, we prove that after reaching the locally optimal solution with respect to a 1-flip search, the implementation of an r-flip search can significantly be reduced. Further, related results are also provided to allow for the efficient implementation of an r-flip search within an algorithm.
Algorithm 2: Exhaustive r-flip local search.
Initialize: n, x, evaluate the vector E(x), value of r
Flag = 1
1    Do while (Flag = 1)
2    Flag = 0
3    For each combination S N   and   S r ,   evaluate   f , Equation (7):
If   f  > 0:
x i = 1 x 1 ,   for   i S , update E(x) using Equation (8), Flag = 1
4    End while

2. New Results on Closed-Form Formulas

We first introduce some notations. For m < n, define n m to be the number of combinations of m elements out of n, and let φ = Max i , j N q i , j and M = φ ( 2 , r ) . Furthermore, Lemmas 1 and 2, presented below, help to prove the results. Note that Lemma 1 is a direct deduction from previous results [11].
Lemma 1.
Given a locally optimal solution x = x 1 , , x n with respect to a 1-flip search, we have:
( x i x i ) E ( x i ) 0 ,   for   i = 1 ,   ,   n .
Proof. 
The condition of local optimality in Equation (5) indicates that:
E x i 0   iff   x i = 1 ,   and   E x i 0 ,   iff   x i = 0 .
Using this condition, we thus have:
( x i x i ) E ( x i ) 0 ,   for   i = 1 , , n .
Lemma 2.
Let  x = x 1 , , x n be any solution to the problem; then, we have:
i , j S x i x i x j x j q i , j M
Proof. 
For each pair of elements, i , j S , the left-hand side can be q i , j or q i , j . Since |S| = r, the summation on the left-hand side is, at most, equal to M. □
Theorem 1.
Let  φ  and M be as defined above and let  x = x 1 , , x n  be a locally optimal solution of  x T Q x  with respect to a 1-flip search. A subset  S N , with |S| = r, is an improving r-flip move if and only if we have:
i S E x i i , j S x i x i x j x j q i , j
Proof. 
Using Equation (7), a subset S N of r elements is an improving r-flip move if and only if we have:
f = f x f x = i S x i x i E x i + i , j S x i x i x j x j q i , j > 0
Since x is a locally optimal solution with respect to a 1-flip search, it follows from Lemma 1 that Inequality (14) is equivalent to Equation (15); that completes the proof.
i , j S x i x i x j x j q i , j > i S x i x i E x i = i S E x i
Proposition 1.
Let  φ  and M be as defined above and let  x = x 1 , , x n  be any locally optimal solution of the  x T Q x  problem with respect to a 1-flip search. If a subset  S N , with |S| = r, is an improving r-flip move, then we must have  i S E x i < M .
Proof. 
Since x is a locally optimal solution with respect to a 1-flip search and S is an improving r-flip move, based on Theorem 1, we have:
i S E x i < i , j S x i x i x j x j q i , j
Using Lemma 2, we also have Equation (17), which completes the proof.
i S E x i < i , j S x i x i x j x j q i , j M
The consequence of Theorem 1 is as follows. Given a locally optimal solution x with respect to a 1-flip search, if there is no subset of S with |S| = r that satisfies Equation (13), then x is also locally optimal solution with respect to an r-flip search. Furthermore, if there is no subset S of any size that satisfies Equation (13), then x is also locally optimal solution with respect to an r-flip search for all r n . Similar statements are also true regarding Proposition 1.
The result of Proposition 1 is significant in the implementation of an r-flip search. It illustrates that, after having a 1-flip search implemented, if an r-flip search is next served as a locally optimal solution, only those elements with the sum of the absolute value of derivatives less than M are eligible for consideration. Furthermore, when deciding on the elements of an r-flip search, we can easily check to see whether any element x i by itself or with a combination of other elements is eligible to be a member of an improving r-flip move S. Example 1 below illustrates this situation.
Example 1.
Consider an  x T Q x  problem with n variables. Let  x = x 1 , , x n  be a given locally optimal solution with respect to a 1-flip search. Consider S = {i,j,k,l} for a possible 4-flip move. In order to have S for an improving move, all 15 inequalities, given below in Equation (18), must be satisfied. Of course, if the last inequality in Equation (18) is satisfied, all other inequalities are also satisfied. This means that each subset of the S is also an improving move. This is important in any dynamic neighborhood search strategy k-flip move for  k r  in consideration.
Here   we   have   φ = M a x i , j N q i j   and   M = 6 φ : E x a < M   for   a = i , j , k , l , E x a + E x b < M   for   a b , a , b = i , j , k , l , E x a + E x b + E x c < M   for   a b c , a , b , c = i , j , k , l ,                                     | E ( x a ) | + | E ( x b ) | + | E ( x c ) | + | E ( x d ) | < M   for   a = i , b = j , c = k , d = l
Obviously, choosing the appropriate subset S to implement a move is critical. There are many ways to check for an improving subset S. Below, we explain two such strategies. In addition, a numerical example is given in Appendix A.

2.1. Strategy 1

We first define a set, D(n), of candidates for improving moves. Given a locally optimal solution x with respect to a 1-flip move, let the elements of x be ordered in ascending absolute value of derivatives, as given in Equation (19).
| E ( x π ( 1 ) ) | | E ( x π ( n ) ) |
Here, π ( i ) means the i-th element of x in the order ( π ( 1 ) , , π ( n ) ) . Let K be the largest value of k = 1, 2,…, n, where Inequality (20) is satisfied. The set D(n) is now defined by Equation (21).
i = 1 k | E ( x π ( i ) ) | < M   for   k = 1,2 , 3 , , n
D ( n ) = { x π ( 1 ) , , x π ( K ) }
Lemma 3.
Any subset  S D ( n )  satisfies the necessary condition for an improving move.
Proof. 
It follows from Proposition 1.
There are some advantages to having elements of x in an ascending order, i.e., Inequality (19):
I.
The smaller the value of | E ( x i ) | is, the more likely that x i is involved in an improving k-flip move for k ≤ r (this might be due to the fact that the right-hand-side value M in Equation (20) for a given r is constant. Thus, smaller values of | E ( x i ) | on the left-hand side might help to satisfy the inequality more easily.
II.
Because the elements of D(n) are in ascending order of absolute values of derivatives, a straightforward implementable series of alternatives to be considered for improving subsets, S, may be the elements of the set given in Equation (22). Note that there are many more subsets of D(n) compared to the sets in Equation (21) that are candidates for consideration in possible k-flip moves. Here, we only provide one possible efficient implementable strategy.
S { π ( 1 ) , π ( 2 ) } , { π ( 1 ) , π ( 2 ) , π ( 3 ) } , , { π ( 1 ) , , π ( K ) }
It is important to note that, if Proposition 1 is used in the process of implementing an algorithm given a locally optimal solution x with respect to a 1-flip search, after an r-flip implementation for a subset |S| = r with r > 1, the locally optimal solution with respect to a 1-flip search for the new solution, x′, can be destroyed. Thus, if an r-flip search needed to be continued, a 1-flip search might be necessary on solution x′ before a new r-flip move could continue. However, there are many practical situations where this problem may be avoided for many subsets, especially when the problem is very large scale, i.e., the value of n is large and/or Q is sparse. Proposition 2 is a weaker condition of Proposition 1 that can help be overcome to a certain point in the aforementioned problem.
In the proof of Theorem 1 and Proposition 1, we only used a condition of optimality for a 1-flip search satisfied for the members of the subset S. We now define a condition as follows and call it “condition of optimality with respect to a 1-flip search for a set S”, or simply, “condition of optimality for S”.
Given a solution x, the condition of optimality for any subset S N is satisfied if and only if we have:
E i t h e r     ( x i = 0   i f f   E i < 0 )     o r     ( x i = 1     i f f   E ( i ) 0 )   for   i S
Of course, if we have N in Equation (23) instead of S, x is a locally optimal solution, as was defined in Fact 1.
For m < n, let (m, n) be the number of combinations of m elements out of n elements, φ S = max i , j S q i , j , and M S = φ S ( 2 , r ) . With these definitions, we now state Proposition 2.
Proposition 2.
(Weak necessary condition): Let  S N , |S| = r, and  φ S  and  M S  are as defined above. Given any solution  x = x 1 , , x n  of  x T Q x , assume the condition of optimality is satisfied for a subset S. If S is an r-flip-improving move, we must have  i S | E ( x i ) | < M S .
Proof. 
Similar to the proof of Proposition 1.
Notice that the values of  φ S and M S in Proposition 2 depend on S; however, these values can be updated efficiently as the search progresses. As explained above, in situations where the problem is very large scale and/or Q is sparse, for many variables, the values of derivatives are “unaffected” by the change in values of the elements in S. This means that a large set of variables still satisfies the condition of optimality, and thus, the search can continue without applying a 1-flip search each time before finding a new set S for r-flip implementation. □

2.2. Strategy 2

Another efficient and easily implementable strategy is when, instead of using Equation (20), we only use an individual element to create a set of candidates for applying an r-flip search, set D(1), as defined below. Corollary 1 is a special case of Proposition 1 that suffices for such a strategy.
D ( 1 ) = { x i : | E ( x i ) | < M }
Corollary 1
. Let φ and M be as defined before. Given a solution  x = x 1 , , x n of  x T Q x , if the 1-flip local search cannot further improve the value of f(x), and  i S   with  S N , where an r-flip move of elements of S improves f(x), then we must have | E ( x i ) | < M .
To gain insight into the use of Corollary 1, we carried out some experimentation to find the size of set D(1) for different sizes of instances. The steps of the experiment to find the size of D(1) are provided below. The problems considered were taken from Ref. [26] and have been used by many researchers. We only used the larger-scale problems with 2500 to 6000 variables for a total of 38 instances.
Find_D(): Procedure for finding the size of set D(1):
  • Step 1. Randomly initialize a solution to the problem. For each value of r, calculate M. Apply the algorithm in Algorithm 1 and generate a locally optimal solution x with respect to a 1-flip search. However, in Step 5 of Algorithm 1, only consider the derivatives with | E ( x i ) | < M .
  • Step 2. Find the number of elements in set D(1) for x.
  • Step 3. Repeat steps 1 and 2 200 times for each problem and find the average number of elements in set D(1) for the same size problem, density, and r-value.
The results of the experiment are shown in Table 1. From Table 1, in general we can say that, as the density of matrix Q increased, the size of D(1) decreased for all problem sizes and values of r. This is, of course, due to the fact that the larger density of Q made the derivative of each element in x more related to other elements. As the size of a problem increases, the size of D(1) also increases.
An interesting observation in our experiment is that, in most cases, the size of D(1) for better locally optimal solutions was smaller than those with the worse locally optimal solutions. This indicates that, as the search reaches closer to the globally optimal solutions, the time for an r-flip search decreases when we take advantage of Corollary 1.

2.3. Implementation Details

We first implement two strategies in Section 2.1 and Section 2.2 via Algorithm 3 for Strategy 1 and Algorithm 4 for Strategy 2, and then proposed Algorithm 5 for Strategy 2 embedded with a simple tabu search algorithm for the improvement in Algorithm 5. A summary of the methodology used in this research is provided as follows:
We started by choosing the appropriate subset S to implement a move. There were two strategies employed at this step that required the utilization of two different algorithms.
Algorithm 3 was applied for Strategy 1, which involved defining a set of candidates for improving moves, given a locally optimal solution with respect to a 1-flip move.
Algorithm 4 was applied for Strategy 2, which involved using an individual element to create a set of candidates for applying an r-flip search.
Algorithm 5 was applied for improvement, which involved a tabu search algorithm.
The detailed pseudo-code of Algorithms 3–5 is provided below:
Algorithm 3: r-flip local search: strategy 1
Initialize: n, x, evaluate vector E(x), value of r, M
Flag = 1
1  Do while (Flag = 1)
2        Flag = 0
3        Call 1-flip local search: Algorithm 1
4        Sort variables according to   E ( x π ( i ) ) E ( x π i + 1 ) ,  using Inequality (20) evaluate value of K
5        For   j = π 1 , , π K :
6                    For   S j = π 1 , , π ( j ) ,   evaluate   M S j
If     i = 1 j E ( x π ( i ) ) < M S j , evaluate ∆f using Equation (7).
7                    If   f  > 0:
x i = 1 x i ,   for   i S j ,  update E(x) using Equation (8), Flag = 1, go to Step 1
8        End for
9      End while
Algorithm 4: r-flip local search: strategy 2
Initialize: n, x, evaluate E(x), value of r, M
Flag = 1
1  Do while (Flag = 1)
2           Flag  = 0 ,   and   S =
3           Call 1-flip local search: Algorithm 1
4           Randomly choose a sequence   π ( 1 ) , , π ( n )   of   integers   1 , , n
5           For   j = π ( 1 ) , , π ( n ) :
6                    If   E ( x j ) < M ,   and   S { j } r   evaluate   f   for   S { j }  using Equation (7)
7                    If   f > 0:
x i = 1 x i ,   for   i   S { j } ,  update E(x) using Equation (8),   S = S j ,
Flag =1, go to Step 1
8           End for
9   End while
Algorithm 5: Hybrid r-flip/1-flip local search embedded with a simple tabu search algorithm
Initialize: n, x, tabu list, evaluate E(x), value of r, M, tabu tenure
Call local search: Algorithm 4
Do while (until some stopping criteria, e.g., CPU time limit, is reached)
Call Destruction()
Call Construction()
Call randChange()
End while
In the Destruction() procedure, there are three steps:
  • Step 3a. Find the variable that is not on the tabu list and lead to the small change to the solution when the variable is flipped.
  • Step 3b. Change its value, place it on the tabu list to update the tabu list, and update E(x).
  • Step 3c. Test whether there is any variable that is not on the tabu list and that can improve the solution. If not, go to Step 3a.
In the Construction() procedure, there are four steps:
  • Step 4a. Test all of the variables that are not on the tabu list. If a solution better than the current best solution is found, change its value, place it on the tabu list, update E(x), update the tabu list, and go to Step 1.
  • Step 4b. Find the index i corresponding to the greatest value of E(xi), change its value of xi, place it on the tabu list to update the tabu list, and update E(x).
  • Step 4c. If this is the 15th iteration in the Construction() procedure, go to Step 1.
  • Step 4d. Test whether there is any variable that is not on the tabu list and that can improve the solution. If not, go to Step 3a. If yes, go to Step 4a.
The randChange() procedure is invoked occasionally and randomly to select an x for the Destruction() using a random number generator. There is a probability of less than 2% of invoking after the Construction() procedure. To get the 2% probability, a random number generator is used to create an integer between 1 and 1000. If the value of the integer is smaller than 20, the randChange() is invoked. The variable chosen in the randChange() will lead to the change of E(x) for Destruction().
Any local search algorithm, e.g., Algorithms 3 or 4, can be used in Step 1 of this simple tabu search heuristic. However, a limited preliminary implementation of Algorithms 3 and 4 within Algorithm 5 suggests that, due to its simplicity of implementation and computational saving time, Algorithm 4 with slight modification was quite effective; thus, we used it in Step 1 of Algorithm 5. The slight modification was as follows. If the solution found by a 1-flip is worse than the current best-found solution, quit the local search and go to Step 2.
In order to determine whether the hybrid r-flip/1-flip local search algorithms with two strategies (Algorithms 3 and 4) perform better than the hybrid r-flip/1-flip local search embedded with a simple tabu search implementation, we compared Algorithms 3 and 4 to Algorithm 5.
The goal of the new strategies is to reach local optimality on large-scale instances with less computing time. We report the comparison of the three algorithms of a 2-flip on very-large-scale QUBO instances in the next section.

3. Computational Results

In this study, we performed substantial computational experiments to evaluate the proposed strategies for problem size, density, and r-value. We compared the performance of Algorithms 3–5 for r = 2 on very-large-scale QUBO instances. We also compared the best algorithm among Algorithms 3–5 to one of the best algorithms for x T Q x , i.e., Palubeckis’s multiple start tabu search. We coded the algorithms in C++ programming language.
In [28], there are five multiple start tabu search algorithms, and the MST2 algorithm had the best results reported by the author. We chose the MST2 algorithm with the default values for the parameters recommended by the author [28]. In the MST2 algorithm, the number of iterations as the stopping criterion for the first tabu search start subroutine is 25,000× the size of the problem, and then the MST2 algorithm reduces the number of iterations to 10,000× the size of problem as the stopping criterion for the subsequent tabu search starts. Within the tabu search subroutine, if an improved solution is found, then the MST2 algorithm invokes a local search immediately. The CPU time limit in the MST2 algorithm is checked at the end of the tabu search start subroutine. Thus, the computing time might exceed the CPU time limit for large instances when choosing short CPU time limits.
All algorithms in this study were compiled by GNU C++ compiler v4.8.5 and run on a single core of Intel Xeon Quad-core E5420 Harpertown processors, which have a 2.5 GHz CPU with an 8 GB memory. All computing jobs were submitted through the Open PBS Job Management System (Version 3) to ensure that both methods used the same CPU for memory usage and CPU time limits in the same instance.
Preliminary results indicate that Algorithms 3–5 performed well in instances with a size of less than 3000 and low density. All algorithms found the best-known solution with a CPU time limit of 10 s. Thus, we only compared the results of large instances with high density and a size of 3000 to 8000 with the MST2 algorithm and the best algorithm among Algorithms 3–5. These benchmark instances with sizes of 3000 to 8000 have been reported by other researchers [5,12]. In addition, we generated some very-large-scale QUBO instances with a high density and size of 30,000 using the same parameters from the benchmark instances. We used a CPU time limit of 600 s and r = 2 for Algorithms 3–5 in the very-large-scale instances in Table 2. We adopted the following notation for the computational results:
  • OFV: The value of the objective function for the best solution found by each algorithm;
  • BFS: The best solution found among algorithms within the CPU time limit;
  • TB [s]: Time for each algorithm to reach the best solution in seconds;
  • AT [s]: Average computing time out of 10 runs to reach OFV;
  • DT: % Deviation of computing time out of 10 runs to reach OFV.
Table 2 shows the results of the comparison for Algorithms 3–5 on very-large-scale instances out of 10 runs. Algorithm 5 produced a better solution than Algorithms 3 and 4 with r = 2; thus, we used Algorithm 5 with r = 1 and r = 2 to compare to the MST2 algorithm. We imposed a CPU time limit of 60 s and 600 s per run, with 10 runs per instance on Algorithm 5 and the MST2 algorithm. We choose a tabu tenure value of 100 for 1-flip and 2-flip.
In our implementation, we chose the CPU time limit as the stopping criterion and checked the CPU time limit before invoking the tabu search in Algorithm 5. Because the MST2 algorithm and Algorithm 5 are not single point-based search methods, the choice of the CPU time limit as the stopping criterion seemed to be a fair performance comparison method between the algorithms.
Table 3 describes the size and density of each instance and the number of times out of 10 runs the OFV was reached as well as the solution deviation within the CPU time limit for the MST2 algorithm and Algorithm 5 with r = 1 and r = 2. The MST2 algorithm produced a stable performance and reached the same OFV frequently out of 10 runs. Algorithm 5 started from a random initial solution and could search for a more diverse solution space within a short CPU time limit. When the CPU time limit was changed to 600 s, the MST2 algorithm and Algorithm 5 produced a better-quality solution in terms of the relative standard deviation [29]. The relative standard deviation (RSD) in Table 3 in parenthesis was measured by R S D = 100 σ μ , σ = ( f x f x ¯ ) 2 n , and μ = f x ¯ , where f(x) is the OFV of each run and f ( x ) ¯ is the mean value of the OFV out of n = 10 runs. For some instances, the relative standard deviation (RSD) was less than 5.0 × 10−4 even though not all runs found the same OFV. We used 0.000 as the value of RSD when the value was rounded up to three decimal points.
Table 4 reports the computational results of the CPU time limit of 60 s, and Table 5 reports the computational results of the CPU time limit of 600 s. In Table 4, it can be seen that the MST2 algorithm matched 5 out of 27 of the best solutions within the CPU time limit. The 1-flip strategy in Algorithm 5 matched 26 out of 27 of the best solutions, whereas the 2-flip strategy in Algorithm 5 matched 18 out of 27 of the best solutions. For the MST2 algorithm, the computing time to find the initial solution exceeded the CPU time limit of 60 s for two large instances.
When the CPU time limit was increased to 600 s, the MST2 algorithm matched 10 out of 27 of the best solutions. The 1-flip strategy matched 25 out of 27 of the best solutions, and the 2-flip strategy matched 23 out of 27 of the best solutions. The 1-flip and 2-flip strategies in Algorithm 5 performed well on the large, high-density instances. There was no clear pattern of the 2-flip strategy being used more often than the 1-flip strategy to find the same OFV. The 1-flip and 2-flip strategies in Algorithm 5 chose the initial solution randomly and independently. The 1-flip strategy had better performance when the CPU time limits were 60 and 600 s.
Table 6 and Table 7 present the time deviation of each algorithm upon reaching the OFV for each instance. The MST2 algorithm had less variation in computing time when it finding the OFV, whereas the r-flip strategy in Algorithm 5 had a wider range of computing time. If the algorithm only found the OFV once out of 10 runs, the time deviation was zero.
The r-flip strategy can be embedded in other local search heuristics as an improvement procedure. Clever implementation of the r-flip strategy can reduce the computing time and improve the solution quality. We reported the time and solutions out of 10 runs for each instance. The time deviation and solution deviation of 10 runs were computed with the short CPU time limits due to the computing resources available to this study.
The observed results show the effectiveness of the employed methodology in finding the best solutions within very competitive CPU time limits. This suggests the possibility of using alternative stopping criteria as a potential improvement in the future. Also, the application of an efficient strategy in evaluating flip moves has the potential to further improve the algorithm performance, as suggested by Anacleto et al. [12].
The r-flip method we developed presents itself as a compelling alternative for quantum computing solvers, which are capable of efficiently handling QUBO problems as large as 5000 by 5000 variables due to the design of quantum processors. The advantages of the r-flip method become particularly pronounced when dealing with substantial, complex problem instances, showcasing superior computing performance. In essence, our method emerges as a favorable choice for addressing large-scale, real-world challenges with efficacy and computational prowess.

4. Conclusions

In this study, we explored the quadratic unconstrained binary optimization (QUBO) problem, which produced significant findings. We established a necessary and sufficient condition for the local optimality of an r-flip search after a 1-flip search had already achieved local optimality. Our computational experiments demonstrated a substantial reduction in candidate options for r-flip implementation. The new r-flip strategy efficiently solved extremely large QUBO instances within 600 s, outperforming MST2 in terms of the time taken to reach the best-known solutions in benchmark instances. These results are particularly promising for implementing variable neighborhood strategies on extensive problems or sparse matrices.
Similar to other quadratic unconstrained binary optimization (QUBO) methods, our approach is subject to scalability constraints. The size of the Q matrix, representing the number of variables in the problem, is inherently restricted by the memory limitations of the computer system. In practical terms, our methodology exhibits robust performance, successfully tackling problem instances of up to 200,000 by 200,000 in dense matrices, with the potential to extend its capabilities to 500,000 by 500,000 in sparse matrices. This underscores the versatility and efficiency of our approach within the specified computational constraints, demonstrating its applicability to a wide range of problem sizes and structures.

Author Contributions

Conceptualization, B.A. and H.W.; methodology, B.A.; validation, B.A., H.W. and L.S.S.; formal analysis, H.W.; investigation, H.W.; data curation, H.W.; writing—original draft preparation, B.A.; writing—review and editing, H.W. and L.S.S.; visualization, B.A.; All authors have read and agreed to the published version of the manuscript.

Funding

This research received no external funding.

Data Availability Statement

The instance data and solutions will be made available upon request.

Conflicts of Interest

The authors declare no conflict of interest.

Appendix A. Numerical Example for Theorem 1 and Proposition 1

Consider the problem with the Q matrix provided below in Figure A1. A locally optimal solution x with f(x) = 1528 and the vector of derivatives E(x) is shown in Table A1. For r = 2, M = 100, every two elements that satisfy Proposition 1 are shown in Table A1. However, the only sets of two-element combinations that were improved are those shown with the red font in Figure A2. These are the two elements that satisfied Theorem 1. The new results of f(x) and E(x) for the two elements are shown in Table A2. In this simple problem, instead of comparing 380 two-element combinations, we only needed to compare 21 combinations. Out of these 21 combinations, the 6 possible improved combinations are shown in Table A3.
Figure A1. Matrix Q for maximizing x T Q x .
Figure A1. Matrix Q for maximizing x T Q x .
Algorithms 16 00557 g0a1
Table A1. A locally optimal solution, x(.), and values of E(xi), i = 1,…, n.
Table A1. A locally optimal solution, x(.), and values of E(xi), i = 1,…, n.
x(.) 11001010010111011010
E(.) 624177−74−459209−744−7−120523−12423322114−3431375−89242−66
f(x) 15286241270055070003830358104089−50200
In Figure A1 and Table A1, we have:
E(x1) = −30 + (50 ∗ 1 – 68 ∗ 0 – 66 ∗ 0 + 94 ∗ 1 – 100 ∗ 0 – 20 ∗ 1 – 4 ∗ 0 + 80 ∗ 0 + 94 ∗ 1 + 0 ∗ 0 + 86 ∗ 1 + 76 ∗ 1 + 98 ∗ 1 − 36 ∗ 0 + 76 ∗ 1 + 52 ∗ 1 − 8 ∗ 0 + 48 ∗ 1 + 42 ∗ 0) = 624
E(x2) = −7 + 50 ∗ 1 + (50 ∗ 0 + 28 ∗ 0 + 60 ∗ 1 + 56 ∗ 0 − 54 ∗ 1 + 78 ∗ 0 + 4 ∗ 0 + 30 ∗ 1 − 42 ∗ 0 − 28 ∗ 1 − 50 ∗ 1 + 90 ∗ 1 − 42 ∗ 0 + 90 ∗ 1 − 26 ∗ 1 + 6 ∗ 0 + 22 ∗ 1 + 0 ∗ 0) = 177
E(x3) = −26 + (−68 ∗ 1 + 50 ∗ 1) + (−46 ∗ 0 + 26 ∗ 1 + 82 ∗ 0 − 50 ∗ 1 − 90 ∗ 0 + 44 ∗ 0 − 94 ∗ 1 + 54 ∗ 0 + 52 ∗ 1 − 50 ∗ 1 + 54 ∗ 1 − 68 ∗ 0 − 52 ∗ 1 + 20 ∗ 1 + 96 ∗ 0 + 64 ∗ 1 − 22 ∗ 0) = −74
E(x4) = −35 + (−66 ∗ 1 + 28 ∗ 1 − 46 ∗ 0) + (8 ∗ 1 − 82 ∗ 0 − 84 ∗ 1 − 46 ∗ 0 − 34 ∗ 0 − 22 ∗ 1 − 62 ∗ 0 − 34 ∗ 1 − 56 ∗ 1 − 86 ∗ 1 + 18 ∗ 0 + 44 ∗ 1 − 84 ∗ 1 + 2 ∗ 0 − 72 ∗ 1 − 60 ∗ 0) = −459
for E(x5) to E(x19)
E(x20) = 22 + (42 ∗ 1 + 0 ∗ 1 − 22 ∗ 0 − 60 ∗ 0 + 14 ∗ 1 + 2 ∗ 0 − 70 ∗ 1 + 94 ∗ 0 − 16 ∗ 0 + 0 ∗ 1 + 52 ∗ 0 + 28 ∗ 1 − 96 ∗ 1 + 64 ∗ 1 − 34 ∗ 0 + 10 ∗ 1 − 26 ∗ 1 + 80 ∗ 0 − 54 ∗ 1) = −66
f(x1) = 1 ∗ (−30 + 50 + 94 − 20 + 94 + 86 + 76 + 98 + 76 + 52 + 48) = 624
f(x2) = 1 ∗ (−7 + 60 − 54 + 30 − 28 − 50 + 90 + 90 − 26 + 22) = 127
f(x3) = 0 ∗ (26 − 50 − 94 + 52 − 50 + 54 − 52 + 20 + 64) = 0
for f(x4) to f(x19)
f(x20) = 0 ∗ (22) = 0
f(x) = 624 + 127 + 55 + 70 + 383 + 3 + 58 + 104 + 89 − 5 + 20 = 1528
Figure A2. The indicated elements satisfy Proposition 1. Only the two-element combinations indicated by the red font can improve f(x), which satisfies Theorem 1, whereas the ones indicated by the black font cannot.
Figure A2. The indicated elements satisfy Proposition 1. Only the two-element combinations indicated by the red font can improve f(x), which satisfies Theorem 1, whereas the ones indicated by the black font cannot.
Algorithms 16 00557 g0a2
Table A2. An improvement using 2-flip for the locally optimal solution, x, and values of E(xi), i = 1, …, n.
Table A2. An improvement using 2-flip for the locally optimal solution, x, and values of E(xi), i = 1, …, n.
x(.) 11001001010111111011
E(.) 646267−204−463275−83−120199−270367−782695834849347361−1237864
f(x) 1684646217001210035031508310240−3999−310−3422
In Figure A2 and Table A2, we have:
f(x1) = 1 ∗ (−30 + 50 + 94 − 4 + 94 + 86 + 76 + 98 − 36 + 76 + 52 + 48 + 42) = 646
f(x2) = 1 ∗ (−7 + 60 + 78 + 30 − 28 − 50 + 90 − 42 + 90 − 26 + 22) = 217
for f(x3) to f(x18)
f(x19) = 1 ∗ (20 − 54) = −34
f(x20) = 1 ∗ (22) = 22
f(x) = 646 + 217 + 121 + 35 + 315 + 83 + 10 + 240 − 39 + 99 − 31 − 34 + 22 = 1684
Table A3. All 6 possible improved combinations for the locally optimal solution (f(x) = 1528).
Table A3. All 6 possible improved combinations for the locally optimal solution (f(x) = 1528).
110010010101111110111684
111011001101110111101646
110010110101010110111633
110010110111011110111616
111011000101110110101601
111010100111010110111530
110010100101110110101528
Table A4. An exhaustive search of r-flip rules for QUBO.
Table A4. An exhaustive search of r-flip rules for QUBO.
Studyr-Flip Rules
Debevre, P, Sugimura, M, and Parizy, M, Ieee Access, 2023 [2].The automotive paint shop problem was formulated as QUBO, then 1-flip and multiple flip moves provided for the solution.
Glover, F, and Hao, J-K, Int. J. Metaheuristics, 2010 [6].An efficient evaluation of 2-flip moves for QUBO was presented.
Glover, F, and Hao, J-K, Annals of Operations Research, 2016 [7].A class of approaches called f-flip strategies that include a fractional value for f is provided for QUBO.
Lozano, M, Molina, D, and Garcia-Martinez, C, European Journal of Operational Research, 2011 [10].A maximum diversity QUBO problem was considered with an added number of variables that must be equal to an integer m. A 2-flip strategy with computational experiment was presented.
Alidaee, B., G. Kochenberger, and H. Wang, Int. J. Appl. Metaheuristic Comput., 2010 [11].Several theoretical results for r-flip moves in a general pseudo-Boolean optimization including QUBO were demonstrated.
Anacleto, E, Meneses, C, Ravelo, S, Computers & Operations Research, 2020 [12].Two closed-form formulas for evaluating r-flip moves were presented. The effectiveness of the moves was evaluated experimentally.
Anacleto, E, Meneses, C, and Liang, T, Computers & Operations Research, 2021 [13].An r-flip move strategy for a quadratic assignment problem that can be transferred to QUBO was considered. A closed-form formula and experimental evaluations were considered.
Katayama, K, and Naihisa, H, in: W. Hart, N. Krasnogor, J.E. Smith (Eds.), Recent Advances in Memetic Algorithms, Springer, Berlin, 2004 [30].A k-flip move in the context of a memetic algorithm was presented.
Liang, R.N, Anacleto, E.A.J, and Meneses, C.N. Computers & Operations Research, 2023 [31].A closed-form formula for pseudo-Boolean optimization and data structure for efficient implementation of the 1-flip rule was presented.
Merz, P, and Freisleben, B, Journal of Heuristics, 2002 [32].Provided 1-flip and multiple-flip strategies for QUBO and provided a computational experiment.
Rosenberg, G., Vazifeh, M, Woods, B, and Haber, E, Computational Optimization and Applications, 2016 [33]. A k-flip strategy in the context of a quantum annealer was presented.
Alidaee, B., Wang, H., and Liu, W. Working Paper, WP 2021-002. Texas A&M International University, 2022 [34].New Results on Closed-Form Formulas for Evaluating r-flip Moves in Quadratic Unconstrained Binary Optimization.

References

  1. Boros, E.; Hammer, P.L.; Minoux, M.; Rader, D.J. Optimal cell flipping to minimize channel density in VLSI design and pseudo-Boolean optimization. Discret. Appl. Math. 1999, 90, 69–88. [Google Scholar] [CrossRef]
  2. Debevre, P.; Sugimura, M.; Parizy, M. Quadratic Unconstrained Binary Optimization for the Automotive Paint Shop Problem. IEEE Access 2023, 11, 97769–97777. [Google Scholar] [CrossRef]
  3. Glover, F.; Kochenberger, G.; Du, Y. Quantum Bridge Analytics I: A tutorial on formulating and using QUBO models. Ann. Oper. Res. 2019, 17, 335–371. [Google Scholar] [CrossRef]
  4. Glover, F.; Kochenberger, G.A.; Alidaee, B. Adaptive Memory Tabu Search for Binary Quadratic Programs. Manag. Sci. 1998, 44, 336–345. [Google Scholar] [CrossRef]
  5. Glover, F.; Lü, Z.; Hao, J.-K. Diversification-driven tabu search for unconstrained binary quadratic problems. 4OR 2010, 8, 239–253. [Google Scholar] [CrossRef]
  6. Glover, F.; Hao, J.-K. Fast two-flip move evaluations for binary unconstrained quadratic optimisation problems. Int. J. Metaheuristics 2010, 1, 100–108. [Google Scholar] [CrossRef]
  7. Glover, F.; Hao, J.-K. f-Flip strategies for unconstrained binary quadratic programming. Ann. Oper. Res. 2016, 238, 651–657. [Google Scholar] [CrossRef]
  8. Kochenberger, G.; Hao, J.-K.; Glover, F.; Lewis, M.; Lü, Z.; Wang, H.; Wang, Y. The unconstrained binary quadratic programming problem: A survey. J. Comb. Optim. 2014, 28, 58–81. [Google Scholar] [CrossRef]
  9. Kochenberger, G.A.; Glover, F.; Wang, H. Binary Unconstrained Quadratic Optimization Problem. In Handbook of Combinatorial Optimization; Pardalos, P.M., Du, D.-Z., Graham, R.L., Eds.; Springer: New York, NY, USA, 2013; pp. 533–557. [Google Scholar]
  10. Lozano, M.; Molina, D.; Garcia-Martinez, C. Iterated greedy for the maximum diversity problem. Eur. J. Oper. Res. 2011, 214, 31–38. [Google Scholar] [CrossRef]
  11. Alidaee, B.; Kochenberger, G.; Wang, H. Theorems Supporting r-flip Search for Pseudo-Boolean Optimization. Int. J. Appl. Metaheuristic Comput. 2010, 1, 93–109. [Google Scholar] [CrossRef]
  12. Anacleto, E.A.J.; Meneses, C.N.; Ravelo, S.V. Closed-form formulas for evaluating r-flip moves to the unconstrained binary quadratic programming problem. Comput. Oper. Res. 2020, 113, 104774. [Google Scholar] [CrossRef]
  13. Anacleto, E.; Meneses, C.; Liang, T. Fast r-flip move evaluations via closed-form formulae for Boolean quadraticprogramming problems with generalized upper bound constraints. Comput. Oper. Res. 2021, 132, 105297. [Google Scholar] [CrossRef]
  14. Glover, F.; Lewis, M.; Kochenberger, G. Logical and inequality implications for reducing the size and difficulty of quadratic unconstrained binary optimization problems. Eur. J. Oper. Res. 2018, 265, 829–842. [Google Scholar] [CrossRef]
  15. Lewis, M.; Glover, F. Quadratic Unconstrained Binary Optimization Problem Preprocessing: Theory and Empirical Analysis. Networks 2017, 70, 79–97. [Google Scholar] [CrossRef]
  16. Vredeveld, T.; Lenstra, J.K. On local search for the generalized graph coloring problem. Oper. Res. Lett. 2003, 31, 28–34. [Google Scholar] [CrossRef]
  17. Kochenberger, G.; Glover, F. Introduction to special xQx issue. J. Heuristics 2013, 19, 525–528. [Google Scholar] [CrossRef]
  18. Ahuja, R.K.; Ergun, Ö.; Orlin, J.B.; Punnen, A.P. A survey of very large-scale neighborhood search techniques. Discret. Appl. Math. 2002, 123, 75–102. [Google Scholar] [CrossRef]
  19. Ahuja, R.K.; Orlin, J.B.; Pallottino, S.; Scaparra, M.P.; Scutellà, M.G. A Multi-Exchange Heuristic for the Single-Source Capacitated Facility Location Problem. Manag. Sci. 2004, 50, 749–760. [Google Scholar] [CrossRef]
  20. Yagiura, M.; Ibaraki, T. Analyses on the 2 and 3-Flip Neighborhoods for the MAX SAT. J. Comb. Optim. 1999, 3, 95–114. [Google Scholar] [CrossRef]
  21. Yagiura, M.; Ibaraki, T. Efficient 2 and 3-Flip Neighborhood Search Algorithms for the MAX SAT: Experimental Evaluation. J. Heuristics 2001, 7, 423–442. [Google Scholar] [CrossRef]
  22. Yagiura, M.; Kishida, M.; Ibaraki, T. A 3-flip neighborhood local search for the set covering problem. Eur. J. Oper. Res. 2006, 172, 472–499. [Google Scholar] [CrossRef]
  23. Alidaee, B. Fan-and-Filter Neighborhood Strategy for 3-SAT Optimization, Hearin Center for Enterprise Science; The University of Mississippi, Hearin Center for Enterprise Science: Oxford, MS, USA, 2004. [Google Scholar]
  24. Glover, F. A Template for Scatter Search and Path Relinking; Springer: Berlin/Heidelberg, Germany, 1998. [Google Scholar]
  25. Ivanov, S.V.; Kibzun, A.I.; Mladenović, N.; Urošević, D. Variable neighborhood search for stochastic linear programming problem with quantile criterion. J. Glob. Optim. 2019, 74, 549–564. [Google Scholar] [CrossRef]
  26. Mladenović, N.; Hansen, P. Variable neighborhood search. Comput. Oper. Res. 1997, 24, 1097–1100. [Google Scholar] [CrossRef]
  27. Alidaee, B.; Sloan, H.; Wang, H. Simple and fast novel diversification approach for the UBQP based on sequential improvement local search. Comput. Ind. Eng. 2017, 111, 164–175. [Google Scholar] [CrossRef]
  28. Palubeckis, G. Multistart Tabu Search Strategies for the Unconstrained Binary Quadratic Optimization Problem. Ann. Oper. Res. 2004, 131, 259–282. [Google Scholar] [CrossRef]
  29. Glen, S. Relative Standard Deviation: Definition & Formula. 2014. Available online: https://www.statisticshowto.com/relative-standard-deviation/ (accessed on 10 November 2023).
  30. Katayama, K.; Naihisa, H. An Evolutionary Approach for the Maximum Diversity Problem; Hart, W., Krasnogor, N., Smith, J.E., Eds.; Recent Advances in Memetic Algorithms; Springer: Berlin/Heidelberg, Germany, 2004; pp. 31–47. [Google Scholar]
  31. Liang, R.N.; Anacleto, E.A.J.; Meneses, C.N. Fast 1-flip neighborhood evaluations for large-scale pseudo-Boolean optimization using posiform representation. Comput. Oper. Res. 2023, 159, 106324. [Google Scholar] [CrossRef]
  32. Merz, P.; Freisleben, B. Greedy and Local Search Heuristics for Unconstrained Binary Quadratic Programming. J. Heuristics 2002, 8, 197–213. [Google Scholar] [CrossRef]
  33. Rosenberg, G.; Vazifeh, M.; Woods, B.; Haber, E. Building an iterative heuristic solver for a quantum annealer. Comput. Optim. Appl. 2016, 65, 845–869. [Google Scholar] [CrossRef]
  34. Alidaee, B.; Wang, H.; Liu, W. New Results on Closed-Form Formulas for Evaluating r-flip Moves in Quadratic Unconstrained Binary Optimization; Working Paper Series, WP 2021-002; Texas A&M International University: Laredo, TX, USA, 2022. [Google Scholar]
Table 1. Size of set D(1).
Table 1. Size of set D(1).
r = 2r = 3r = 4
Density
Prob. Size0.10.30.50.80.10.30.50.80.10.30.50.8
2500<100<40<30<20<400<200<100<100<1000<500<300<200
3000<100<40<30<20<400<200<100<100<1100<500<400<250
4000<100<30<30<20<500<200<100<100<1200<600<400<250
5000<100<30<30<20<500<200<100<100<1300<600<400<250
6000<100<30<30<20<500<200<100<100<1400<600<400<250
Table 2. Results of Algorithms 3–5 on p30000 instances with a CPU time limit of 600 s and r = 2.
Table 2. Results of Algorithms 3–5 on p30000 instances with a CPU time limit of 600 s and r = 2.
Instance
ID
Algorithm 3Algorithm 4Algorithm 5
SizeDensityOFVTB (s)OFVTB (s)OFVTB (s)
p30000_1 30,0000.5127,239,168591127,292,467591127,336,719592
p30000_2 30,0000.8158,439,036572158,472,098555158,526,518571
p30000_3 30,0001179,192,241584179,219,781587179,261,723590
Table 3. The solution quality of the MST2 algorithm and Algorithm 5 with CPU time limits of 60 and 600 s out of 10 runs.
Table 3. The solution quality of the MST2 algorithm and Algorithm 5 with CPU time limits of 60 and 600 s out of 10 runs.
Instance
ID
MST2
with 60 s
r-Flip with 60 sMST2
with 600 s
r-Flip with 600 s
SizeDensityr = 1r = 2r = 1r = 2
p3000_1 30000.510 (0)10 (0)10 (0)10 (0)10 (0)10 (0)
p3000_2 30000.810 (0)10 (0)10 (0)10 (0)10 (0)10 (0)
p3000_3 30000.84 (0.01)7 (0.007)10 (0)10 (0)10 (0)10 (0)
p3000_4 3000110 (0)10 (0)10 (0)10 (0)10 (0)10 (0)
p3000_5 3000110 (0)9 (0.003)7 (0.002)9 (0.001)10 (0)10 (0)
p4000_1 40000.510 (0)10 (0)10 (0)10 (0)10 (0)10 (0)
p4000_2 40000.810 (0)10 (0)10 (0)9 (0.004)10 (0)10 (0)
p4000_3 40000.810 (0)10 (0)10 (0)10 (0)10 (0)10 (0)
p4000_4 400011 (0.033)10 (0)10 (0)10 (0)10 (0)10 (0)
p4000_5 4000110 (0)10 (0)10 (0)10 (0)10 (0)10 (0)
p5000_1 50000.56 (0.000)1 (0.002)2 (0.002)10 (0)3 (0.002)2 (0.002)
p5000_2 50000.810 (0)4 (0.003)1 (0.002)6 (0.012)10 (0)10 (0)
p5000_3 50000.810 (0)7 (0.001)3 (0.002)10 (0)10 (0)10 (0)
p5000_4 5000110 (0)1 (0.002)1 (0.001)10 (0)3 (0.002)1 (0.001)
p5000_5 500016 (0.021)9 (0.003)4 (0.004)10 (0)10 (0)10 (0)
p6000_1 60000.510 (0)10 (0)4 (0.001)10 (0)10 (0)10 (0)
p6000_2 60000.810 (0)4 (0.001)4 (0.001)1 (0.006)10 (0)9 (0)
p6000_3 600019 (0.002)3 (0.002)1 (0.007)10 (0)10 (0)10 (0)
p7000_1 70000.51 (0.002)1 (0.006)1 (0.007)10 (0)2 (0.002)4 (0.002)
p7000_270000.87 (0.000)1 (0.008)1 (0.008)10 (0)1 (0.004)2 (0.004)
p7000_3700018 (0.011)3 (0.021)5 (0.023)10 (0)10 (0)10 (0)
p8000_1 80000.510 (0)1 (0.004)1 (0.005)9 (0.001)10 (0)1 (0.002)
p8000_280000.810 (0)1 (0.009)1 (0.008)10 (0)7 (0.003)10 (0)
p8000_38000110 (0)1 (0.013)1 (0.01)10 (0)4 (0.001)3 (0.002)
p30000_1 30,0000.51 (0.002)1 (0.023)1 (0.019)7 (0.018)1 (0.017)1 (0.011)
p30000_2 30,0000.810 (0)1 (0.017)1 (0.016)6 (0.01)1 (0.019)1 (0.013)
p30000_3 30,000110 (0)1 (0.015)1 (0.019)2 (0.037)1 (0.025)1 (0.019)
Table 4. Results of the MST2 algorithm and r-flip strategy in Algorithm 5 within the CPU time limit of 60 s.
Table 4. Results of the MST2 algorithm and r-flip strategy in Algorithm 5 within the CPU time limit of 60 s.
Instance
ID
BFS (60 s)MST2 (60 s)r-Flip (60 s)
OFVTB (s)OFV (r = 1)TB (s)OFV (r = 2)TB (s)
p3000_1 3,931,5833,931,583103,931,58333,931,5838
p3000_2 5,193,0735,193,073255,193,07325,193,0732
p3000_3 5,111,5335,111,533525,111,53385,111,5334
p3000_4 5,761,8225,761,437105,761,82225,761,8222
p3000_5 5,675,6255,675,430245,675,62575,675,62517
p4000_1 6,181,8306,181,830406,181,83036,181,8304
p4000_2 7,801,3557,797,821127,801,355137,801,3554
p4000_3 7,741,6857,741,685317,741,68557,741,6858
p4000_4 8,711,8228,709,956588,711,82258,711,82211
p4000_5 8,908,9798,905,340278,908,97948,908,97913
p5000_1 8,559,6808,556,675568,559,680218,559,6807
p5000_2 10,836,01910,829,8483410,836,0195910,836,01911
p5000_3 10,489,13710,477,1292810,489,1372010,489,13716
p5000_4 12,251,71012,245,2825212,251,7105412,251,52042
p5000_5 12,731,80312,725,7795612,731,8031712,731,80316
p6000_1 11,384,97611,377,3154211,384,9761211,384,9765
p6000_2 14,333,85514,330,0323914,333,8552714,333,76714
p6000_3 16,132,91516,122,3335116,130,7312416,132,91548
p7000_1 14,477,94914,467,1575614,477,9494114,476,26321
p7000_218,249,94818,238,7295518,249,9484718,246,89547
p7000_320,446,40720,431,3545920,446,4071520,446,40712
p8000_1 17,340,53817,326,2594717,340,5382617,340,53835
p8000_222,208,98622,180,4655522,208,9865422,208,68353
p8000_324,670,25824,647,2485624,670,2584324,669,35150
p30000_1 127,252,438126,732,48,360127,252,43858127,219,33660
p30000_2 158,384,175157,481,36669158,384,17559158,339,49760
p30000_3 179,103,085178,093,10989179,103,08558179,029,74754
Table 5. Results of the MST2 algorithm and r-flip strategy in Algorithm 5 within the CPU time limit of 600 s.
Table 5. Results of the MST2 algorithm and r-flip strategy in Algorithm 5 within the CPU time limit of 600 s.
Instance
ID
BFS
(600 s)
MST2 (600 s)r-Flip (600 s)
OFVTB (s)OFV (r = 1)TB (s)OFV (r = 2)TB (s)
p3000_1 3,931,5833,931,583113,931,58353,931,5835
p3000_2 5,193,0735,193,073255,193,07315,193,0733
p3000_3 5,111,5335,111,533525,111,533305,111,5338
p3000_4 5,761,8225,761,8222695,761,82215,761,8222
p3000_5 5,675,6255,675,6255055,675,625435,675,62529
p4000_1 6,181,8306,181,830406,181,83046,181,8302
p4000_2 7,801,3557,800,8515307,801,35587,801,3558
p4000_3 7,741,6857,741,685307,741,68557,741,6852
p4000_4 8,711,8228,711,822678,711,82228,711,8227
p4000_5 8,908,9798,906,525658,908,97948,908,97913
p5000_1 8,559,6808,559,0753248,559,68098,559,68027
p5000_2 10,836,01910,835,43754110,836,0191710,836,01921
p5000_3 10,489,13710,488,73540010,489,1372910,489,13738
p5000_4 12,252,31812,249,29026512,252,31812712,251,848143
p5000_5 12,731,80312,731,80326512,731,8031912,731,80332
p6000_1 11,384,97611,384,97640611,384,976811,384,97639
p6000_2 14,333,85514,333,76749814,333,8556214,333,85517
p6000_3 16,132,91516,128,60923916,132,9156016,132,91571
p7000_1 14,478,67614,477,03934414,478,6769214,478,676397
p7000_218,249,94818,242,20558718,249,94811518,249,84443
p7000_320,446,40720,431,83310920,446,4074720,446,40721
p8000_1 17,341,35017,337,15454617,340,5384517,341,350141
p8000_222,208,98622,207,86612222,208,9864922,208,98689
p8000_324,670,92424,669,79740224,670,92418524,670,924386
p30000_1 127,336,719127,323,304568127,332,912598127,336,719592
p30000_2 158,561,564158,438,942573158,561,564580158,526,518571
p30000_3 179,329,754179,113,916575179,329,754599179,261,723590
Table 6. Computing the time deviation of the MST2 algorithm and r-flip strategy in Algorithm 5 within the time limit of 60 s.
Table 6. Computing the time deviation of the MST2 algorithm and r-flip strategy in Algorithm 5 within the time limit of 60 s.
Instance
ID
MST21-Flip2-Flip
AT (s)DTAT (s)DTAT (s)DT
p3000_1 12.515.66315.784.07524.156.875
p3000_2 32.520.0594.945.5834.868.606
p3000_3 54.35.90129.346.18012.060.477
p3000_4 13.318.43412.0107.79810.051.640
p3000_5 30.415.82933.245.47032.348.240
p4000_1 49.010.2277.750.1319.336.570
p4000_2 14.29.84822.162.35121.170.476
p4000_3 35.411.23615.169.69916.575.542
p4000_4 58.0022.265.40835.445.780
p4000_5 31.111.08218.173.03829.640.109
p5000_1 56.82.3394.0010.042.426
p5000_2 35.03.56328.374.32911.00
p5000_3 30.08.60738.933.03833.050.069
p5000_4 54.05.23854.0042.00
p5000_5 57.21.31738.840.50430.563.379
p6000_1 43.35.11232.947.38021.867.507
p6000_2 39.84.23831.851.52142.346.315
p6000_3 52.15.02732.344.64048.00
p7000_1 56.0041.0021.00
p7000_255.31.36747.0047.00
p7000_359.0042.056.29335.245.958
p8000_1 48.17.23226.0035.00
p8000_255.90.56654.0053.00
p8000_357.21.80643.0050.00
p30000_1 60.0058.0060.00
p30000_2 70.01.16659.0060.00
p30000_3 90.30.91258.0054.00
Table 7. Computing the time deviation of the MST2 algorithm and r-flip strategy in Algorithm 5 within the time limit of 600 s.
Table 7. Computing the time deviation of the MST2 algorithm and r-flip strategy in Algorithm 5 within the time limit of 600 s.
Instance
ID
MST21-Flip2-Flip
AT (s)DTAT (s)DTAT (s)DT
p3000_1 11.916.06721.362.67837.8130.045
p3000_2 29.118.1445.569.2347.781.231
p3000_3 58.516.889126.499.610143.6116.812
p3000_4 292.111.28510.858.36513.749.512
p3000_5 543.96.365109.188.328164.372.144
p4000_1 42.87.77313.563.55315.163.861
p4000_2 552.22.59730.749.92337.0110.712
p4000_3 31.77.29318.857.44222.947.545
p4000_4 70.84.09442.2102.33148.7115.376
p4000_5 70.58.59625.381.98443.069.595
p5000_1 337.24.26570.7126.28748.061.872
p5000_2 557.84.565135.496.462210.667.670
p5000_3 428.57.257115.896.524115.5104.238
p5000_4 279.45.987270.348.842143.00
p5000_5 287.19.234194.594.641172.792.268
p6000_1 424.84.555152.995.641145.946.657
p6000_2 498.00142.597.37573.8122.070
p6000_3 252.35.571248.051.129318.161.672
p7000_1 344.50.153272.593.675441.512.974
p7000_2587.00115.00265.176.694
p7000_3109.0084.539.472131.155.401
p8000_1 548.61.398251.363.346141.00
p8000_2145.411.829258.356.352300.756.001
p8000_3514.311.365368.843.667417.312.797
p30000_1 572.01.365598.00592.00
p30000_2 581.51.526580.00571.00
p30000_3 586.52.773599.00590.00
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Share and Cite

MDPI and ACS Style

Alidaee, B.; Wang, H.; Sua, L.S. An Efficient Closed-Form Formula for Evaluating r-Flip Moves in Quadratic Unconstrained Binary Optimization. Algorithms 2023, 16, 557. https://doi.org/10.3390/a16120557

AMA Style

Alidaee B, Wang H, Sua LS. An Efficient Closed-Form Formula for Evaluating r-Flip Moves in Quadratic Unconstrained Binary Optimization. Algorithms. 2023; 16(12):557. https://doi.org/10.3390/a16120557

Chicago/Turabian Style

Alidaee, Bahram, Haibo Wang, and Lutfu S. Sua. 2023. "An Efficient Closed-Form Formula for Evaluating r-Flip Moves in Quadratic Unconstrained Binary Optimization" Algorithms 16, no. 12: 557. https://doi.org/10.3390/a16120557

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop