Modified Artificial Bee Colony Algorithm for Multiple-Choice Multidimensional Knapsack Problem

The multiple-choice multidimensional knapsack problem (MMKP) is a well-known NP-hard problem that has many real-time applications. However, owing to its complexity, finding computationally efficient solutions for the MMKP remains a challenging task. In this study, we propose a Modified Artificial Bee Colony algorithm (MABC) to solve the MMKP. The MABC employs surrogate relaxation, Hamming distance, and a tabu list to enhance the local search process and exploit neighborhood information. We evaluated the performance of the MABC on standard benchmark instances and compared it with several state-of-the-art algorithms, including RLS, ALMMKP, ACO, PEGF-PERC, TIKS-TIKS2 and D-QPSO. The experimental results reveal that MABC produces highly competitive solutions in terms of the best solutions found, achieving approximately 2% of the optimal solutions with trivial (milliseconds) CPU time. The Kruskal-Wallis test revealed that there was no statistically significant difference in the objective function values between the MABC algorithm and other state-of-the-art algorithms (H = 0.31506, p = 0.98882). However, for CPU efficiency, the test showed a statistically significant difference (H = 84.90850, p = 0), indicating that the MABC algorithm exhibited significantly better CPU efficiency (with shorter execution times) than the other algorithms did. Along with these findings, the ease of implementation of the algorithm and the small number of control parameters make our approach highly adaptive for large-scale real-time systems.


I. INTRODUCTION
The MMKP is a generalization of the classical knapsack problem (KP) [1].It is significant because it can model a wide range of real-time applications such as resource allocation [2], intelligent transportation systems [3], logistics [4], quality of service (QoS) [5], [6], web service composition [7], Energy-Efficient Offloading in Mobile Edge Computing [8], medicine [9], budgeting problems [10], hardware design [11], and cloud computing [12].Formally, the MMKP can be expressed as a set of items divided into n disjoint groups and an m-dimensional resource constraint represented by the vector of resource availability   = { 1 , … ,   }.Item j in group i has a non-negative profit value vij and consumes a certain amount    of resource k (k = 1, …, m).The decision variable xij = 1 if item j from class i is selected and xij = 0 otherwise.The MMKP is then defined as ∈ {0,1},  = 1, . ., ,  = 1, . .,   (4) As a variant of the classical KP, the MMKP can be considered as a combination of two challenging problems: the multidimensional knapsack problem (MKP) [13] and the multi-choice knapsack problem (MCKP) [14].It involves a linear objective function under two types of linear constraints: (2) and (3).The first is a multidimensional constraint and the second is a choice constraint.If constraint (3), which limits each group to a single item, is relaxed, the problem is reduced to MKP [15].Constraint (2) guarantees that the knapsack capacities are respected, and if the resource constraint is relaxed to a single dimension (m = 1), the problem is reduced to an MCKP [16].
The MMKP has a potentially wide range of practical applications.However, developing an efficient and effective algorithm for the problem is challenging because it is an NP-hard problem [17] as it is not trivial to find even a feasible solution within polynomial runtime complexity, particularly for large-scale problems.
NP-hard problems have numerous local minima that can be challenging to escape.This is further aggravated by the cycling phenomenon, wherein the algorithm repeatedly visits a candidate solution, thereby wasting time and causing it to fall into a local optimum.
Recently, metaheuristics based on nature-inspired algorithms have gained attention as a solution to the MMKP and other complex optimization problems.These algorithms are inspired by the behavior and decision-making processes of natural systems, such as the genetic algorithm (GA) [18], particle-swarm optimization (PSO) [19], ant colony optimization (ACO) [20], [21], biogeography-based optimization (BBO) [22], harmony search (HS) [23], and artificial bee colony (ABC) algorithm [24].By combining metaheuristics with mathematical optimization techniques, they can effectively solve complex optimization problems and produce near-optimal solutions.
The use of metaheuristics based on nature-inspired algorithms in practical problems highlights the importance and potential of these algorithms for real-world applications.These algorithms can effectively and efficiently solve complex optimization problems, making them useful in various fields [25], [26].
The ABC algorithm contains three main phases: employed-bee, onlooker-bee, and scout-bee.The employedbee and onlooker-bee phases are dedicated to the exploitation of the search space, whereas the scout-bee phase is dedicated to the exploration of the search space.The exploration strategy of the ABC algorithm, which is based on a stochastic pattern search process, delivers excellent performance.However, similar to other evolutionary algorithms, it encounters performance challenges during the exploitation process [47].
The deficiencies in the ABC exploitation process are caused by several factors.In the employed-bee phase, the local search process is related to neighborhood information, which limits the efficiency of the exploitation process owing to the restricted information that a neighborhood can offer.A similar drawback affects the onlooker-bee, because the same structure is applied in the onlooker-bee phase.Furthermore, the fitness structure used in ABC maintains only food sources with high amounts of nectar; however, low-nectar solutions may also contain useful information.These factors lead to an imbalance between exploitation and exploration in the search process, causing delayed convergence and falling into a local optima [48].
In this study, we propose a Modified Artificial Bee Colony (MABC) algorithm to solve the MMKP based on the ABC algorithm.The MABC algorithm improves the performance of the ABC algorithm by integrating three distinct techniques, namely, surrogate relaxation, Hamming distance, and tabu list, to handle the combinatorial nature of the problem, increase population diversity, and facilitate faster convergence to find nearoptimal solutions within a short computational time.The MABC algorithm adopts the Hamming distance to measure the dissimilarity between candidate solutions, which is defined as the number of positions (groups) at which two solutions differ.The algorithm employs a stochastic selection process to generate new solutions within a predefined Hamming distance from the current solutions.This approach improves the population diversity, thereby avoiding convergence to local optima.Furthermore, the MABC algorithm employs a surrogate relaxation approach to address the combinatorial nature of the MMKP problem.By combining surrogate relaxation with Hamming distance techniques, the MABC algorithm aims to accelerate the convergence and find near-optimal solutions in reduced computational time.Finally, the MABC algorithm integrates a tabu list that monitors the recently visited solutions, thereby preventing the algorithm from revisiting them.This technique enhances the exploration of the solution space and assists in avoiding the local optima.
The approach was validated on standard benchmark problem instances and compared with several state-of-theart algorithms in literature.
The remainder of this paper is organized as follows.Section 2 presents a brief review of the relevant literature.
We describe our MABC algorithm in Section 3. Section 4 presents and discusses the extensive computational results obtained for the known benchmark problems.Finally, Section 5 concludes the study.

II. LITERATURE REVIEW
MMKP is strongly constrained and NP-hard [49].Consequently, the search space grows exponentially with the problem size [17], which renders scanning highly difficult or even impossible in practice, despite advancements in computer technologies.In particular, it is challenging to identify a good solution quality without falling into a local optimum when scanning most of the search space.
Several exact approaches have been proposed to solve the MMKP problem [50]- [52] most of which use a branch-andbound algorithm.Khan [52] suggested a combination of a branch-and-bound algorithm and linear programming.Sbihi [51] described an exact branch-and-bound algorithm that explores the search tree using the best-first strategy.In this approach, the upper bounds of the objective function are computed by reducing multiple dimensions to one and transforming the problem into an MCKP problem.Hence, the computational results reported in Sbihi [51] indicate that the algorithm outperformed Khan's approach [52].Razzazi and Ghasemi [53] used a more powerful branch-and-bound scheme based on a depth-first strategy to explore the search tree.They calculated the upper bounds using the surrogate relaxation of the problem.Their algorithm provides better results than those of Sbihi [51].Ghasemi and Razzazi [50] developed an exact algorithm based on an approximate core to solve MMKP.They obtained promising results with up to five knapsack constraints and 1000 items.
Nevertheless, exact approaches can only deal with problems of a limited size (n = 100 and m = 10) [54].For realtime decisions, exact algorithms are not feasible owing to their complexity and requirement of a fast system response.Therefore, approximation algorithms are viable options for solving the MMKP, particularly in cases where a precise optimal solution is not required and computational time is a significant constraint.
For larger instances, several heuristics have been proposed to determine near-optimal solutions within acceptable computation time [54].In 1997, Moser et al. [55] introduced the first heuristic algorithm for resolving the MMKP based on Lagrangian relaxation and repetitive permutation.The approach was subsequently improved by Akbar et al. [56].
Further, Hifi et al. [57] used a reactive local search (RLS) and a modified reactive local search (MRLS), which yielded better results than those of Moser et al. [55].Cherfi and Hifi [58] proposed a hybrid algorithm combining local branching with column generation, which outperformed all previous approaches.
Combinations of linear programming relaxation and other techniques are often used in MMKP algorithms to solve the reduced problem [59]- [61].Cherfi [62] extended the approach proposed by Cherfi and Hifi [58] to improve the quality of solutions by combining column generation techniques and local search.Ren and Feng [63] presented an ACO approach following the scheme of a max-min ant system to solve the MMKP problem.Crévits et al. [64] introduced a semicontinuous relaxation approach to solve the MMKP.In their approach, relaxation is used at each iteration to generate an upper bound and then create a sub-problem that can be solved to find a lower bound.Pseudo cuts are also produced to prevent falls into the local optima.
Mansi et al. [60] described another hybrid approach based on iterative relaxation that applies new cuts to generate a reduced problem and a reformulation procedure.Additionally, Htiouech et al. [65] used a surrogate constraint combined with an oscillation method to solve the MMKP.Subsequently, Htiouech and Alzaidi [66] divided the MMKP into small subproblems and used an agent-based approach to solve the reduced problem.Xia et al. [67] proposed a first-level tabu search algorithm.Their proposed algorithm performs fairly well compared with legacy heuristic approaches.
Gao et al. [61] described a new iterative pseudo-gap enumeration based on a new family of pseudo-cuts resulting from the reduced cost constraint of non-basic variables.Dong et al. [68] proposed an enhanced quantum particle swarm optimization algorithm for MMKP that prioritizes effective genes and reserves particles with greater revolutionary potential.The algorithm employs a mutation based on elite genes to prevent local optimization when the population diversity decreases.
Caserta et al. [69] defined a primary mathematical model for solving the MMKP.Their model addresses complex system reliability and uses a new robust formulation characterized by second-order cone programs.In this model, the resource consumption values of items are nondeterministic.The authors demonstrated the ability to convert a nondeterministic MMKP into an integer linear program without extra complexity.Mkaouar et al. [70] developed an algorithm that uses the ABC algorithm to resolve the MMKP.Their proposed algorithm, inspired by the general behavior of the honeybee swarm, provided better quality solutions for medium and large scale instances compared to other reported approaches.
Mansini and Zanotti [71] proposed a new approach for solving this problem.The method solves sub-problems of increasing size using a recursive variable fixing process until an optimality condition is satisfied.Syarif et al. [72] analyzed three different GA and evaluated the performance of several heuristic algorithm approaches to solve the MMKP.
Yang et al. [73] applied a memetic algorithm to the MMKP.The authors designed a repair heuristic based on a tendency function with human experience through experiments using genetic algorithms.Lamanna et al. [74] provided a new variant of the heuristic framework kernel search applied to the MMKP.Dellinger et al. [75] proposed simple strategies that generate bounded solutions for the MMKP.
Despite the existence of several exact and approximate heuristic algorithms for solving the MMKP, new algorithms must be developed.This is for several reasons, including the fact that the MMKP is an NP-hard problem, meaning that obtaining exact solutions for large problem instances is a difficult task.Moreover, many existing algorithms are computationally intensive and require considerable computational time to provide the best possible solutions, particularly for large problems.The computational time required to solve the MMKP problem can be reduced by developing more efficient algorithms.Finally, new algorithms may need to be developed to handle new constraints, objectives, or uncertainties or to adapt to new problem instances or settings, which may require more flexible and adaptable solutions.
Despite the diversity of methods used in research on the MMKP, none of the methods have leveraged dissimilarity and similarity measures between solutions.Such a measure can be highly valuable because it provides numeric values quantifying the relative positions (distances) of solutions with respect to each other in the search space.Therefore, this concept can provide significant flexibility for the algorithm to jump from one current local search area to another, and consequently explore several different zones of the search space.

III. MABC
To the best of our knowledge, the ABC algorithm has not yet been used for the MMKP, except in the study by Mkaouar et al. [70] that presents an algorithm inspired by the general behavior of a honeybee swarm.However, this study represents the different phases of the ABC algorithm for the MMKP.
The ABC algorithm was first proposed by Karaboga [24] to solve continuous and discrete problems.Subsequently, Karaboga and Basturk [28] compared the performance of the ABC algorithm to that of the GA, differential evolution (DE), PSO, and evolutionary algorithm (EA), and tested them using five multidimensional numerical test problems.The experimental results show that ABC escaped falling into a local minimum, was more proficient for multivariable and multimodal function optimization, and outperformed DE, PSO, and EA [28], [29].
The ABC algorithm simulates the intelligent comportment of a honeybee swarm while probing for a food source (solution).In an ABC, a potential solution for the considered problem is a symbol of a food source, and the quality of this solution depicts the quantity of nectar in this food source.ABC adopts a colony model divided into three categories according to the task performance.
Employed-bees: Each employed bee is a distinct food source.Employed-bees are responsible for investigating nectar food sources in areas or neighborhoods already visited by them.An employed-bee modifies the food source (current solution) in its memory depending on the local information (visual information) and assessments of the nectar amount (fitness value) of the new source (new solution).If the quantity of nectar in the new solution is higher than that in the current solution, the bee memorizes the new position and abandons the old one.Otherwise, it retains the position of the solution in memory.Moreover, it shares information about food sources with a certain probability with the bees residing in the hive (onlooker-bees).
Onlooker-bees: receive information from employed-bees and evaluate the quality of the food source.Similar to the employed-bees, onlooker-bees attempt to improve the solutions using a greedy search strategy.
Scout-bees: The employed-bee and onlooker-bee phases are dedicated to the exploitation of the search space, whereas the scout-bee phase is dedicated to the exploration of the search space.Scouts search for new food sources in new areas.An employed-bee becomes a scout-bee when the quality of a food source does not improve after a predetermined number of attempts, called the "limit." This cycle (employed-bee, onlooker-bee, and scout-bee phases) is repeated until "maxCycle" (maximum number of cycles) is reached.Subsequently, the best global solution is returned by the algorithm.
The main steps of the ABC algorithm are summarized in Algorithm 1.The different phases of the ABC algorithm were modified to improve its performance.The following subsections describe each step in more details.

A. Initialization of population
The generation of an initial population in an optimization metaheuristic is important because it affects the search in future iterations and significantly influences the final solution.The random method aims to generate random solutions to produce greater diversity, which is an important factor for determining the quality of the final solution.The random greedy method may generate a population with good fitness solutions; however, there is a risk of rapid convergence toward a local optimum [76].
Because it may not produce feasible solutions for the MMKP within a reasonable computation time, the random initialization method for the candidate solutions of the initial population used in the standard ABC is not suitable for the MMKP.Therefore, in this study, a new initialization method based on the Hamming distance (see Section V.B.1) was applied to create the initial population (initializeSolution procedure) to increase the diversity of the population and help avoid getting stuck in local optima.
The principle of this procedure is to assign the n groups of the problem to N classes with  <  and    = 0.The groups are randomly assigned to classes with the same number of groups in each class.The problem here is reduced to N subproblems (classes) containing each of the   = ⁄ groups.Each reduced problem P' is individually solved.The combination of N partial solutions for the N sub-problems can be a candidate for a complete feasible solution for the MMKP.The initializeSolution procedure is repeated for each candidate solution X l of the initial population with l = {1, ..., SN}, and SN is the size of the population.
The main steps for the solution generation are presented in Algorithm 2. for each subset 6. dh= constant // number of items to be exchanged from a candidate solution 7. While (Ɵ' ≠ ∅) // while there is a group not yet initialized 8.

B. Modified employed-bee phase
This phase aims to enhance the performance of the ABC algorithm by obtaining superior quality solutions while avoiding convergence to local optima [47], [48], [77].

1) DISTANCE MEASURE: HAMMING DISTANCE
In this study, we incorporated the concept of a distance measure to enhance the exploitation search process.Manipulating the distances between solutions facilitates the localization of relative positions of the solutions.It also offers flexibility of movement within the search space from the position of the current solution to that of another by acting on a predefined part of the current solution.The size of the manipulated part represents the distance between the current and newly generated solution.The distance between solutions reflects the degree of similarity.If the distance between the two solutions is small, then the solutions are similar and located within a neighborhood search area, whereas if the distance between the two solutions is large, then the solutions are dissimilar and localized in different search areas.
The MABC algorithm utilizes the Hamming distance as a distance metric because of its simplicity and effectiveness in capturing the differences between two solutions based on the number of different bits.Specifically, in the context of the MMKP, the Hamming distance is adept at capturing the differences between two solutions based on the number of groups in which the corresponding items differ.
In information theory, the Hamming distance between two binary strings a and b is measured by performing the XOR operation (a ⊕ b) and then counting the total number of ones in the resultant string [78].Typically, the Hamming distance between two vectors a and b of the same length n is given by The solution for the MMKP is represented as a vector X of length n (number of groups).X is used to indicate item j with j ∈ {1, .., ni}, which is selected from each group i with i ∈ {1, .., n}.Fig. 1 illustrates the structure of solution X for an instance containing ten groups (n = 10) and five items (ni = 5).In our approach, we define the distance between two solutions as the number of groups in which selected items differ.The distance d between two solutions X and X' of length n is given by An example of the calculation of the Hamming distance between the two MMKP candidate solutions is shown in Fig. 2. The unit of the Hamming distance measure (dh) is referred to as a step (the number of groups in which the corresponding items differ).For example, if dh (s, s') = 2, s is two steps away from s'.
This approach aims to manipulate the search depth in the exploitation phase by expanding (selecting large steps between solutions) or narrowing (selecting small steps between solutions) the local area around the solution (Fig. 3).This facilitates the exchange of a set of items in a single iteration, and consequently helps the algorithm to quickly converge to promising regions of the solution space.Specifically, the proposed algorithm generates a candidate solution s' in the neighborhood of the current solution s with dh (s, s') = d steps (number of items to exchange) from the current solution s by performing d exchanges E (i, j, h) of d items satisfying x ih = 1, with d new items belonging to the same group satisfying x ij = 0. select item j with xij = 0 // j and h belong to the same group 5.
replace item h with j // a mutant solution V is generated from X 6.
if the new solution V is feasible, then replace V with X 7. End For 8. Return V

2) SURROGATE RELAXATION
Each solution has more than one neighboring candidate solution.The choice of movement depends only on the information from the neighborhood domain of the current solution.Therefore, it is important to define a neighborhood relation between the solutions in the search space.In this study, the neighborhood relation was based on the surrogate constraint relaxation information.The surrogate relaxation technique is mainly used to prevent the algorithm from getting stuck in local optima.This involves approximating the original optimization problem with a simpler, relaxed problem that is easier to solve.By relaxing the problem, the algorithm can explore a larger solution space and avoid becoming trapped in local optima.Glover [79] proposed a surrogate constraint obtained by substituting the constraints of a problem with a single constraint to obtain approximate nearoptimal solutions for integer programming problems.Surrogate relaxation has been proven to be efficient in the exploitation of several knapsack problems [65], [80].
Htiouech et al. [65] used surrogate relaxation information according to the search direction: add move, drop move (infeasible solution case), or swap move (feasible solution case).Here, we are interested only in the swap move strategy, because our algorithm only deals with feasible solutions.The surrogate relaxation algorithm (swap move) proposed by Htiouech et al. continues through all groups and items in each group, and performs intensive mathematical tests and computations.Exchanges between items are performed whenever an improvement is detected.The algorithm stops only when no further improvement is possible, which making it computationally heavy.However, in our study, the computational time was considered a critical measure of the quality of the obtained solutions.Consequently, adjustments were made to the surrogate relaxation method used by Htiouech et al. [65] to overcome its limitations in terms of time complexity.Therefore, in the employed-bee phase of the MABC, we combine the Hamming distance (local search depth control) and the surrogate relaxation information structure to utilize its solution improvement efficiency without increasing the time complexity of the algorithm.Thus, only dh exchanges are permitted in the current solution.The choice rule for exchanges between items is based on the information provided by the surrogate relaxation.
During this step, d emp exchanges are performed for each candidate solution (Steps 18-21 in Algorithm 4).In each exchange E (i, j, h), item h is selected from group i and replaced by item j belonging to the same group.The choice of the d emp groups (items from the current solution to be exchanged) is based on the lowest ratio utility (Step 19 in Algorithm 4) given by | |   = 1,  = 1, . ., ,  = 1, . .,   (10) For each selected item with xih = 1, surrogate relaxation is used (Step 20 in Algorithm 4) to select a new item xij = 0 from the same group to maximize (11).In (11), the term v ij / v ih represents the gain of the profit value, and s ij / s ih represents the gain in terms of the remaining available resources.Consequently, the choice of the new item j (x ij = 0) to be exchanged instead of the old item h (x ih = 1) is made to improve the quality of the solution in terms of the maximization of (i) profit and (ii) savings of aggregate resources.
After the exchange, the decision variable x ij changes from 0 to 1, and x ih changes from 1 to 0. Therefore, a new solution V l is generated (Step 22 in Algorithm 4) from the current solution X l (with l in {1, ..., SN}), where dh (X l , V l ) = d emp .A greedy selection based on the value of the objective function is performed between the newly generated solution and the current solution (Steps 23-29 in Algorithm 4).

C. Modified onlooker-bee phase
The probability of selecting a candidate solution in this phase (Steps 32-34 in Algorithm 4) is inspired by the Gbest-guided artificial bee colony (GABC) algorithm [81], which is given by prob  = ( 0.9 * fitness (  ) fitness best ) + 0.1 (13) where fitness (Xi) is the fitness value of the current solution and fitness best is the highest fitness value.
A feasible candidate solution with relatively low nectar content may yield a better global solution than another candidate solution with higher nectar content.Therefore, the greedy selection between the current solution Xl and the new solution Vl is based on the highest fitness value computed by ( 14) instead of (9).
The depth of the search is controlled using the Hamming distance (dh).In other words, dh = don maximum number of exchanges is allowed (Steps 39-42 in Algorithm 4) to obtain a new candidate solution Vl from the current solution Xl.
For each candidate solution, d on items (x ij = 1) with the lowest profit selected using (16) (Step 40 in Algorithm 4) are exchanged randomly with the new item (x ij = 0), thereby satisfying the choice constraint (Step 41 in Algorithm 4).No exchange is allowed, unless this leads to a feasible solution.
After d on exchanges, a greedy selection between the new solution V l and the current solution X l is performed, and only the solution with the highest fitness value ( 14) is retained (Steps 43-50 in Algorithm 4).Equation ( 14) (the bound of the resources availability per consumed resources) ensures an improvement in the quality of the retained solution (neither the current solution X l nor the newly generated solution V l ) in terms maximizing the remaining available resources,

D. Modified scout-bee phase
The employed-bee and onlooker-bee phases could be considered perturbation processes that aim to change the trajectory of the search to release the solution when it is stuck in a potential local optimum, and further improve the solution without losing the progress made by the exploitation process.If the solution cannot be further improved, it is completely re-initialized with a randomly generated new solution (scout bee) using the initializeSolution procedure (Algorithm 2) (Steps 59-64 in Algorithm 4).
A tabu list (TL) is used in this study.This involves tracking recently explored solutions and temporarily excluding them from the search.This helps the algorithm avoid revisiting the same solutions repeatedly and efficiently exploring new areas of the solution space, thus accelerating convergence.TL is updated using the first-in-first-out (FIFO) strategy.Consider Vl as the new solution to be inserted into TL, and Xl as the oldest solution in the list.The TL vector is updated as follows

E. General approach
Algorithm 4 presents the main steps of the MABC.The algorithm begins by generating the initial population (Steps 11-15 in Algorithm 4), followed by the main loop containing the employed-bee, onlooker-bee, and scout-bee phases of the algorithm.The employed-bee (Steps 16-30 in Algorithm 4) and onlooker-bee (Steps 31-57 in Algorithm 4) phases aim to improve the quality of solutions.In the employed-bee phase, if the generated solution achieves a better objective value than the current solution, the current solution is updated.However, in the onlooker-bee phase, the solution with the best remaining resource value is retained.If a solution reaches the maximum for non-improvement (limit), the solution is completely reset by the scout bee (Steps 59-64 in Algorithm 4).The three main steps of the algorithm (employed-bee, onlooker-bee, and scout-bee phases) are repeated until the maximum number of cycles is reached (Step 66 in Algorithm 4).The global best solution is memorized in each cycle (Step 65 of the algorithm) and then returned to the end of the algorithm (Step 67 in Algorithm 4).The pseudo code for the proposed approach is presented in Algorithm 4. TLl ←Xl // initially, the TL contains the initial population 14.End For 15. Cycle ← 1 16./* Employed-bee phase */ 17.For l = 1 to SN 18.
Select xij that maximizes (11) // the choice of item j is based on the surrogate relaxation 21.
End For 22. Calculate the fitness value fitness (Vl) // Vl is generated from Xl after demp exchanges 23.If f (Vl) > f (Xl) and Vl ∉ TL // f is the objective function value of the considered solution 24.
Calculate fitness (Vl) using ( 14) // Vl is the mutant of Xl after performing don exchanges 44.
Generate a new solution Xl using (algorithm 2) 62.
End For 65.
Memorize the BGS 66.Until Cycle = maxCycle 67.Return BGS The computational complexity of the MABC algorithm was determined by evaluating the worst-case time complexity of each component.The time complexity of the MABC algorithm was estimated to be O((demp+don)×ni×m).

IV. COMPUTATIONAL RESULTS
This section assesses the performance of the MABC algorithm.We experimentally examined the algorithms on two sets of benchmark instances: E1 (I07 -I13) proposed by Khan [52], and E2 (INST01 -INST20) proposed by Hifi et al. [57].The instances (I01-I06) are known to be easily solvable in the literature.Hence, this study focused on the most difficult and large instances (E1 and E2).

A. Problem instances
All the benchmarks are available from the MMKP benchmarks website [82].
The first set contained 7 instances (I07-I13), and the number of groups in each instance varied between 100 and 400.Each group contained 10 items.Therefore, the number of decision variables ranges from 1000 to 4000.The second set contains 20 instances (INST01-INST20).The number of items in each group varied from 10 to 30 and the number of groups ranged from 50 to 400.Therefore, the total number of items in each instance of the second set varied from 500 to 7500.
All benchmarks are characterized by their common dimensionality size m = 10, n indicates the number of groups, and ni indicates the size of group i.The details of these instances are summarized in Table I.
The best results are obtained using the following parameters  maxCycle = 20  limit = 5  TL length = SN  demp = n / ni: Hamming distance (number of allowed exchanges) used in the employed-bee phase. don = ni: hamming distance onlooker-bee phase

B. Performance of MABC
In this section, we compare the convergence performance of our proposed MABC algorithm, which includes surrogate relaxation, Hamming distance, and tabu list, with its basic version, BABC, which does not use these techniques.The objective of this comparative analysis is to demonstrate the favorable impact of these additional techniques on the convergence performance of the MABC algorithm.
Table II provides the detailed results for both algorithms for the two sets of instances.Column 2 shows the CPLEX solution.Columns 3 and 4 display the solutions obtained (Obj) by the BABC and its computational time (CPU), respectively, whereas columns 5 and 6 display the results for the MABC. ) × 100 (18) Columns 8 and 9 present the solutions obtained for the MABC when maxCycle was set to 2000.The best computational times and objective function values for the two algorithms are highlighted in bold.
The results in Table II indicate that BABC provides acceptable results within a short average computational time.The MABC attained better solutions than the BABC with shorter computational times.Therefore, MABC improves the instances by an average of 4.6% with a shorter execution time (a total of 3.46 s against 10.11 s).Evidently, the improvements in the results are due to modifications of the BABC to enhance its performance.Table II shows the good quality of the solutions provided by both BABC and MABC (7% on average for BABC and 2.4% on average for MABC over the quality of the solutions provided by CPLEX); the computational times for both algorithms are very low (0.1 s and 0.3 s on average for each instance for BABC and MABC, respectively), which proves that both the algorithms are very fast and adequate for real-time and critical-time problems.On average, the quality of the solutions generated by the MABC algorithm is 4.6% higher than that generated by the BABC algorithm.This improvement is ascribed to the modifications made during the  When the threshold for the number of non-improvement (limit parameter) times is reached, the solution is discontinued and replaced by a new randomly chosen solution.This explains the sudden drop in the quality of solutions (orange lines).Behavior of MABC for instance 20 when varying the limit and maxCycle set at 100.Fig. 6 shows the sensitivity of the limit parameter to the quality of the obtained solution by setting the maxCycle parameter value and varying only the limit parameter for INST20.The sensitivity of the limit parameter variation becomes detectable only with a large number of cycles (maxCycle = 100 in this case) and a significant separation interval between the values of the limit parameter (intervals of 40, 50, and 100 in this case).Fig. 6 shows that when the limit value is relatively low (the solution quickly reaches the reinitialization threshold), the execution time becomes considerable (26 s for limit = 2 and maxCycle = 100), whereas by increasing the value of the limit, the execution time decreases gradually (until waiting for 11 s in this case).The decrease in CPU time is accompanied by a slight decrease in the quality of the objective function because the more the value of the limit parameter increases, the less the reinitialization phase (scout-bee phase) is executed, and consequently, the running time will be reduced (and vice versa).

D. Comparative study
In this subsection, we compare the results of the MABC with those of state-of-the-art algorithms.
We implemented MABC in Java JDK version 8, and all the reported computational experiments were conducted on a PC with a 2.30-GHz Intel i5 CPU.
Table III presents the results of our approach, compared to the results of six approaches from the literature, namely RLS: reactive local search-based algorithm [57], ALMMKP: ACO approach [63], PEGF-PERC: two variants of the reduce and solve approach [54], TIKS-TIKS 2 : two variants of the twophase iterative kernel search approach [74] and D-QPSO: Diversity reserved quantum particle swarm optimization approach [68].The details of the running configurations of all these state-of-the-art algorithms, except those of ALMMKP (not reported), are presented next.
RLS: The algorithms were coded in C++ and tested on an Ultra-Sparc10 250 Mhz.
PEGF-PERC: The algorithms were executed on an Intel Xeon 2.83 GHz E5440 CPU and CPLEX 12.4.Two variants, PEGF and PERC, were proposed and the best results obtained are presented in Table III.
TIKS and TIKS 2 : The algorithms were coded in Java 8 and Gurobi 9.0 is used as an MILP solver.The tests were executed on an Intel Core I7-5930K 3.5 GHz processor.TIKS has a 1200 s time limit using six cores and TIKS 2 has a 3600 s time limit using two cores on the machine.D-QPSO: The algorithm was coded in MATLAB, run on an Intel Core 2 2.66GHz and tested only on the E1 benchmark set.
To enable comparisons between the best results, Table III presents the best objective function value and the minimal running time produced by our algorithm within 100 trials using different random seeds for each instance.Note that different trials yielded slightly different results, with deviations in the range of 0.1-1.5% in the quality of the obtained solutions.Additionally, the best solutions obtained with CPLEX 12.9 within a time limit of 3600 s are reported.
Most heuristic comparisons in the literature are based on the objective function values.However, it is not fair to assess algorithms by comparing only the best reported solutions.Nevertheless, to facilitate an objective comparison between the computation times of the methods cited earlier, they must be run on the same platform and configuration.Because these algorithms are not available, this is not possible.
Therefore, our comparative study included both computational time and objective function values to better evaluate the performance of our algorithm.The best computational times and objective function values for the state-of-art algorithms, cited in table III, are highlighted in bold.The last column indicates the percentage of solutions achieved by our algorithm compared to the best objective function value from the literature.Finally, the last two rows of Table III, labeled as "Average" and "Sum," report the runtime average and runtime sum, respectively, of all the solutions over all the instances realized by each of the considered methods.
The quality of the solutions generated by the MABC is evaluated against the CPLEX solutions in Table III, showing an average similarity of nearly 2%.This indicates that the MABC produces high-quality solutions that are close to the optimal solutions obtained by CPLEX.Our algorithm demonstrated a significantly improved runtime compared to other algorithms.In comparison to the fastest algorithm (ALMMKP) cited in Table III, which recorded an average runtime of 11.5 s per solution and a total runtime of 294 s for all instances, our algorithm exhibited an average runtime of 0.37 s per solution and a total runtime of 10.11 s for all solutions.Consequently, our algorithm, MABC, resulted in a time saving of more than 283 s for all instances when compared to the fastest algorithm from the literature (ALMMKP).Moreover, for the largest instance, INST17 (7500 variables), MABC provides a value close to 2%, similar to the best solution in less than 2 s (1.3 s).
To further illustrate the significance of the results obtained from the proposed MABC algorithm compared with those of other state-of-the-art algorithms (RLS, ALMMKP, PEGF-PERC, and TIKS), we performed a Kruskal-Wallis test, which is a nonparametric statistical test that compares the median values of independent groups based on the ranks of the observations.The test output provides the p-value and H statistic, where the former measures the probability of observing the data if the null hypothesis (no differences between the groups being compared) is true, and the latter measures the overall difference among the medians of the groups being compared.
We applied the Kruskal-Wallis test on two levels: the objective function value and CPU.For the objective function value, the H statistic was 0.31506, with a p-value of 0.98882, indicating no significant difference among the medians of the groups being compared.This suggests that there is no significant difference between the objective function values of the solutions obtained by the MABC algorithm and those obtained by the other state-of-the-art algorithms.
For CPU, the H statistic was 84.90850 and the p-value was 0, indicating strong evidence to reject the null hypothesis of equal medians among the compared groups.Thus, we can conclude that there is a significant difference in the CPU performance of the MABC algorithm compared with other state-of-the-art algorithms.

V. Conclusion
In this study, we developed a new approach (MABC) to solve the MMKP problem based on the ABC algorithm combined with surrogate relaxation, Hamming distance, and tabu list.The proposed method was validated using 27 benchmark instances.The experimental results verified that MABC generated competitive results (2.4% proximity to CPLEX solutions) within very short computational time (in milliseconds).
The Kruskal-Wallis test was used to compare the performance of the MABC algorithm with that of other stateof-the-art algorithms in terms of objective function value and CPU efficiency.Statistical analysis revealed no statistically significant difference between the objective function values obtained by the MABC algorithm and the other algorithms (H = 0.31506, p = 0.98882).However, for CPU performance, the Kruskal-Wallis test demonstrated a statistically significant difference between the MABC algorithm and the other algorithms (H = 84.90850,p = 0).Thus, it can be concluded that the MABC algorithm has a significantly different CPU efficiency compared with other state-of-the-art algorithms, with very short execution times.
However, increasing the parameter configuration values (limit and maxCycle parameters) may improve the quality of the obtained solutions, but with a significant computational time cost.Therefore, using the Hamming distance during the exploitation process to limit the local search to a finite number of groups (items) significantly reduces the time complexity of the algorithm.However, this may lead to a loss of information.
Therefore, the MABC algorithm is effective for solving optimization problems with complex constraints and objective functions.Nevertheless, the performance of the algorithm may depend on the selection of parameters, and it may not be suitable for problems requiring high precision or a large number of variables.
In future work, we aim to improve the quality of the obtained solutions without increasing the computational weight of the algorithm.This study was restricted to feasible exchanges between items.Thus, complex moves that traverse the solutions from the feasible search space to the infeasible space, and vice versa, can be examined.In addition, a systematic empirical study on the general swarm intelligence performance (including that of ABC and ant colony) can be

FIGURE 1 .
FIGURE 1. Structure of a solution X for the multiple-choice multidimensional knapsack problem (MMKP).
This article has been accepted for publication in IEEE Access.This is the author's version which has not been fully edited and content may change prior to final publication.Citation information: DOI 10.1109/ACCESS.2023.3264966This work is licensed under a Creative Commons Attribution 4.0 License.For more information, see https://creativecommons.org/licenses/by/4.0/ =   − ∑ ∑      |  = 1,  = 1, . ., (12) This article has been accepted for publication in IEEE Access.This is the author's version which has not been fully edited and content may change prior to final publication.Citation information: DOI 10.1109/ACCESS.2023.3264966Thiswork is licensed under a Creative Commons Attribution 4.0 License.For more information, see https://creativecommons.org/licenses/by/4.0/which reduces the overall load on the resources during the subsequent iterations of the exploitation process.
This article has been accepted for publication in IEEE Access.This is the author's version which has not been fully edited and content may change prior to final publication.Citation information: DOI 10.1109/ACCESS.2023.3264966This work is licensed under a Creative Commons Attribution 4.0 License.For more information, see https://creativecommons.org/licenses/by/4.0/ Column 7  shows the deviation between the results of the two algorithms, given by %dev = This article has been accepted for publication in IEEE Access.This is the author's version which has not been fully edited and content may change prior to final publication.Citation information: DOI 10.1109/ACCESS.2023.3264966This work is licensed under a Creative Commons Attribution 4.0 License.For more information, see https://creativecommons.org/licenses/by/4.0/

Fig. 4
Fig.4provides a closer view of the behavior of the MABC by illustrating the evolution of the quality of solutions over time (I13 as an example).The figure demonstrates a continuous gradual improvement in the quality of the solutions over the cycles until it reaches a maximum (stagnation phase).When the threshold for the number of non-improvement (limit parameter) times is reached, the solution is discontinued and replaced by a new randomly chosen solution.This explains the sudden drop in the quality of solutions (orange lines).

FIGURE 5 .
FIGURE 5. Behavior of MABC for instance 20 when varying maxCycle with the limit set at 5.

Fig. 5
Fig. 5 shows the behavior of MABC when fixing the limit parameter value and varying the maxCycle parameter value for instance 20.It is clear from the figure that the objective function value of the obtained solutions gradually increases by 2.7% from maxCycle 1 to 19 (41% improvement in total), until it becomes almost constant at 20.This significant improvement requires almost no extra-computation time (less than 0.1 ms in each cycle).

FIGURE 6 .
FIGURE 6. Fig. 6.Behavior of MABC for instance 20 when varying the limit and maxCycle set at 100.
This article has been accepted for publication in IEEE Access.This is the author's version which has not been fully edited and content may change prior to final publication.Citation information: DOI 10.1109/ACCESS.2023.3264966This work is licensed under a Creative Commons Attribution 4.0 License.For more information, see https://creativecommons.org/licenses/by/4.0/ This article has been accepted for publication in IEEE Access.This is the author's version which has not been fully edited and content may change prior to final publication.Citation information: DOI 10.1109/ACCESS.2023.3264966Thiswork is licensed under a Creative Commons Attribution 4.0 License.For more information, see https://creativecommons.org/licenses/by/4.0/conducted to achieve an efficient and consistent solution quality for the MMKP.