Metaheuristic algorithms for one - dimensional bin - packing problems: A survey of recent advances and applications

: The bin - packing problem ( BPP ) is an age - old NP - hard combinatorial optimization problem, which is de ﬁ ned as the placement of a set of di ﬀ erent - sized items into identical bins such that the number of containers used is optimally minimized. Besides, di ﬀ erent variations of the problem do exist in practice depending on the bins dimension, placement constraints, and priority. More so, there are several important real - world applications of the BPP, especially in cutting industries, transportation, warehousing, and supply chain management. Due to the practical relevance of this problem, researchers are consistently investigating new and improved techniques to solve the problem optimally. Nature - inspired metaheuristics are powerful algorithms that have proven their incredible capability of solving challenging and complex optimization problems, including several variants of BPPs. However, no comprehensive literature review exists on the applications of the metaheuristic approaches to solve the BPPs. Therefore, to ﬁ ll this gap, this article presents a survey of the recent advances achieved for the one - dimensional BPP, with speci ﬁ c emphasis on population - based metaheuristic algorithms. We believe that this article can serve as a refer - ence guide for researchers to explore and develop more robust state - of - the - art metaheuristics algorithms for solving the emerging variants of the bin - parking problems.


Introduction
The bin-packing problem (BPP) is a combinatorial optimization problem that deals with packing a finite set of items with weights into a finite number of bins without exceeding the specified maximum capacity of the bins. This must be done such that the total number of required bins is minimized. The BPP can be viewed as a special case of the one-dimensional (1D) cutting-stock problem [1]. Research into the classical version of the BPP dates back into the early 1970s; however, the structure and applications of this problem have been studied since the 1930s [2]. In terms of computational complexity theory, this problem is known to be NPhard [3]. Therefore, achieving optimal solutions can be time-consuming, specifically for problem instances with large sets of items.
The classical 1D BPP can be formally defined as: for a non-negative bin capacity, C, and a list of n items, = ( … ) L a a a , , , n 1 2 , where a i has a value (size or weight) ( ) s a i satisfying the constraint ≤ ( ) < s a C 0 i (size of item must not be larger than capacity of bin), the requirement is to determine the smallest integer t such that there is a partition of = ∪ …∪ L W W W t 1 2 . Here, the sum of the sizes of the items ∈ a W i j must not exceed the maximum capacity. The set W j can be seen as the contents of a bin with capacity, C [4].
There are several variations of the 1D BPP that fit different applications and have various types of constraintsa few of which will be briefly mentioned here. Coffman et al. [5] introduced the concept of maximizing the number of items that are packed into a bin, with the intention of modelling processor and storage allocation problems. Given a fixed number of bins, m, and a list of items, L, the aim of this variant is to pack the maximum subset of L into the bins in such a way that the maximum bin capacity is never exceeded. Krause et al. [6] proposed a variant of the BPP problem that places a restriction on the number of items allowed to be packed into each bin. Hence, for a given non-negative number, k, each bin may contain at most k items. The authors investigated this problem with task scheduling in mind. Similarly, Coffman et al. [7] described a generalization of the classical version of the BPP, where arrival and departure times were added to each item. Hence, the items in a bin occupy the space according to the specified time interval. This variant is more practical in particular applications such as problems associated with computer storage allocation.
Other research introduced multidimensional variations. The two-dimensional BPP requires allocating a finite set of rectangles into a minimized number of rectangular bins [4]. The three-dimensional problem (3D) proposed by Martello [8] requires packing a finite set of 3D rectangular items into a minimized number of bins. In both problems, the bins must be of a fixed size and overlapping must be avoided.
The classical 1D BPP can be modelled as an Integer Linear Program [9]. Firstly, let u be an upper bound on the minimum number of bins required to pack all the items. Assume that these bins are numbered as The constraints enforce that the maximum capacity of the bin must not be exceeded, and that each item must only be packed into one bin. The goal of the 1D-BPP is to minimize the total number of bins, N , that are used to pack all n items, this can be estimated as follows: where S i represents the size, or weight, of each item in the list of n items, and C represents the fixed capacity of the bins. Due to the complexity of this problem and the variety of real-world applications that can benefit from good quality solutions, many approaches have been used to solve the BPP. These approaches include approximate methods, metaheuristics, and hybrid metaheuristics. In addition, recently, the use of metaheuristic approaches for solving the BPP has become popular. These are incredibly powerful algorithms that have successfully been applied to various combinatorial optimization problems [10], which include the population-based genetic algorithm (GA) [11], particle swarm optimization (PSO) [12], the tabu search [13], and many others. Some main benefits of utilizing metaheuristics are that they easily handle complex constraints present in real-life applications, and they produce high-quality solutions while requiring shorter computational time [14]. However, metaheuristics cannot randomly be applied to optimization problems, but rather, a significant amount of knowledge on the subject is required to create a proper metaheuristic implementation [10] an example of this is choosing a good representation scheme to fit the problem at hand.
The aim of this study is to highlight recent nature-inspired metaheuristics that have been applied to solve the classical 1D BPP and to understand the benefits of this approach, which includes efficiency and high-quality solutions. This survey would invariably provide the much needed guidance to future enthusiastic researchers and industrial practitioners alike, who have interest in adapting the nature-inspired metaheuristic algorithms to solve the well-known BPP. Specifically, we may summarize the technical contributions of this article as follows: • A state-of-the-art review of widely used metaheuristic algorithms for the 1D BPP.
• Critical analysis of design concepts and solution representation for the implementation of BPP using nature-inspired population-based metaheuristic algorithms. • A comparative evaluation of existing literature results for the BPP.
• Suggestions of trending practical application areas for the BPP.
The rest of this work is structured as follows: Section 2 provides an overview of approximate algorithms and the recent metaheuristics that have been used as the foundation of the adapted nature-inspired metaheuristics that solve the BPP. Section 3 provides insights into the aforementioned nature-inspired metaheuristics by elaborating on their key features. Section 4 provides a comparison of results for each of these metaheuristics. Section 5 presents some of the most intriguing recent application areas of the BPP. Finally, the concluding remarks and future research direction are discussed in Section 6.
2 Literature review 2.1 Approximate algorithms Approximate algorithms were the first approach to solve the classical 1D BPP. There are two types of approximation algorithms: online and offline. In online algorithms, the items are considered one by one, with no knowledge of succeeding items. Hence, the placement of the current item is based solely on the size of the current item and the already packed items [15]. A compelling concept that is introduced in the context of online algorithms is that of bounded-space algorithms. Bins can either be open or closed, and items must only be packed into open bins. When a new bin is added, it is given the status of "open." In some algorithms, the bin may be closed due to the inability to add items to the contents (as it may result in exceeding the maximum capacity). Therefore, a bin-packing algorithm is considered a k-bounded-space algorithm. This means that if there are k bins open and a single item is packed into a new bin, then one of the open bins must be closed [15].
The Next Fit (NF) heuristic packs the maximum number of items that the current bin can contain, and when there is no available space for the next item, the current bin is closed, a new bin is opened, and this bin becomes the current bin [16]. The First Fit (FF) heuristic differs from NF in that the bins are not closed. Each item is packed into the first bin that has sufficient space. If an item cannot fit into any of the available bins, a new bin is opened [16]. The Best Fit (BF) heuristic packs an item into the best, or most suitable, binthat is, the bin with the smallest available space after including the current item into it. As in FF, if no bin can fit the current item, a new bin is opened [16].
On the other hand, offline algorithms have also been used to solve this problem. Famous examples are the NF-Decreasing, BF-Decreasing, and FF-Decreasing algorithms. This type of heuristic processes the data before packing the items into the bin. Generally, this means that the items are rearranged and sorted in increasing or decreasing order [4]; thereafter, these algorithms fill the bins just as the original NF, BF, and FF algorithms do. These offline algorithms are not guaranteed to return optimal solutions every time.
An example of an algorithm that is both online and offline is the Better-Fit heuristic algorithm (BFH) [17], which removes an existing item from a bin and replaces it with the current item if the current item better fills the bin. Moreover, if the packing of the current item results in a smaller available space than the packing of the existing item, then the latter item is removed from the bin it is in. This "replaced item" is then packed using the BFH. This continues for all items until better-fit cannot pack a replaced item. In this case, the BF heuristic is used to pack the object. This algorithm outperforms the BF heuristic in every instance. The performance of the algorithm is based on the sequence of items. If the items are arranged in decreasing order, then the results are equivalent to that of BF-Decreasing, and if the items are arranged in increasing order, the algorithm will place small items into the initial bins. Larger items cannot replace these. Therefore, the best performance is the average case in which the item weights (or sizes) are random [17].

Metaheuristic approaches 2.2.1 The fitness-dependent optimizer (FDO)
The FDO was developed in 2019 by Abdullah and Ahmed [18]. It is a swarm intelligent algorithm that models the characteristics of the reproductive process of bee swarms, along with their collective decision-making behaviour. Although the FDO is considered a PSO-based algorithm, it calculates the velocity of a particle differentlyit uses the problem fitness function value to produce weights. These weights then guide the algorithm's search agents during the exploitation and exploration phases. Additionally, the FDO algorithm requires fewer computations than the PSO algorithm for updating the velocity and particle positions [19]. Bees are social insects who reside in small caves or hollow trees. They work in colonies that are generally called hives. The three types of bees in a colony include the queen, worker, and scout bees. Each of these bees has specific functions according to their traits. The FDO algorithm focuses on the function of the scout bees. These bees explore their environment in order to locate a suitable place for the colony to build a hive (in other words, they exploit preferable hives). Once this is found, the bees perform a sort of "dance" to communicate with the swarm [20]. In the algorithm, each hive that is exploited by a scout bee is seen as a candidate solution, and the best hive represents a global optimum solution, according to the relative fitness weight.
The advantages of this algorithm are that it is stable in both the exploitation and exploration phases and that it requires fewer computations than other algorithms. The disadvantage is that it uses a weight factor in order to control the fitness weights which are, in most cases, ignored [21]. Abdul-Minaam et al. [19] took into account these strengths and weaknesses. They adapted the FDO to solve the 1D BPP by replacing the original way of generating the first population with a random generation of the initial population using an improved FF heuristic and by updating the operating strategies in the original algorithm to improve the exploration and exploitation phases.

Cuckoo search via Lévy flights
In 2009, Yang and Deb developed the population-based Cuckoo Search via Lévy Flights (CS) metaheuristic algorithm [22]. This algorithm was inspired by the breeding strategy of certain cuckoo species, as they tend to lay their eggs in nests belonging to birds of other species or host birds. Often, these cuckoos choose a nest that contains recently laid eggs. A host bird could react to the realization of a foreign egg in their nest in two waysthey may get rid of the alien egg by throwing it away, or they may abandon the entire nest and rebuild elsewhere. Some cuckoos have evolved such that the female parasite cuckoos can mimic the colours and patterns of the eggs of the host birds, thereby reducing the probability of their eggs being abandoned. This technique leads to an increase in reproductivity [23]. These cuckoo eggs tend to hatch before the other eggs present in the nest. The first instinct of the chick is to evict the host eggs by blindly propelling these eggs out of the nest. This action leads to an increased portion of food provided by the host bird to the cuckoo chick. The Lévy Flights mechanism replaces the simple random walk to improve the performance of the algorithm [22]. This mechanism flight is described as a "random walk in which the step-lengths are calculated with a heavy-tailed probability distribution" [23].
The advantages of this algorithm include that it uses far fewer parameters than most metaheuristics; therefore, not much tuning is required, it is straightforward to implement, and it is easily hybridized with other algorithms. A significant disadvantage is that fast convergence cannot be guaranteed because it is dependent on random walks [24]. Zendaoui and Layeb [25] used these strengths to aid their attempt to adapt the CS algorithm to solve the 1D BPP by introducing an interesting mechanism, Ranked Order Value (ROV), in order to convert the results of the original algorithm from a continuous space to a discrete space.

Whale optimization algorithm (WOA)
The WOA was developed in 2016 by Mirjalili and Lewis [26]. This algorithm is a swarm intelligence-based metaheuristic, and it imitates the hunting strategy of humpback whales. These whales are known for their ability to use an uncommon hunting strategy, also called the "bubble net" strategy. This is where the whales cleverly cooperate to trap their prey, fish, into a ring of air. The whales accomplish this by emitting a stream of bubbles. These bubbles take two different shapes: the first is a spiral, and the second is a shrinking circle. After trapping their prey in these bubbles, the fish are swallowed by the humpback whales. In the algorithm, the exploration phase is represented by the hunt for prey, while the hunting strategy utilizing the shrinking and spiral shapes represents the exploitation phase. The positions of the prey are randomly initializedthis represents the initial population, which is evaluated to find the current best solution.
The advantages of this algorithm include the simplicity of implementation and low computational cost. On the other hand, the disadvantage is that the algorithm sometimes results in stagnation in local optima, and that the exploitation phase would be more beneficial if it were improved [27]. Abdel-Basset et al. [28] utilized these strengths in their adaptation of WOA to solve the 1D BPP, called the Improved Lévy-based Whale Optimization Algorithm (ILWOA), developed to solve the BPP. This was accomplished by integrating various mechanisms including the Largest Order Value (LOV) technique (in order to convert the continuous results to discrete ones) Lévy Flights, and Chaotic maps to overcome the weaknesses of the original WOA.

Squirrel search algorithm
The Squirrel search nature-inspired optimization algorithm (SSA) was developed in 2018 by Jain et al. [29]. This algorithm mimics the behaviour of flying squirrels and their efficient movement. The flying squirrels do not fly, but rather they use a special technique known as gliding. This technique is considered highly efficient because it is energetically cheap and enables small animals to cover great distances quickly [30]. There are three primary assumptions in the SSA [29]. First, there is a certain number of flying squirrels in the forest. Second, each of these squirrels forages for food and utilizes the available food resources dynamically. Finally, there are three types of trees in the aforementioned forestnormal, acorn, and hickory trees.
An advantage of this algorithm is that there is an efficient search space exploration. The disadvantages, on the other hand, is that it suffers from premature convergence and that it is possible, when solving complex problems, that the algorithm will get trapped in a local optimum [31]. El-Ashmawi and Abd Elminaam [32] modified the SSA to solve the 1D BPP with these weaknesses in mind, aiming to improve on them. The modified algorithm incorporated randomization in the initial population and tweaks to the operating strategies to enhance the new generations during exploration.

GA
The GA was initially proposed by Holland [33] and has been applied to a vast range of optimization problems. This algorithm mimics the natural selection process of evolution, based on the teachings of Charles Darwin [34]. In GA, solutions are modelled as chromosomes, which can take many different formsfor example, binary strings or real number vectors. A population consists of multiple chromosomes. A fitness function must be defined so these chromosomes can be decoded and evaluated, and a fitness value can be assigned to this chromosome. This value is an indication of the strength of that individual in the current population and dictates the probability of being selected for the creation of the next population. The newer populations are generated by performing techniques on the chromosomes such as mutation and crossover. Stronger, or more fit, chromosomes are more likely to be chosen to be carried into the new population after the genetic operators have been applied, so that the new populations contain better quality solutions.
The advantages of this algorithm include that it has been developed to deal well with complex problems and parallelism, and it is easy to understand and implement. However, naturally, there are disadvantages to this metaheuristicthis includes the difficulty in formulating the correct fitness function for the given problem, determining the best population size and parameters such as the crossover and mutation rate, which governs how often the operators must occur during the iterations of the algorithm. An inappropriate selection of these parameters and functions may cause the GA to produce results that do not have meaning, or it may be increasingly difficult for the GA to converge [34]. Quiroz et al. [35] used the GA as a foundation for their grouping GA, adding grouping mechanisms and a fascinating selection mechanism to solve the BPP.
3 Optimization methods 3.1 Adapting metaheuristics for the 1D BPP Figure 1 illustrates a general overview of metaheuristic algorithms that are used to solve the 1D BPP. The algorithm begins by defining parameters, such as population size and any other values that must be specified to ensure the algorithm functions as intended. Next, the initial population is generated. This step is important, and the method chosen to do this impacts the efficiency of the algorithm greatly. Next, the solutions go through the "fit and evaluate" phase. This refers to using approximate algorithms (discussed in Section 2) to pack the items into bins. This packing is then evaluated by the objective function so that the solution is assigned a fitness value that will determine it's position in the population. This phase additionally helps to determine the best solution in the population. This best solution is then stored in memory. The algorithm will then perform the specific local and global walks so that the population is improved by adding solutions with more favourable fitness values and generally discarding of unfavourable or weak solutions. The "fit and evaluate" phase must be repeated at this stage so that the best solution can be checked against, and if a better solution than the current best is found, then this solution replaces the best solution in memory and becomes the current best. Some algorithms may require an update to parameters, but this is not always the case; therefore, this is optional. Thereafter, the termination criterion is checked. Usually, termination criterion refers to the number of iterations (generations of population) the algorithm has gone through. However, the criterion may also be to check if the current best solution is an optimal solution. It is possible that either one or both of these conditions are checked at this point in the algorithm. If the criterion has been met, then the algorithm may end and produce the final solution. However, if the criterion has not been met, the algorithm returns to update the population using exploration and exploitation mechanisms, so that a better solution may be found, and the cycle continues.

Adapted metaheuristics for the 1D BPP
All equations have been taken directly from the surveyed papers, and all figures and algorithms have been adapted from these papers.

Objective function
If this function is set to be just the number of bins, the algorithm may eventually experience stagnation [19]. This is due to several possible solutions having the same number of bins, yet different representations, and therefore, various amounts of unused space. In order to avoid such stagnation and move towards finding the optimal solutions, the objective function should consider the amount of unused space, as well as the number of bins for a specific representation. Hence, the following functions are used: which essentially entails giving more value to the solution using the least bins and having the least amount of unused space. So, fill k is the capacity of bin k (it is the sum of the sizes (S i ) of all items in the bin), N represents the number of bins in the solution, C represents the fixed bin capacity, and z represents a constant that is used to define the equilibrium of the filled bin (generally kept at = z 2) [19].

Adaptive fitness-dependent optimizer (AFDO)
In 2020, Abdul-Minaam et al. [19] adapted the FDO algorithm to solve discrete optimization problems and tested it on the BPP, and this was named AFDO. This algorithm aims to improve the solution quality for the BPP. For the adaptation, the authors suggested using a random initial population and added an update to the algorithm procedure. In this algorithm [19], an artificial bee scout represents a candidate solution to the BPP. Each solution is a vector of n dimensions where one dimension represents the index of an item, and another represents the index of the bin that the corresponding item is assigned to. Abdul-Minaam et al. [19] found this representation to aid in minimizing the number of bins used while allowing multiple items to be packed in one bin without exceeding the maximum bin capacity constraint. This can be seen in Figure 2. Figure 2(a) represents the list of items with their indexes and corresponding weights.
Since the initial population influences the execution time and quality of the result [19], the authors modified the FF heuristic such that the algorithm takes in a shuffled list of items and randomly assigns the items to the first available bin. This allows for the generation of diverse, feasible solutions in the initial population. Figure 2(b) and (c) represents possible solutions using the modified FF heuristic.
An additional variable to be considered in this algorithm is the weight factor, wf, that is either set to 0 (neglect the factor) or 1 (lowers the possibility of coverage and increases the level of convergence). This weight controls the stability of the search and dramatically influences the movement of the bees towards the next position. Therefore, it is a parameter that requires testing. The fitness weight is directly impacted by the weight factor, as shown in equation (1), where ( ) * f X i t , represents the global best solution's fitness value and ( ) f X i t , represents the current solution's fitness value.
The new position of a scout bee relies on the movement rate, pace, and direction. Only a positive direction is considered in the AFDO algorithm. The pace is computed by considering the current solution (X i t , ), a random number, r, generated with uniform distribution (rate), and the fitness weight (the last two are critical parameters that improve the exploration of the search space), as can be shown in equation (2): , , The cases in this equation represent the influences on the movement direction. In the first case, a random sequence of raw vectors is generated from the current solution, based on the number of bins and items in the specific problem instance. As can be shown in Figure 3, the final solution of the first case is raw vectors, of the form ⟨ ⟩ item old bin new bin , , . The random number, r, is set to 0.2 and represents the probability that a task (assignment of an item to a bin) is selected for an update in the aforementioned vector. If a task is selected, a new bin is randomly chosen for the item to be assigned to. This modification to the FDO algorithm provides the possibility of obtaining multiple solutions through the use of randomization. The number of items, I , is 10.
In the second case, the result of the ⊖ operator is computed by taking the difference between the current solution and the global best solution thus far. This is given in terms of raw vectors, as shown in Figure 4. The form of the vectors is the same as mentioned previously. If an item is assigned to the same bin in both solutions, then no change is made. If an item is in two different bins in the solutions, then the raw vector is added to the set. The ⊗ operator represents the chance of fw choosing each generated raw vector. Since = fw 0.3, three of the raw vectors are randomly chosen in the final output.
After that, the solution's pace is calculated as in equation (3), and the new solution is introduced, as shown in Figure 5.
It is worth noting that the reassignment of an item to a bin will only occur if the suggested reassignment does not cause the bin to overflow (in other words, exceed capacity). This is the reason that the first and third raw vectors in the pace in Figure 5 do not affect the resulting solution.
The algorithm continues until a predefined number of iterations is reached or the most optimal solution is found. The pseudocode for this algorithm can be seen in Algorithm 1. Update the remaining capacity of the bin that the item was added to remove the size of the item from the bin's current capacity ;

Adaptive cuckoo search (ACS) algorithm
The CS algorithm follows three cardinal rules: First, each cuckoo must lay one egg at a time and randomly chose a nest to dump this egg in. Second, the nests that contain eggs of the highest quality will proceed to the next generation. Third, there is a fixed number of available hosts, and the host bird discovers the cuckoo egg with a probability, p a , between 0 and 1 [34]. Additionally, this probability governs the balance between the local and global explorative walks. In 2016, Zendaoui and Layeb [25] adapted the cuckoo search algorithm to solve the 1D BPP problem (ACS). Since the original CS algorithm was designed to solve continuous optimization problems, it could not directly be applied to solve the discrete BPP. Therefore, the authors proposed utilizing a method that linked the continuous output of the algorithm to integer representations that correspond to the index of the items in a given list. The ROV method was employed for this reasonit guarantees the feasibility of new solutions and avoids creating any additional overhead. This can be shown in Figure 6.
For the representation of solutions in ACS [25], the authors assume that only one egg is laid in one nest, and each nest contains a single egg. The egg in this nest is a candidate solution represented by an item permutation, determined by the ROV. The FF method was used to assign the items to the bins and evaluate the fitness of a solution. Two essential movements are used to generate new solutions in the ACS. Firstly, a local random move which can be seen in equation (4). This move is used for exploitation and produces a new solution by utilizing two randomly selected solutions (x j t and x k t ), a Heaviside function, a random number, ε, drawn from uniform distribution, and s which represents the step size. An example is provided in Figure 7.
Second, a global random move via Lévy Flights is used for exploration. This is shown in equations (5) and (6). A scaling factor, α, related to the scale of the problem to be solved must be set. Once the result of the Lévy Flight is calculated, it is added to the continuous version of the item permutation, and the solution is ranked once again with ROV, and then evaluated by the objective function. An example is provided in Figure 8.
A fraction, equal to p a (the switching parameter that is predefined), of nests with unacceptable fitness values are abandoned. In other words, these solutions are replaced with new solutions generated using the local walk movement. The algorithm tracks the best solution and only replaces this position if a solution with a lower fitness value is found (since the aim is minimization).
This algorithm continues until the number of iterations has reached a predefined number or if an optimal solution is found.
The pseudocode for this algorithm can be seen in Algorithm 2.

ILWOA
Although the convergence rate and performance of the original WOA [26] were good and obtained a highquality solution in a negligible time when applied to a continuous search space, Abdel-Basset et al. [28] observed that WOA also performed well on combinatorial problems. This observation motivated the attempt to adapt this algorithm to solve the BPP. Therefore, in 2018, the ILWOA was developed. Three enhancements were made in this algorithm. The deployment of Lévy flights for whale movements improved the exploration capabilities of WOA, the original algorithm was embedded with a mutation phase in order to enhance convergence speed, and a logistic chaotic map was utilized to swap between exploitation and exploration phases efficiently.
Since it was necessary to discretize the search space, the authors used the LOV technique. As shown in Figure 9, this technique first ranks the descending order of continuous values, , , where 1 to n represents the dimensions of the solution. This results in a sequence, , . To decode the solution, the formula used is , where k represents the corresponding dimension [36].
The BF heuristic was employed for packing bins with the assigned items. The representation used in this study was simply a list of items. The Lévy distribution has an infinite mean and infinite variance. This causes a longer movement from the solution's current position to the new position, which is much more efficient for the exploration phase.
For improved diversification of the given search space, the WOA [26] combines a couple of exploration search mechanisms. This is carried through and slightly modified in the ILWOA. The probability of these search mechanisms being employed on a candidate solution depends on a switching parameter.
Chaotic maps can be described as: "evolutionary functions that produce a deterministic bounded sequence of random numbers depending on initial condition" [28]. The authors decided to use logistic chaotic maps to determine the switching parameter value due to the random-like parameter adaptation [28]; this value is known as p. The value of a coefficient vector from the original WOA, → C , is replaced by a random step that is drawn from Lévy distribution (equation (6)). A random variable, r, and p dictate how the solutions are updated.
→ A is calculated as in equation (7). This coefficient vector includes → a which represents the shrinking feature of the spiral and decreases from 2 to 0, and → r which represents a random number between 0 and 1.
The use of two exploration mechanisms introduces improved diversification of the search space.
Therefore, the value of → A influences whether the best solution or a randomly selected solution will affect the positions of solutions in the search space. This is explained below.
If < r p and → < A 1, then the update is calculated using equation (8) and the solution is generated using equation (9). In these equations, the current best solution and the current solution are represented by → ( ) * x t and → ( ) x t , respectively.
However, if < r p and → ≥ A 1, then the update is calculated by equation (10), where → ( ) x t r is a random solution chosen from the current population, and the updated solution is generated by equation (11).
If ≥ r p, then the update is calculated by equation (12) and the position is updated spirally by equation (13). These equations simulate the whales' movements around the prey, specifically, the best solution found thus far. In equation (13), b is a pre-specified constant that defines the shape of the spiral and l is a randomly selected number in the range [− ] 1, 1 .
The additional mutation phase occurs before and after each iteration. In this phase, the current best number of bins is tested for optimality. If the test is successful, the search stops. However, if the test fails, the solution is randomly modified by three operators, namely, swap, displacement, and reversion. The swap operator randomly chooses and swaps two indexes in the solution. The displacement operator randomly chooses a subset of items and inserts it into another place in the solution. Finally, the reversion operator randomly selects a subset of the solution and reverses the order of the items within that subset. These mechanisms further improve the exploration capabilities of the algorithm. Figure 10 illustrates these operators. This occurs until the maximum number of iterations has been reached.
The pseudocode for this algorithm can be seen in Algorithm 3.
Algorithm 3: Pseudocode of improved Lévy-based whale optimization algorithm Generate the initial population; Use LOV to map continuous population to combinatorial population; Evaluate population; Set * x to the current best solution; Set * perm to the current best permutation; Set * nbin to the current best number of bins; while termination criteria has not been met do

Modified squirrel search algorithm
In 2019, El-Ashmawi and Abd Elminaam [32] modified the SSA algorithm in order to apply it to the BPP. This version of the algorithm generates random but feasible initial solutions. Additionally, various operating strategies are employed to update the locations of the squirrels. This aids in generating new populations during the exploration phase of the algorithm. The feasible initialization step ensures that the initial population's randomness explores the solution space in an efficient manner. This was accomplished by improving the BF heuristicrandomly assigning items from the given list of items to the BF bin (such that total waste is minimized). The evaluation of the population depends on the values of the fitness function, as is with most metaheuristics. The population must be sorted according to the ascending order of fitness value. The best squirrel (the one with the lowest fitness value) is assigned to the hickory tree. Being on this tree indicates that this particular squirrel is at the optimal food source. In other words, it is a current best solution. The next three squirrels with relatively low fitness values are assigned to the acorn tree. This implies that those squirrels are at the normal food source. In other words, these solutions are near-currentbest. Finally, the rest of the squirrels are assigned to the normal tree. This means that these squirrels have no food sourceimplying that these solutions are quite far from the current best [32].
Individual solutions are updated according to the tree that they are assigned to. If a solution is on an acorn tree, it moves towards the hickory tree, and if it is on a normal tree, it can be moved towards either the acorn or the hickory tree. The probabilities of these updates are controlled by a random number ( ) r r r 1, 2, 3 drawn from a uniform distribution, between 0 and 1, and a constant, Pdp. This constant is known as the "probability of a predator" and it is set beforehand. If the random number is not greater than the specified constant, the squirrel's position is randomly updatedthis procedure achieves good exploration of the search space. These updates are shown in equations (14), (15), and (16). The α β , , and γ values are random numbers between 0 and 1. These values denote the gliding distance of each squirrel.
The ⊖ operator calculates the difference between the two solutions and results in a set of swap operators difference means to look at each item-bin entry in the solutions and, if the two solutions have the same item in the same bin, no swap operator is created, but if the two solutions have the same item in different bins, a swap operator of the form ⟨ ⟩ item number bin number , is added to the set. An example of this can be seen in Figure 4.
The ⊗ operator computes the probability that the swap operators in the set are selected and applied in the update (the probability is given by α β , , and γ). Based on the result (a number) of this operation, random solutions are selected from the set. This can also be seen in Figure 4; however, the example uses fw in place of the random values in this algorithm.
The ⊕ operator updates the solution. In other words, it changes the location of the squirrel. This is done by replacing the item-bin pairs in the chosen solution with the selected swap operators. An example of this is shown in Figure 5; however, instead of a "set of swap operators," "pace" is used. These functions are essentially the same.  If the random number ( ) r r r 1, 2, 3 is less than Pdp, this indicates that a squirrel was not able to reach a source of food, but survives regardless and moves to a location that is randomly generated. This is done by generating swap operators randomly and applying the ⊕ operator to the solution. This is shown in equation (17). O i represents the swap operators, and ≤ ≤ i m 1 where m is the number of swap operators generated. These random walks introduce improved exploration in the space.
The stopping criterion is based on the number of iterations reached compared to a pre-specified maximum number or until the optimal value has been found. The pseudocode for this algorithm can be seen in Algorithm 4.

Grouping genetic algorithm with controlled gene transmission (GGA-CGT)
In 2015, Quiroz et al. [35] published the GGA-CGT to solve the 1D BPP. The authors propose transmitting the best genes in a chromosome while maintaining the balance between diversity and selective pressure in the current population. The algorithm consists of the following features: a novel technique for generating a high-quality initial population, grouping operators that aid in exploiting the search space of the problem, a rearrangement operator that aids in exploring the search space, and the balance of the evolution is ensured by the use of a novel reproduction technique that is capable of preventing premature convergence and governing the exploration phase.
The initial population is generated with a modified FF heuristic. Until a predefined number of iterations is reached or the optimal solution is found, the individuals in the population are recombined and mutated in a couple of phases. First, some individuals are selected with "controlled selection," and the gene-level crossover and FF decreasing heuristic are employed on the selected individuals. Afterwards, "controlled replacement" is utilized to introduce the offspring. The second phase considers a predefined "lifespan" of individualsaccording to this lifespan, elite individuals with superior fitness values are cloned, and several individuals are chosen to apply genetic alterations to. These alterations are accomplished with the use of "adaptive mutation" and "RP" (Rearrangement of Pairs). As in the first phase, controlled replacement is applied to individuals in the second phase, before they are added to the new population. Algorithm 5 shows the pseudocode for this algorithm. GGA-CGT uses a group-based encoding schemeso, there could be various lengths of chromosomes based on the number of bins used in the specific solution. Therefore, every gene in a chromosome is a "group" of items. Each group is packed into a single bin.
The authors introduced a rather interesting method of generating an initial population from a set N of n items by first finding a subset, Ñ , of ñ items that have weights greater than half of the fixed bin capacity. This subset represents items that cannot be packed into a bin with items of the same subset, as this would cause a bin to overflow. The items of Ñ are packed first into different bins, and then the remaining items of N (that are not part of Ñ ) are randomly packed into the bins using the FF heuristic.
The grouping crossover operator called the gene-level crossover can be described as follows: A novel crossover for group-based representation was introduced, whereby the two selected parent solutions are compared on a gene-level. Two children are produced, as both of the selected solutions are given the opportunity to be the "first father." First, the operator looks at the bins in each solution according to the descending order of how full each bin is. This is done so that the offspring have a better chance of inheriting the best bins in the parent solutions. To create the offspring, for every pair of bins, the bin that is more filled is inherited first. The bins are compared in parallelso, the first bin of the first father and the first bin of the second father are considered a pair. After that, the other bin in the pair is inherited. This continues until all the bins in both parent solutions have been added. In the event of a pair of bins being equally filled (have the same amount of available space), the first father's bin is inherited first. It can be observed that this method would result in a duplication of items since every bin from both solutions is added to the child solution. Therefore, if a bin contains an item that already exists in the solution (i.e., the item can be found in a previous bin), then the bin containing the duplicate item is eliminated from the child solution. This elimination may cause the child solution to be invalid since it would not contain all the items from the problem instance. The method resolves this issue by determining the missing items and placing these items into the existing bins by using the FF decreasing heuristic. This can be seen in Figure 11.
The grouping mutator operator permits introducing random changes into the population, resulting in more diversity in the solutions, so there is more exploration of the search space. The proposed mutator operator promotes transmitting the "best genes" in a chromosome and is applied at the gene level to avoid the loss of high-quality genes (which are essentially well-filled bins). This operator eliminates the bins that have the most available space (are not well-filled) and reinserts the items from the eliminated bins into the solution with the help of a rearrangement technique that is discussed later. The operation is called adaptive because the number of bins that will be eliminated in a solution, n b , is determined by equation (18) considering: the solution size (m) and how many bins in the solution and not completely filled ( ) τ , the elimination proportion ( ) ε as calculated in equation (19), and the probability of elimination ( ) P ε as calculated in equation (20).
where k defines the rate of change of the elimination proportion, ε, and probability, P ε , concerning the number of incomplete bins, τ.
The rearrangement heuristic, called "rearrangement by pairs," or RP, is a technique that must be implemented in two steps. First, every bin is reviewed to determine the possibility of improving its packing schema by swapping pairs of already-packed and free items (free items are also known as "missing items" which are items that need to be placed in a bin but are not present in the solution being repaired). Second, the remaining items are inserted into the solution through the FF heuristic. This technique has a significant impact on the exploration and exploitation of the search space. Algorithm 7 explains the rearrangement by pairs procedure. ′ S denotes the result of swapping the items s and p from the bin Bj with an item i from F.
is true if the swap that has occurred results in a bin with a capacity that does not exceed the fixed maximum capacity, otherwise it is false. Both the items from S and F are considered in pairs. There are two possibilities for the two pairs of items, as shown in the IF-statements in the algorithm. These statements say two things: (1) if it can be done, replace the pair of items p and s from the bin with one of the free items from the pair that have a weight greater than or equal to the sum of the weight of p and s, as long as the replacement does not cause the bin to overflow; (2) if replacing the pair of items from the bin (p and s) with the free items (i and k) results in the free items filling the bin equal to or better than the items from the bin, swap the items p and s with i and k. Then, apply the FF heuristic to reinsert the items in F to make the solution valid. Figure 12 shows an example of the adaptive mutator with the rearrangement heuristic. Randomly sort the items of F; The authors additionally propose a "controlled selection" mechanism that balances the population diversity and selective pressure. Population diversity permits exploring new areas of the search space, which positively impacts solution quality and helps avoid premature convergence. The selective pressure awards fitter individuals in the population with a better chance of being chosen for mutation, reproduction, and survival. If these attributes are missing from the algorithm, the search process will not be guided but instead be random, which will result in promising regions of the search space being overlooked. Therefore, balancing these features greatly improves the GGA-CGT's performance. Every individual is given the opportunity to contribute to the succeeding generation of the population; however, the proposed selection scheme ensures that the best individuals survive.
The controlled selection for crossover is as follows: for n c parents to generate n c children, create two sets of individuals, G and R, that will serve as parents. B is known as the elite group, which consists of the best solutions. The first set, G, which stands for "good," contains / n 2 c solutions randomly chosen from the best n c solutions in the current population. In contrast, the second set, R, which stands for "random," also contains / n 2 c solutions randomly selected but from the set: population minus B. The random selections are made with uniform probability. Moreover, because this crossover occurs pairwise between the two sets (hence, G i is crossed with R i , where ≤ < / i n 0 2 c ), the manner in which the sets are chosen avoids a solution being crossed with itself.
The controlled selection for mutation is as follows: a fixed number of solutions, n m , will be mutated. The operator is applied to n m of the best solutions in the population. In this case, lifespan plays a role in determining if cloning occurs. If a chosen solution exists within a specific lifespan, then it is cloned. After this, solutions are selected from the population to mutate, according to decreasing fitness values.
The replacement strategy dictates which solutions are eliminated and replaced by the new progeny. The authors aim to promote exploration by always permitting new solutions to be added. There are two types of controlled replacement: one for crossover and one for mutation. In the controlled replacement for crossover, the first / n 2 c children generated from the crossover operator replace their parent from the random set, R (their second father). The remaining children replace solutions from a subset of the population that does not include the set of best (B) and random (R) solutions. In this latter case, the children either replace solutions from the described subset of the population with duplicate fitness (if they exist) or worst solutions. In the controlled replacement for mutation, the cloned solutions either replace solutions with duplicate fitness (if they exist), or the worst solution in the current population.

Comparison of results
Since every algorithm described in this article used different instances of datasets, and were tested on hardware with varying hardware specifications, it would not be possible to conduct a valid comparison of the metaheuristics with each other. However, the researchers have provided results and compared their proposed algorithms with various other popular algorithms; therefore, this will be analysed in this section.
The benchmark datasets used in all of the reviewed papers were made available by Scholl et al. [37] and are divided into easy, medium, and hard classes. These classes have various numbers of items, weights, and maximum bin capacities. For the easy class, there are 720 instances, and the number of items in each instance can either be 50, 100, 200, or 500. The bin capacities are 100, 120, or 150. In the medium class, there are 480 instances, and the number of items in each instance is the same as the easy class; however, the maximum bin capacity for each instance is 1,000. Finally, for the hard class, there are ten instances, and there are 200 items in each instance, and the capacity is 100,000. These sets have been used to test several algorithms, and it provides a way to compare algorithms based on their success in solving these instances. For the following results, each researcher selected particular instances of these classes to demonstrate the successes of their algorithms. However, these instances do not necessarily overlap between papers.
The AFDO [19] algorithm was tested on three classes of diverse difficulty, and the results were compared to three other well-known metaheuristicsnamely, the PSO, Jaya, and Crow Search (CS) algorithms. In the easy and medium classes, the AFDO was able to display high efficiency in solving the 1D BPP in terms of the average fitness values. Out of 15 instances of the easy class, the AFDO successfully found all optimal values, whereas the other three algorithms found between 7 and 9 optimal values. Similarly, for the medium class, out of ten instances, all ten optimal values were found by the AFDO, whereas the other three algorithms found five or six optimal values. However, in the most challenging class (hard), the algorithm did not reach the optimal number of bins, but it was noted that a better item packing schema was achieved, yielding a lower number of bins compared to the other algorithms. Hence, AFDO proved to effectively explore the search space to locate an optimal or near-optimal solution within a reasonable time.
The ACS algorithm [25] was tested on the described dataset. The results were compared to the FF Decreasing heuristic, the Ant System algorithm, Firefly and Ant Colony algorithm, and the Quantum Cuckoo Search algorithm. For the easy class, the ACS produced results identical to the other four algorithms in the chosen instancesthese were all optimal values. For the medium class, ACS outperformed other algorithms in all chosen instanceseither achieving optimal or near-optimal results. Finally, for the hard class, the ACS successfully achieved better near-optimal results and outperformed the other four algorithms. Moreover, the ACS algorithm has fewer parameters to tune, and as a result, it is easier to implement.
The ILWOA [29] was tested against the ACS algorithm, quantum-inspired cuckoo search, firefly algorithm, firefly colony optimization, and ant system algorithm. For the selected instances in the easy class, the ILWOA performs just like other algorithms and finds the best-known number of bins. For the instances of the medium and hard classes, however, the results obtained using ILWOA were not always optimal but were superior in many cases. The authors also noted that the overall results of the ACS and ILWOA on this standard benchmark dataset were very similar. However, ILWOA was able to return reasonable solutions with fewer iterations and search agents.
The modified squirrel BPP (MSBPP) algorithm [32] was tested against popular metaheuristic algorithms such as PSO, African Buffalo Optimization, and Crow Search Algorithm (CRSA) to solve the BPP. The authors chose specific instances of the benchmark datasets from the easy, medium, and hard classes. For all of these easy class instances, the MSBPP algorithm was able to reach optimal values, whereas PSO and CRSA failed to reach optimal values for even half of the selected tests. For the medium class, the MSBPP successfully reached optimal values for 11 of the 12 instances, whereas PSO performed exceptionally poor, reaching optimal values for merely 3 of the 12 instances. For the instances of the hard class, the MSBPP performed well relative to other algorithms, achieving values much closer to the optimal number of bins.
For the GGA-CGT [35], the authors compared their algorithm to two state-of-the-art algorithms, namely, Perturbation-SAWMBS (PSAWMBS) and the hybrid improvement heuristic for the 1D BPP (HI_BP). The authors of GGA-CGT [35] tested their algorithm on a range of BPP datasets but did not report in detail their findings on the standard benchmark dataset described above. However, the report stated that optimal results for all 720 instances of the easy class, 480 instances of the medium class, and 10 instances of the hard class of the standard benchmark dataset described above were found, just as for the other two algorithms. It was worth noting that the PSAWMBS was a much faster algorithm and obtained similar results in the majority of the datasets that were tested. The most thought-provoking findings of this report were that for the Hard28 dataset, GGA-CGT was able to find optimal results for 16 of the 28 instances, while the other two algorithms were only able to find optimal results for 5 instances. This highlights the superiority of GGA-CGT as the Hard28 dataset is known to be one of the most challenging datasets known for the 1D BPP [35].
Finally, it is very important to highlight here that because the choice of parameter settings can significantly affect the quality of solutions generated by the individual metaheuristic optimization algorithms, several experiments need to be performed in order to find the best combination of parameters values that would give the desired competitive results. Therefore, depending on the scale of the test problems for which the algorithms are being evaluated upon, it is suggested that different empirical and statistical analysis options should be explored and adopted to ensure the efficient selection of the parameter values. However, this approach might be more appropriate for those class of metaheuristics with varying control parameters. As for those variant of metaheuristics with little or no control parameter, such initial evaluation would not be necessary. For example, metaheuristic optimization algorithms such as the symbiotic organisms search algorithm [38,39] and teaching-learning-based optimization [40] are known to have few or no control parameters beside the initialized population size, which is a default control parameter setting for all the global metaheuristic algorithms.

Complexity analysis of metaheuristics
There are three challenging areas in algorithm analysis: complexity, convergence, and no-free-lunch theory [41]. For the traditional algorithms, complexity analysis is well-established because the algorithms are deterministic. However, for metaheuristic algorithms, complexity analysis remains a challenging task to date, partly due to their nondeterministic or stochastic nature. In addition, no generic framework exists for them. Although, in recent times, dynamic systems and Markov processes have been used to study complexity analysis of metaheuristics algorithms, convergence analysis still remains one of the active research areas with many encouraging results [41][42][43].
Furthermore, there is a common belief among domain enthusiasts that metaheuristic algorithms tend to be less complex for implementation. In many cases, the problem sizes are not directly linked with the algorithm complexity [41]. Although most metaheuristics can often solve immensely challenging NP-hard combinatorial optimization problems, our understanding of their performance in terms of efficiency and convergence lacks far behind. Moreover, because of the algorithms, diverse application and capability of solving complex problems like the BPP, metaheuristics can be considered as an efficient way to produce acceptable solutions in a reasonably practical time. In addition, because metaheuristics are random searchbased techniques, the complexity of the problem of interest makes it impossible to search for every possible solution or combination, specifically for large graph size BPPs. Therefore, in most cases, the aim is to find reasonable, feasible solutions in an acceptable timescale. Hence, the general pursuit and idea are to have efficient but practical algorithms that will work most of the time and produce reasonable quality solutions.
Finally, based on the notion of no-free-lunch theorem that Wolpert and Macready proposed in 1997 [44], which states that given any two algorithms A and B, the algorithms will on average perform equally, that is, if algorithm A performs better than algorithm B for some problems, then algorithm B will outperform algorithm A for other problems [41]. This implies that no single universally accepted superior algorithm can solve all types of problems, including the BPPs. However, this does not mean that some algorithms would not perform better than other algorithms for some specific kinds of problems. We do not need to measure performance on average for all functions, but instead, we need to measure how an algorithm performs for a given class of problems.

Recent application areas of BPP
The BPP is an interesting research domain that has over the years received recognition and more comprehensive coverage because of its relevance to industrial applications, especially in cutting (wood and glass industries), packing (transportation and warehousing), and supply chain management (vehicle, container, pallet or cargo loading, cutting stock and trim loss problems, packaging design, resource allocation, load balancing, scheduling, project management, and financial budgeting). Therefore, in this section, we present more recent and general application areas of the BPP, and we tried to classify articles that are published in these areas into their different categories. However, interested readers are directed to refs. [45][46][47][48] for older and more theoretical research coverage on the application areas of the BPP.

Scheduling and resource allocation
The application of BPP to the area scheduling and resource allocation basically deals with the problem of allocating limited resources or tasks with/without time consideration. Researchers have proposed different approaches or variation of the BPP in this regard. For example, Ojeyinka [49] applied the online and offline variants of the bin packing heuristics, implemented using the fill function, on the passenger-bus scheduling and the multiprocessor job scheduling problems. The goal of reducing the timespan needed for a multiprocessor to process all tasks using the BPP is exploited by Coffman et al. [50]. The performance of some scheduling algorithm was evaluated in ref. [51] using the BPP where the operating room time corresponds to the bin to be minimized. Leinberger et al. [52] showed how multi-capacity bin packing can lead to a highly sophisticated multi-resource allocation and scheduling. Furthermore, the scheduling of surgical operations using the BPP was exploited by Van Houdenhoven et al. [53].

Production
The BPP has several practical applications in the supply chain sectors, which cut across different manufacturing and service orientations. For instance, in manufacturing, the product to be manufactured can be considered to be a task to be accomplished within a time frame in a production cycle; the plant used for production is the bin to be allocated to the task (product), and finally, the goal of minimizing production cost is achieved by minimizing the number of bins [54]. Smart packing algorithm was designed by Khairuddin et al. [55] using the GA to solve the 3D bin or container packing problem. The authors in ref. [55] then applied their proposed method to reduce packaging waste due to ineffective packaging in the manufacturing process. Two-dimensional packing algorithm was similarly used in ref. [56] to solve the problem of composite material production in autoclave moulding. The aspect of product delivery using mobile robotics was exploited in ref. [57].

Health care community
The BPP is applied in this area to promote better cooperation between different components within the health care sector to provide an improved health care system. Surgical cases and resource scheduling using BPP were exploited in refs. [53,58,59]. The common goal here is to make optimal use of the operating rooms by scheduling surgeries that can be combined to achieve high throughput in the system. Patient scheduling for access to a practitioner was exploited in ref. [60], they used BPP for effective and optimal scheduling of patients to available practitioners. In the real sense, this problem is essentially a BPP with the modification that each bin might have a different total size. Each doctor forms a bin whose capacity is equal to the number of free hours in the doctor's schedule, and each patient is an object to be placed into a bin, whose size is equal to the number of hours for which she needs to be seen. The overall goal here is to find the most efficient way to schedule patients across doctors, while upholding certain measure of fairness in terms of workload across the doctors, and maximizing fairness while getting every patient seen by the prescribed doctors on duty. However, this task would become even more complex and difficult to solve when dealing with a scenario where the doctors are specialists in different subfields and each patient needs to be seen by a doctor with a certain set of skills under the different subfields depending on their medical practice.
Another interesting application of the BPP is in nurse scheduling, here a consideration of the capacity of the nurses and the various needs of the patients using BPP are taken into account. A nurse to patient allocation relative to the BPP was considered in ref. [61].

Distribution and inventory
Although some aspect of the distribution and inventory system can be classified as being part of the production category, distribution and inventory are well researched using the BPP. The BPP fits in here because of consideration of sizes and shape, technological and orientation constraints during delivery and so on. Gupta and Radovanovic [62] considered a scenario of items in the form of a sequence (for delivery or inventory) that must be packed on arrival. A similar scenario was considered in ref. [63] except that in this case, additional constraints of no buffering and readjustment were added. For an inventory, online order fulfilment is an integral part of e-commerce. Zhang et al. [64] proposed a solution to the dynamic stocking problem using a mixed integer programming. Besides, without adequate inventory in a warehouse, storage processing is interrupted. Ravichandran and Sasi [65] proposed a robust solution approach using the BPPbased farm optimization algorithm.

Logistics
The logistic process, in this case, implies packaging and routing of goods and services for different interests. This industry usually deals with the respective company rules on handling their products; however, this is by no means an easy task. Sajini Anand and Guericke [66] proposed a variable size BPP to achieve this objective. A smart packaging scheme was proposed by Khairuddin et al. [55]. A scenario where a decision must be made from a list of permissible actions upon the arrival of a stochastic request was exploited by Banerjee and Freund [67]. The authors in ref. [68] used BPP to address the problem of minimization of the distance of client's location from the requested item location. The electric cars used are in multi-depots.

Cloud computing
In cloud computing, the problem of energy efficiency and cost of operation can be effectively managed if the number of servers used for a given task is minimized. This approach greatly fits into BPP, hence, several studies have been published in this regard. The placements of the virtual machines were considered to be the bins in ref. [69]. A heuristic method was proposed to solve a smaller version of the problem, with the primary goal of minimizing the problem objective function. A BPP model that implements the reversed auction in cloud computing was proposed by Ye et al. [70]. In the same vein, Srirama et al. [71] proposed a dynamic BPP strategy with auto scaling. In order to solve the complications of scheduling and autoscaling caused by container layer, Wang et al. [72] proposed an elastic scheduling for microservices (ESMS), which minimizes the cost of the virtual machines without compromising autoscaling.

Concluding remark and future direction
This study has reviewed current nature-inspired, population-based metaheuristics that have been used to solve the classical 1D BPP. These algorithms were either adaptations or modifications of other metaheuristics. The mechanisms discussed show how simple it is to discretize a solution space to adapt algorithms that were created for continuous optimization problems to algorithms that solve discrete optimization problems. Furthermore, the researchers of these reviewed papers focused on improving the stability of the exploration and exploitation phases of the metaheuristics, which greatly impacts the final solution quality and improved on the weaknesses of the original metaheuristics while leveraging the strengths. As can be seen, some algorithms are being tailored towards simplicity of implementation, such as the ACS and ILWOA, while others focus on decreasing computational expense. The former approach usually results in optimal solutions at the expense of time and resources, while the latter approach generally produces near-optimal solutions but takes far less time to compute a result.
In general, metaheuristics are widely used optimization tools for finding near-optimal solutions to large graph sized problem instances of the BPP in reasonable execution times. Moreover, the metaheuristic optimization algorithms are often simple to implement and flexible in terms of their adaptability in solving the 1D BPP in practice. In addition to these benefits, this class of optimization algorithms continue to be promising tools for numerous NP-Hard optimization problems where the exact solution methods tend to fail because of the exponential search spaces. However, some disadvantages of the metaheuristic algorithms include the issue of premature convergence, which can lead the algorithms into getting trapped in local optimum, and the aspect of parameter fine-tuning, as some of the algorithms would require having to set the control parameter to meet certain specified threshold.
For future research, it would be interesting to review hybridized versions of nature-inspired metaheuristic algorithms that have been used to solve the 1D BPP and other variants which involve additional constraints. Furthermore, it will be worth exploring the specific real-world applications of the metaheuristic algorithms for solving the BPP and the impact of these implementations. More so, a comparative performance analysis study of the state-of-the-art implementation of different nature-inspired metaheuristic algorithms can be considered so as to identify the best possible methods for handling the different variants of the BPP. Finally, it would be interesting to further conduct an extensive comparative analysis study to determine the success of the new generation metaheuristic algorithms presented in ref. [73] on the 1D BPP.