WorksMathematics
New Heuristics for Large-Scale Joint Order Selection, Allocation, Batching, and Picking
Abstract
Manual order picking in warehouses plays an important role in modern e-commerce fulfillment. In this work, we consider a warehouse fulfillment model recently introduced by researchers at Zalando, a leading fashion e-commerce company. It simultaneously models the hierarchy of decision stages in a very large-scale setting with a semi-online order set, where only a certain number of items have to be fulfilled in each time interval. For their base model, we present both new and improved algorithms together with comprehensive performance evaluation. We further extend the model to a setting with multiple phases, which more closely represents the situation observed in real warehouses, and adapt the algorithms to this setting, including new variants that incorporate multi-phase specific features. We demonstrate that this extension allows us to model, control, and optimize for certain parameters such as order age which play an important role in managerial considerations with the growing importance of next or even same day delivery.
Introduction
In the age of ever-growing e-commerce, manual order picking in large-scale warehouses still plays an important part in the fulfillment supply chain. While semi- or fully-automated warehouses are seeing increasing use, manual order picking is still seen in a majority of warehouses [7]. In a typical setting, items are distributed on shelves throughout the warehouse and pickers collect them individually. The cost of order picking is often cited to make up more than 50% of the total cost of the warehouse operation. Pickers, on average, spend around half of their time traveling between their assigned items to pick or the drop-off stations [36]. This implies that there are major cost-saving opportunities just through optimization of this part of the supply chain. In this work we focus on a setting recently introduced by researchers working at Zalando, one of the largest e-commerce fashion retailers in Europe [3]. Their setting combines a multi-layered decision process with a very large-scale setting, with tens of thousands of pending orders at any given point in time.
Warehouse Order Picking
A multitude of variants of order picking problems in real warehouses exist and an even larger amount of settings has been studied from a theoretical perspective. Several recent surveys provide a comprehensive overview over the current state of the art [7, 22, 28, 12, 4]. While some publications discuss the optimization of the warehouse layout itself, most works consider a fixed layout which has been determined during the warehouse’s initial design phase. Commonly studied layouts are rectangular shelf arrangements with one or more cross-aisles, fishbone configurations and V-shaped rack configurations [32, 11 ZLF+19, 5]. Items are spread across the shelves throughout the warehouse. Unlike in settings such as spare parts management for big industrial machines, in e-commerce often many items of a specific article (SKU) are stocked inside of the warehouse. It has been shown to be beneficial to spread these items throughout the warehouse instead of keeping all at the same location, as this enables routing synergies when collecting items [25], so modern warehouses typically support such storage policies. This strategy is called scattered or explosive storage.
In our setting, we focus on a pure picker-to-parts model, where humans, possibly with the help of some form of cart, walk throughout the warehouse and collect the items. Some other variants have been studied where the pickers are assisted by technological tools such as automated guided vehicles which deliver picked orders to the depots or rideable “cobots” which enable pickers to travel across large distances more quickly [21, 35]. The pending demand is usually specified by a list of orders, each of which consists of one or several articles contained in the warehouse. While some low throughput systems exist where each order is individually collected by a single picker, in larger warehouses with high order volume the task is typically spread amongst several pickers who each pick articles belonging to different orders. For each picker, an efficient route from the depots through the warehouse has to be calculated. The picked items are then combined into the respective orders in a later step of the logistics process, which we do not consider here. This setting and closely similar ones have been studied by many authors. Focusing on the picklist route step, results in [31, 29, 8, 26] have shown polynomial time solvability of this subproblem for certain restricted warehouse layouts. Settings which combine batching/assignment and routing have been studied in works such as [6, 2, 34] and are usually computationally hard.
A novelty in the model of [3], which we base our work on, is the introduction of an item goal, such that not all orders have to be fulfilled, but rather a subset of orders containing a set number of items has to be picked. This enables additional synergies to be exploited, as not all orders have to be picked in the considered step, so orders with complementing article placement can be preferred, while the remaining orders can benefit from new orders arriving later.
Large-Scale Warehouses
The model considered in [3] and here focuses on a very large-scale setting as faced by the largest players in modern e-commerce. Zalando itself has more than 1.8 million different products available [24] and thus the considered scales vastly exceed most of the order picking literature. While not every one of Zalando’s warehouses contains all of the products, we model several hundred thousand distinct articles with a million total items contained in our instances spread across 100 zones with 100 × 100 locations each. For our largest instances, around 50,000 orders are considered at any time, of which 10,000 need to be batched. Most previous works consider a few hundred orders at most, with single zone warehouses and a small number of pickers and articles. A review of recent relevant articles shows typical order counts of a few hundred up to a thousand, with at most a few thousand item positions in the warehouse. In [30], the authors consider a setting with around 10,000 item locations and at most 700 orders. For leaf layout warehouses, [23] review common picker routing algorithms and evaluate their performance for a single zone and up to 1,000 orders. Further numerical evaluations with between 600 and 7,200 item locations and up to 100 and 200 orders can be found in [20, 13, 9, 2, 1].
Semi-Online Time Scales
The aim of the item goal in this model is to represent a real-time semi-online setting, where in some discrete steps of time, usually between 5 and 60 minutes, the current state of the pending orders is considered and then an order batch and subsequent picklist assignment is created. Compared to a fully online setting, this establishes a precomputed schedule for the respective time period, which can increase reliability. Due to this, the overall algorithm has to run fairly quickly, with target times of a few minutes at most. Due to the increased offering of services such as same day shipping and express delivery [15, 10], it becomes increasingly important to dynamically update the order set considered by the algorithm timely, as otherwise the targeted quick delivery times could not be achieved and possible synergies when picking the orders would be missed. Most relevant literature in order picking views the problem in a more classical static setting with a fixed set of orders and a fixed warehouse inventory, searching for an optimal or close to optimal solution to the respective problem configuration. Such approaches generally do not achieve the restrictive target times for such a dynamic setting and faster but more inaccurate heuristics have to be employed.
Hierarchy of Subproblems
As mentioned above, there exists a plethora of specialized problems in warehouse optimization and all of them interact in some way or another with whichever optimization objective is being chosen. Thus, many (especially more recent) publications in the field focus on integrating several of these problems into a single optimization problem to achieve the best outcome. Studying these problems in isolated settings often reveals that they are already hard from the perspective of complexity theory and their combination reaches limits of feasibility in the real-world applicability of the solutions very quickly, especially considering the size of real-world instances and the necessity of providing solutions reasonably quickly. For extensive discussions on both the individual levels, as well as various integrations of them, we refer to recent surveys on this field [27, 22, 12]. In the following, we present the relevant hierarchical stages of the problem we discuss in this work. These are the stages we attempt to solve simultaneously as a single integrated problem.
Order selection Typically, the full set of orders available to the problem is expected to be completed at once, and the optimization procedure attempts to find an optimal solution to do so. In the model considered in this paper, we allow this requirement to be relaxed to some degree: from the current set of orders, we only attempt to complete a certain number (given by what we call the item goal) of them, while the remainder is postponed to a later time period. The idea behind this new approach compared to the existing literature is that new orders coming in during a later stage could provide opportunity for better synergies with the set of remaining orders.
The time period modeled in this step represents between tens of minutes to a few hours of real-world time, after which a significant amount of new orders have already been placed within the scale of the application we model here. This additionally addresses the situation that customers are able to place orders at any time, while warehouses often have limited working hours. The model can address these imbalances in the size of the full set of orders while maintaining consistent warehouse throughput.
Order batching The discretization we choose in the previous step works on a larger scale than what is required for the operational scale in the warehouse. On smaller time intervals, we need to provide the subsequent stages of the order fulfillment process with all articles required to complete a certain set of orders. Clearly, some maximum throughput capacity sets the limit to how many orders should be fetched simultaneously. We control this selection process by grouping orders into batches. All respective items of the selected orders in a single batch are then retrieved from the warehouse in parallel by multiple pickers across multiple warehouse zones and then forwarded to the next stage before continuing with the next batch of orders. This approach not only allows a single picker to be assigned items for multiple orders to be retrieved within a single tour (according to the capacity of their cart), but also a single order can be spread across different pickers to improve the efficiency of the process.
Item allocation With the introduction of mixed-shelves storage and the explosive storage policy, where identical items of the same article do not have to be stored at a single warehouse location, another decision has to be considered in the optimization process: which specific item will be picked to fulfill the article request of a given order. While this additional step introduces significant amounts of computational complexity into the problem, the synergistic opportunity of this decision during the routing step is similarly significant.
Picker routing Finally, with the set of orders selected, partitioned into batches, and their respective articles being assigned a specific item in the warehouse, the pickers are sent out to retrieve these items from the warehouse. We consider a model where the warehouse is split into separate zones to which the pickers are restricted for a single picklist. Within a batch, the solution consists of a set of picklists, describing for every picker in which order the items should be fetched from the warehouse such that the total travel distance is minimized. Again, we emphasize that while this last optimization step is in itself a mathematically intricate optimization problem, its optimal solution is highly affected by all the choices higher up in the hierarchy presented here, and therefore an integrated approach is favorable.
Contributions
In their article, [3] introduced a new setting for order picking in warehouses, inspired by their knowledge about the warehouse operations of Zalando. In this work, we build upon their model and algorithms and thus provide the next step in exploring both algorithms for and limitations of the model. To make the model more representative of real world constraints and the analysis less susceptible to local optima, we extend it to a multi-phase setting and analyze all algorithms in this new setting. The analysis shows that our algorithms both run in reasonable time while also providing good heuristic cost results. Additionally, some variants also achieve strong performance with regards to some secondary managerial objectives like fulfillment guarantees and delay prevention. The main contributions of this paper are summarized as follows:
We present an improved and computationally efficient implementation of a reference algorithm for the joint order selection, allocation, batching, and picking problem.
Several new algorithmic variants for this problem with attractive runtime behavior maintain good solution quality in computational experiments.
We conduct empirical analysis of these algorithms on synthetic data and discuss structural properties of the solutions.
An extension of the model to a multi-phase setting allows for more accurate analysis of the algorithms’ performances.
We introduce several novel age-dependent algorithms to address shortcomings of the established algorithms over multiple phases, especially with regard to order starvation and fulfillment guarantees which are important from a managerial perspective.
Through a broad empirical analysis of the algorithms on the multi-phase model, we confirm the desired long-term behavior.
Our implementation of the models and algorithms can be found at https://github.com/puenka/multiphase-batching-heuristics.
Problem Definition
Our paper is based on the problem and model presented by researchers from Zalando in [3], which we paraphrase in this section and extend later. Let us first discuss the underlying logistics of the problem on a less mathematical level from the bottom to the top of the hierarchy. An instance of this problem will be called a phase in the multi-phase model introduced later in § 2.2.
The warehouse considered in the problem is split into independent zones, in which the picking part of the problem is located. Each zone is a physical warehouse section with locations indicated by racks and aisles. At each of these locations, individual items are located and these locations are therefore identified by the zone, rack, and aisle number. The picker can navigate along aisles and change between different aisles at three orthogonal cross-aisles at the center and at both ends of each aisle. Each route for the picker starts at a depot located in the center of the zone and they have to return to this depot at the end of the route. Also, the routes cannot span across different zones, so after the item selection the routing problem is limited to a single zone. For simplicity, we typically assume a symmetric warehouse setup. See Figure 1 for an illustration of a warehouse zone with several items being picked up in a route.
Figure 1. An exemplary warehouse setup, indicating a route that picks up several items and an item with its location indices (the corresponding row is highlighted by a dashed line).
The next level in the hierarchy is the item selection: For each article (note the differentiation between article and item) that has to be picked up by the picker to complete an order, one of possibly several identical items at different locations in the warehouse has to be chosen. Additionally, each article has an associated volume, which reflects the portion it takes up in the bounded capacity of a single picker as a single numerical value.
The main objective is for a given list of orders to be completed. Each order consists of a list of articles and orders are not allowed to be fulfilled only partially. The order selection part of the problem consists of selecting a given number of orders in each batch. The maximum number of orders in each batch reflects the capacity of the warehouse and the processing capacity after the item collection in the logistics chain for a given time frame.
Furthermore, a novelty in [3] was the introduction of an item goal. Instead of requiring all orders in the problem to be completed, like it is observed in most other picker routing problems, we focus on simply achieving a set number of items in each phase of the problem, while keeping a backlog of orders to be fulfilled in a later phase. This potentially enables additional optimization potential, as we can select a subset of orders to be completed that synergize well with each other and hope for new orders to come in during later phases, that now complement the remaining orders better.
Mathematical Model
We briefly review the most important parameters of the model here, as some of them are used in construction and specification of the algorithms, for full details regarding all parameters and the associated constraints and goals see Appendix § 7.§ 1. For ease of notation we use the term set to refer to multisets.
During execution of any of the algorithms in this work, the state of the warehouse is captured by several variables. Denote by the set of articles and by the set of items in the warehouse. Recall that articles correspond to stock keeping units, while items correspond to the actual physical objects located in the warehouse. The volume of article is given by . Each item can fulfill its corresponding article and is located at a location triple corresponding to zone, rack, and aisle number. During execution of the algorithms, the set of unfulfilled orders is given by , where each order consists of a set of articles. Each of the pickers in the model has a capacity , which captures how much volume they can transport at once.
Model Extension to Multiple Phases
The multi-phase model is a direct extension of the single-phase model to a larger timeframe. It can be seen as a sequence of single phases, with restocking periods in-between. This is meant to model the continuous process of restocking and order fulfillment periods more closely, instead of only considering a single isolated phase.
After each phase, the warehouse is restocked with articles and the list of remaining orders is refilled. Both steps are done in a way to ensure that the number of items in the warehouse remains constant throughout the whole model run. Additionally, through appropriate design of the newly added orders, it is ensured that every order is theoretically fulfillable at any given point in time, so there are never orders which contain articles not contained in the warehouse.
Note that iterative application of any algorithm for the single-phase model gives solutions for multiple phases as well. We investigate the structure of these solutions and address their issues in § 5.4.
Complexity and Polynomial Solvability
In this section, we briefly review the state of the art regarding complexity results and solvability of picking problems. We additionally discuss further sub-problems related to the multi-zone setting and to picker capacities. Such analysis is important to understand which approaches and algorithms are reasonable for the given settings of order picking.
General Order Picking Complexity
The complexity of general order picking problems is well studied, with most problems shown to be NP-hard, unless heavily restricted. This is due to order picking being interpretable as a combination of several classical well-known hard problems, such as Traveling Salesperson (TSP), Steiner-tree, and Bin-packing [19].
The setting of so called wave-picking, where orders are released in large batches and the next batch can only be started when the previous one is completed, was studied in [18], with NP-hardness established there. For an order batching subproblem used to reduce picker traveling times, [17] show hardness if some batches contain more than two items. In their work, [33] show that a version they call Generalized Order Picking Problem is NP-hard, even if all picklists are restricted to be of length one and the warehouse has a simple structure with a single zone and only two cross-aisles. Focusing mainly on the TSP aspect of order picking, in their survey [4] present a wide variety of hardness proofs and some polynomial algorithms for many variants of the problem.
Efficiently Solvable Instances
In contrast to the NP-hardness of general order picking problems, many restricted variants or subproblems are known to be solvable in polynomial time. By assuming certain parameters such as the number of aisles and rows to be of a fixed size, parametrized polynomial time algorithms are also known.
Order picking in a rectangular warehouse with only two cross-aisles at the two ends of the aisles was shown to be solvable in linear time in the number of aisles by [31]. Recently, the runtime for these two cases was improved in [14]. This setting was extended by [29] with the introduction of additional cross-aisles in the inner part of the warehouse at the cost of a much higher runtime. For an arbitrary fixed number of cross-aisles, [8] introduced a polynomial time algorithm with an exponential dependency on . Additional analysis and further details can be found in [26]. A more general framework which encompasses these types of settings together with some optimizations which slightly improve the runtime can be found in [33].
NP-Hardness of Order Selection
The complexity and solvability of the picker routing problem is well studied, as demonstrated in the previous two sections. In our setting, with multiple disjoint independent zones and articles of which copies can be spread throughout these zones, additional complexities arise. As each order consists of several articles, each of which might have several corresponding warehouse items, we have to decide which of them to pick to fulfill the order.
For a given set of orders, assigning articles to orders to fulfill all demands without assigning an article twice is a bipartite matching problem, which is well known to be solvable in polynomial time. However, if we also want to optimize certain cost parameters at the same time, the problem becomes much harder. We call a selection of articles satisfying for a set of orders if all item demands from these orders are fulfilled by the set. We claim that deciding whether a satisfying set of articles which can be picked for a certain cost exists is NP-hard to decide, even when the warehouse structure is very simple and optimal picking routes are known. The same hardness extends to deciding whether a satisfying set exists which only uses a certain number of zones. There are multiple ways to show this, which can be used to establish the hardness even for more restricted instances.
Even in the case where there is only one unique article corresponding to each item in the warehouse, certain subproblems remain difficult. In this setting, for each set of orders there is a unique set of satisfying articles. Even if these items were all situated in the same zone at the same place, due to their volumes and the maximum capacity of each picker, it would be hard to decide whether there is a way to pick the items using two pickers or whether at least three are required. This follows as a direct consequence of the hardness of the classic Bin-packing problem.
Single Phase Setting
In this section we introduce and evaluate several algorithms for the single-phase setting. We focus on high level descriptions and refer to the implementation for finer details. The Distance Greedy Algorithm (DGA) and the base version of the Randomized Distance Greedy Algorithm (RDGA) serve as reference algorithms and are only slightly adapted from [3]. We present additional variants and improved versions of these algorithms. The remaining algorithms are novel and use a variety of approaches. We first introduce all algorithms and then give a complete analysis and comparison of their performance in § 4.2.1. In § 4.3 we examine and compare the performance impact of certain subroutine choices, such as the optimization of the picklist routes by better solvers.
Distance Greedy Algorithm
The Distance Greedy Algorithm (DGA) is logically identical to the one in [3]. For this algorithm, the item batches are created sequentially and during the creation of each batch, one order after another is picked, until the maximum size of the batch is reached. The respective next order is picked based on a distance function which estimates the cost to pick each order based on the previously selected orders and thus prioritizes orders whose items are close to already selected items or close to the depots. The picklist creation is done at the end through a simple greedy procedure. In § 4.3, we empirically compare this greedy procedure to an improved solution computed by modeling this subproblem as a constrained vehicle routing problem (CVRP) using a solver from the external library OR-Tools [16].
As noted by the authors in [3] and provided in their codebase, in a naive implementation, this algorithm runs too slowly on larger instances, with runtimes reaching several hours. Through various design and implementation improvements (all within a pure Python implementation to maintain comparability to the reference), we have achieved a version of this algorithm with equivalent computational output, but vastly improved runtime performance, being fast enough to be employed in a setting where results within minutes are required. The most important change is keeping track of already computed distance estimates within a heap data structure and updating them only when necessary. After selecting the next order and its associated items, using several structural insights into efficient picker tours, the algorithm analyzes which items and thus orders could potentially have their cost estimates affected by the order choice, which leads to much fewer required updates and a resulting significantly faster runtime. For easier disambiguation and comparison we call our improved version fast DGA (FDGA).
We also introduce a variant of this algorithm based on a simplification of the subroutine which selects the next order. To estimate the marginal cost of an order, each article is iteratively assigned the currently best fitting item. While DGA and FDGA then compare the addition of subsequent items also to the already picked items for the order under investigation, the variant FDGA-Skip (which we adapt from the improved implementation FDGA) omits this part of the computation and only estimates the cost by comparison to all items of previously selected orders.
Randomized Distance Greedy Algorithm
The base version of the Randomized Distance Greedy Algorithm (RDGA) from [3] is a severe simplification of the DGA. Instead of using the cost estimate to select the next order, a random unfulfilled order is picked. Then, items are selected that fulfill this order which heuristically minimize the marginal increase of the picklist cost with regard to the already selected orders.
We build upon this idea of randomization by introducing a sampling-based variant called RDGA-. Our goal is to achieve a trade-off between the improved runtime obtained by considering only a subset of the remaining orders and the increased resulting total cost through lost synergy potential. Instead of picking a single order like RDGA, our new variant RDGA- uniformly samples of the remaining orders and then selects the one minimizing the expected cost. We also allow to be a function depending on the state of the warehouse, such as the number of remaining orders, or more specifically, their square root, called RDGA-.
Local Distance Greedy Algorithm
Our new algorithm called Local Distance Greedy Algorithm (LocalDGA) attempts to refine the sampling approach of the RDGA. In this algorithm, we aim to preserve the improved runtime obtained by omitting the evaluation of a large number of potential orders, while reducing the loss in optimality incurred through the random choices. Instead of resampling the entire space of orders as is done in the RDGA, a set of candidate orders is maintained, from which the next order is selected. After each selection, new candidate orders are identified, and the set of candidate orders is re-sampled from the combined old and new orders. New candidate orders are picked based on custom distance functions based on the newly considered articles belonging to the added order.
In our testing implementation, we considered a base set of 100 candidate orders, with 10 new candidate orders being considered in each step. In each step, from these candidate orders, the one closest to already picked items is selected. Then 10 new orders are identified whose items are in the same aisle as previously picked items. This aims to achieve synergies, as some of these items might lie on existing routes already and if not, extending these routes to such items is cheap on average.
Computational Evaluation - Single Phase
Before we present the performance evaluation data, we give a brief overview of the instance parameters and instance generation, for additional details we refer to Appendix § 8. We provide additional data for other instances in Appendix § 9.
Each instance is created in a way that ensures that all orders can always be fulfilled. Order sizes and article volumes are sampled from appropriate probability distributions and each order consists of randomly chosen articles. The number of items in the warehouse is roughly three times as large as the number of articles and each item is assigned a uniformly random location in the warehouse. We present data for two different instance sizes called medium and large with parameters outlined in Table 1. These instance parameters were also taken from [3] and later generalized for our multi-phase approach. For each instance class, the item goal is set to be approximately 20% of the total number of articles on order.
| Parameter | medium | large |
| Warehouse items | 100,000 | 1,000,000 |
| Orders | 5,000 | 50,000 |
| Zones | 50 | 100 |
| Rows | 100 | 100 |
| Aisles | 100 | 100 |
Table 1. Parameters for the different instance categories.
We introduce the following variations on some parameters of the instance descriptions: by “-fewzones” and “-fewerzones”, we denote the instance that uses only 10 and 3 zones, respectively. Another variant is the “-longbatch” instance, in which 250 orders may be scheduled per batch, as compared to the 50 orders in the standard instances.
Analysis of the computational results
In this section we computationally evaluate all algorithms outlined above and analyze their advantages and disadvantages. For RDGA-, we choose two variants: and . Each algorithm was applied to the same set of five randomly generated instances of medium and large size. The numerical data indicates the average value of the respective observation over all runs of the same instance size. As the variance between runs on the same instance and over the different instances of the same size is low, no further statistical parameters other than the mean value are presented.
In Table 2, the results for the primary objectives in our single-phase analysis are displayed: the total cost of the picklists and the runtime of their computation. Note that the cost of DGA and FDGA is not only equal on average, but their output is exactly the same, and we therefore only provide data for FDGA outside of runtime discussions. Our first contribution is the vastly improved runtime, which is about 18 times faster for FDGA compared to DGA in large instances, thereby making this approach significantly more feasible in terms of real-world applicability. We observe that our first variant FDGA-Skip is able to reduce the runtime by a further 8–10% with a total reduction of a factor of 19.5 compared to DGA, while maintaining solution quality that is comparable to the reference algorithm (within ±0.3% of the objective for large instances).
| Algorithm | Cost | Relative Performance | Time | Cost | Relative Performance | Time |
| DGA | 62354.4 | +0.2% | 108.9s | 524925.2 | +0.0% | 10548.6s |
| FDGA | 62354.4 | +0.2% | 8.7s | 524925.2 | (reference) | 591.8s |
| FDGA-Skip | 62203.2 | (reference) | 7.9s | 526366.8 | +0.3% | 545.5s |
| LocalDGA | 70684.4 | +13.6% | 5.7s | 597082.8 | +13.7% | 113.8s |
| RDGA- | 76453.2 | +22.9% | 1.8s | 734645.2 | +40.0% | 59.1s |
| RDGA-50 | 77449.2 | +24.5% | 1.4s | 843182.0 | +60.6% | 22.5s |
| RDGA | 139287.2 | +123.9% | 0.2s | 1489700.8 | +183.8% | 9.8s |
Table 2. Benchmark data of selected algorithms. The columns are grouped into medium and large.
The RDGA variants implement a sampling approach to trade some of the cost performance in favor of even faster runtime, which we observe in this data: While the increase in cost compared to the reference is not insignificant, the computation time is another order of magnitude faster than FDGA. The LocalDGA algorithm offers a compromise between the two approaches, with increased runtime compared to RDGA due to the overhead incurred for maintaining candidate orders, but at the same time achieving cost closer to FDGA (+14%) than the independent sampling All values are averaged over five different instances and rounded to the nearest tenth.
All values are averaged over five different instances and represent the mean value over all batched items, picklists, and orders respectively. The reference values refer to all orders/items in the instance as compared to the ones picked by the algorithm.
approaches.
Further Solution Insights
In this section we analyze additional solution properties. The goal is to gain insight into the solution structure and we perform additional experiments to evaluate different properties of the optimization procedure.
Table 3 outlines some observations for the previously discussed algorithms. The picklist length is the average length over all picklists created in the last step of each algorithm. The order size is the average number of items contained in the selected orders, and the item distance from the conveyor is the average distance each of the picked items has to the conveyor. The instance reference value for the average item distance from the conveyor belt refers to the resulting distances when all available orders are fulfilled. This reference has been computed by selecting the closest of the available items of each article to fulfill each order. Because we do not use actual route lengths for this estimate, the specific item selection does not affect this metric.
| Algorithm | Item distance from conveyor | Order size | Picklist length | Item distance from conveyor | Order size | Picklist length |
| FDGA | 23.2 | 2.3 | 3.3 | 22.8 | 2.2 | 2.6 |
| FDGA-Skip | 23.3 | 2.3 | 3.3 | 22.8 | 2.2 | 2.6 |
| LocalDGA | 23.3 | 2.3 | 3.3 | 23.2 | 2.3 | 2.5 |
| RDGA- | 22.1 | 2.4 | 3.0 | 21.5 | 2.4 | 2.1 |
| RDGA-50 | 22.0 | 2.4 | 2.9 | 21.1 | 2.4 | 2.0 |
| RDGA | 33.5 | 2.7 | 3.0 | 32.8 | 2.6 | 1.9 |
| (Instance) | 34.03 | 2.65 | − | 34.03 | 2.64 | − |
Table 3. Further computational measures for different algorithms. The columns are grouped into medium and large.
We observe that the average distance to the conveyor of items picked by the algorithms is significantly lower than the average over all items (with the exception of the crude random item choice in RDGA). While some of this difference is to be expected due to the algorithm usually selecting the item corresponding to an article which is closest to the conveyor, the observed effect is actually stronger than this. It turns out that the algorithms strongly prefer orders whose items are close to the conveyor, which when considering the multi-phase setting leads to a kind of gradual emptying of the center of each zone and a simultaneous starvation of orders whose items are mostly in far positions. Additionally, the length of batched orders is less than the average, indicating that the algorithms favor batching smaller orders, as it might be easier to accommodate all items in an order if there are fewer of them. This behavior is obviously undesirable from a managerial perspective, as it could lead to unbalanced warehouse utilization and delayed order fulfillment. We capture and address these observations in our extension to multiple phases discussed in § 5.
Picklist Length and Routing Another observation is that the number of items picked in each picklist is quite small, even for the reference algorithm, with on average fewer than 4 items picked for each picker route. This is due to the restrictive batch size (50 orders) and small average order size in comparison to the number of zones (50 for medium, 100 for large instances) in the problem.
To elaborate on this observation and eliminate this undesirable effect, we have performed additional computations on varied parameters as outlined above and provide some performance-related data in Table 4. The performance evaluation confirms the qualitative ranking of the different algorithms outlined above. Additionally, we observe a more realistic outcome with longer picklists and higher load on the pickers’ capacity constraints: for the -fewzones variants, the picklists contain 10–13 items on average with a median picker load of ca. 30–40%, and for the -fewerzones variants, the picklists contain 17.5–20 items per picklist with median load exceeding 80%.
| Algorithm | medium-fewzones Cost | medium-fewzones Relative Performance | medium-fewzones Time | medium-fewerzones Cost | medium-fewerzones Relative Performance | medium-fewerzones Time |
| DGA | 41446.4 | +0.0% | 185.5s | 29281.6 | +2.7% | 395.1s |
| FDGA | 41446.4 | (reference) | 30.4s | 29281.6 | +2.7% | 74.7s |
| FDGA-Skip | 41682.4 | +0.6% | 27.7s | 28498.4 | (reference) | 67.7s |
| LocalDGA | 43815.6 | +5.7% | 9.1s | 33404.4 | +17.2% | 21.1s |
| RDGA-50 | 53383.2 | +28.8% | 2.3s | 38494.0 | +35.1% | 4.7s |
| RDGA- | 51320.4 | +23.8% | 2.9s | 36911.6 | +29.5% | 6.1s |
| RDGA | 102917.6 | +148.3% | 0.2s | 83658.4 | +193.6% | 0.3s |
Table 4. Benchmark data of selected algorithms for medium instances with few and fewer zones. All values are averaged over five different instances and rounded to the nearest tenth.
While [3] have only used a heuristic for the computation of the picklists after the item selection has concluded, we have additionally experimented with improving solutions for this subproblem using a specialized library [16] for constrained vehicle routing problems (CVRP) for the optimization separately on every zone. For this solver, we have used the default parameters with a time limit of 10s for each zone.
Even though the basic routing heuristic performs sufficiently well in the reference instances due to the small number of items in each picklist and only provides marginal improvements in the objective value (Table 5), we observe a different outcome with substantially improved performance in our problem variant with longer picklists. For later results, we therefore restrict our analysis to routing using the external library instead.
| Algorithm | medium: Greedy | medium: CVRP | medium: Rel. Performance | medium-fewerzones: Greedy | medium-fewerzones: CVRP | medium-fewerzones: Rel. Performance |
| FDGA | 62354.4 | 61526.4 | -1.3% | 29281.6 | 26103.2 | -10.9% |
| FDGA–Skip | 62203.2 | 61215.6 | -1.6% | 28498.4 | 25474.0 | -10.6% |
| LocalDGA | 70684.4 | 68294.4 | -3.4% | 33404.4 | 29532.8 | -11.6% |
| RDGA– | 76453.2 | 75569.2 | -1.2% | 36911.6 | 34086.0 | -7.7% |
| RDGA–50 | 77449.2 | 77311.6 | -0.2% | 38494.0 | 35381.2 | -8.1% |
| RDGA | 139287.2 | 135510.8 | -2.7% | 83658.4 | 64500.4 | -22.9% |
Table 5. Comparing the heuristic routing subroutine with the improved CVRP-based solution for medium and medium-fewerzones instances.
All values are averaged over five different instances and rounded to a tenth.
Multi Phase Setting
In this section we discuss and analyze the extension of the model to multiple phases, as defined in § 2.2. This extension is motivated by the need to more accurately account for settings observed in real-life warehouses and to thus reduce weaknesses of the single-phase model.
Motivation
Each picking phase in the original single-phase model is supposed to represent a rather short timeframe during a typical workday at a warehouse. Depending on the exact circumstances, the represented timeframe might range from a few minutes up to around an hour. So a typical workday will consist of many such phases, with restockings of the warehouse throughout. While restocking might actually be performed in parallel to order picking in some warehouses, we slightly simplify the model and assume instantaneous restocking in-between picking phases. Due to the rather short length of these phases, this does not have a large impact.
Considering multiple consecutive phases has the advantage of both capturing possible synergies between picking decisions over multiple phases while also eliminating a biased advantage which single-phase algorithms can obtain by making short-term decisions. Some such advantages were already observed in § 4.3, as many of the algorithms overly prioritize orders which can be fulfilled by items close to the conveyor belt or which only consist of few articles. We show that over a longer timeframe, such decisions lead to worse overall outcomes, as later phases are then much harder to fulfill cost efficiently. The multi-phase setting is also beneficial from a managerial perspective, as other performance indicators such as fulfillment guarantees and order starvation prevention can be tracked, analyzed, and optimized for.
As a motivating example, we would like to present a glimpse of the data outlined in § 5.4: After the naive application of FDGA to 100 consecutive phases on medium instances, we end up with an order set, where the size of an order yet to be fulfilled is 3.6 articles on average (compared to 2.64 articles of average order size in the ground set) and the average age of an order (in terms of number of phases since it has been added to the problem) is 15.72 phases. The oldest order that has not been fulfilled yet is from the initial phase, i.e. it has been added 100 phases prior. Under this light, the competitive performance of FDGA must be critically evaluated, as it can be conjectured that it achieves smaller cost only at the trade-off of leaving generally unsynergetic orders unfulfilled.
In the following, we present algorithms which not only eliminate this potential drawback, but in some cases even outperform the benchmark FDGA algorithm in terms of the total cost. Furthermore, this is all achieved without increasing the runtime of FDGA.
Computational Evaluation - Multi Phase
Similar to the single-phase setting, we evaluate the different algorithms regarding their cost and runtime. In this case, we consider 100 consecutive phases. Each phase is treated by the algorithms as an independent instance of a single-phase picking problem. The only additional information that is communicated to the solvers is the age of every order currently in the warehouse, i.e. the number of phases that have passed since the order came in.
In order to computationally model the sequential setting, we devised a scheme to populate the warehouse with items and orders similar to the single-phase case. Initially, we start with some number of orders that vastly exceeds the number of orders to be completed when the item goal of a single phase is approximately fulfilled, and a warehouse stocked with some number of extra items that are currently not requested, just as in the single-phase setting. On a technical level, we generate orders and their according items as sequences. After the completion of each phase, we take the next chunk of items and corresponding orders that they can fulfill from the sequence and add them to the instance. The full sequences are unknown to the algorithm and new items and orders are only revealed during the restocking. In order to maintain a consistent warehouse size, we restock the exact number of items that was removed in the previous phase. These items also approximately correspond to the number of orders completed in the previous phase. Table 1 outlines the parameters used in this experiment, and they are directly applied to the initial phase of the multi-phase setting and thus generalize the instance categories medium and large to this setting. Within these parameters, approximately 20% of the available orders are fulfilled in every phase, i.e. around 1,000 orders for the medium instances and 10,000 for the large instances.
Multi-Phase Algorithms
While the single-phase setting did not have a notion of age for each order, this is a feature we consider crucial in our extension to the multi-phase setting. As outlined below, this is also reflected in our newly devised algorithms. Additionally, we compare the novel variations to the iterative and age-agnostic application of selected algorithms (FDGA, LocalDGA, and RDGA-) from the single-phase setting above, which compute independent instances for each new phase. As FDGA computes the same solutions as DGA, this selection thus provides a benchmark to the application of the algorithm from [3] while drastically improving the computation time.
FDGA with soft age objective
For this first approach of incorporating the age information of each order to achieve timely order fulfillment, we modify the cost function in the FDGA procedure to prioritize old orders over new ones to a certain degree. In order to do this, we discount the cost of older orders according to their age using two parameters and , where the former corresponds to geometric and the latter to linear discounts. The cost heuristic in FDGA which selects the next order now computes the cost for each order as before and modifies it to a new age-dependent cost of , where is the age of order given as an integer counting the number of phases. The order that minimizes is now returned. Thus, all orders of the same age are again compared to each other with the same discount factor. Depending on the given parameter choice of and , older orders are prioritized over new ones, while still maintaining the incentive for the algorithm to choose synergising orders.
In our experiments, we have found satisfactory performance without using any linear discounts (i.e. ) and refer to the algorithms by FDGA-Soft() for the corresponding geometric discount parameter . We use for our experiments, which corresponds to discounting the cost of each order for each phase by 20%, 10%, 5%, and 1% respectively.
FDGA with strict age objective
While the previous approach accomplishes the completion of old orders implicitly due to the modification of the costs, we have also devised a second approach that gives explicit hard guarantees by design of the algorithm. For a full description see Appendix A.2.
This variant of FDGA takes as input a list of non-increasing order numbers , where . We also call the bucket size of age or completion targets. Each indicates how many orders of age may be carried over to the next phase of the algorithm. Thus, no order can exceed age over the course of the algorithm. For appropriately chosen bucket sizes, the algorithm is guaranteed to hit the target age distributions. This is achieved by randomly sampling as many orders as necessary to fulfill the completion targets and then employing a modified version of FDGA to select both these mandatory orders as well as additional synergistic orders in an efficient way.
In our experiments, we use the following implementations of the bucket sizes. Note that both of them implicitly use (an estimate of) the number of newly added orders in each phase.
FDGA-Linear() implements a linear decline of bucket sizes from to 0 at age . The buckets are thus given by
FDGA-Cutoff() does not impose any restrictions on the orders up to age , but then requires all orders of that age to be completed. Thus we have and .
Multi-Phase Analysis
First, we start off by comparing the performance of the different algorithms in Table 6 for medium-fewzones instances, as we deem its solutions an adequate compromise between the number of zones to pose a sufficiently challenging problem and the resulting picklist lengths The parameter for the number of new orders is set to 1000 if applicable and approximately corresponds to the number of new orders in each phase. The column for relative cost compares to the reference of FDGA. The values are averaged over 5 instances and rounded to appropriate precision. The values for the second part of the table are computed for the set of orders in the last phase of each run. For reference, the average order length in the instance is 2.64.
| Algorithm | Total cost | Rel. cost | Avg. cost per item | Avg. cost per order | Average order length | Maximum order age | Average order age | Median order age |
| FDGA | 5609744 | (reference) | 21.51 | 55.97 | 3.6 | 100.0 | 15.72 | 4.2 |
| LocalDGA | 5566124 | −0.8% | 21.41 | 55.9 | 3.31 | 100.0 | 12.35 | 3.0 |
| RDGA− | 6620678 | +18.0% | 25.44 | 66.5 | 3.21 | 100.0 | 12.11 | 4.0 |
| FDGA−Cutoff(5) | 7023362 | +25.2% | 27.28 | 71.84 | 2.73 | 5.0 | 2.34 | 2.0 |
| FDGA−Cutoff(10) | 6652562 | +18.6% | 25.75 | 67.46 | 3.03 | 10.0 | 3.53 | 3.0 |
| FDGA−Cutoff(15) | 6352230 | +13.2% | 24.59 | 64.29 | 3.17 | 15.0 | 4.56 | 3.0 |
| FDGA−Cutoff(20) | 6188696 | +10.3% | 23.87 | 62.34 | 3.26 | 20.0 | 5.46 | 3.0 |
| FDGA−Cutoff(25) | 6067686 | +8.2% | 23.4 | 61.07 | 3.32 | 25.0 | 6.27 | 3.2 |
| FDGA−Cutoff(30) | 5991385 | +6.8% | 23.04 | 60.12 | 3.38 | 30.0 | 7.05 | 3.4 |
| FDGA−Linear(10) | 6750239 | +20.3% | 26.15 | 68.55 | 3.0 | 10.0 | 3.37 | 3.0 |
| FDGA−Linear(15) | 6423991 | +14.5% | 24.81 | 64.88 | 3.16 | 15.0 | 4.47 | 3.0 |
| FDGA−Linear(20) | 6226611 | +11.0% | 24.03 | 62.77 | 3.26 | 20.0 | 5.43 | 3.0 |
| FDGA−Linear(25) | 6113034 | +9.0% | 23.53 | 61.43 | 3.33 | 25.0 | 6.31 | 3.2 |
| FDGA−Linear(30) | 6018649 | +7.3% | 23.16 | 60.43 | 3.38 | 30.0 | 7.11 | 3.8 |
| FDGA−Soft(0.8) | 5539346 | −1.3% | 21.39 | 56.25 | 2.81 | 8.2 | 2.29 | 2.0 |
| FDGA−Soft(0.9) | 5315791 | −5.2% | 20.55 | 53.93 | 2.93 | 12.6 | 2.71 | 2.0 |
| FDGA−Soft(0.95) | 5299643 | −5.5% | 20.43 | 53.51 | 3.06 | 20.0 | 3.38 | 2.0 |
| FDGA−Soft(0.99) | 5469906 | −2.5% | 21.01 | 54.84 | 3.35 | 60.6 | 6.49 | 3.0 |
Table 6. Benchmark data comparing different multi-phase algorithms for medium-fewzones instances.
for practical applications, as discussed in § 4.2. We provide analogous data for different instance variants in Appendix § 10. All of the results reflect our qualitative observations outlined in this section, but the quantitative extent varies slightly between the specific instance settings.
Besides the total cost, we also present the relative cost of these algorithms compared to the single-phase reference FDGA. Additionally, the average cost per batched item and per batched order is given, in order to eliminate any irregularities from varying numbers of chosen items or orders due to the order selection in the computation.
For different parameter choices for the algorithms FDGA−Cutoff() and FDGA−Linear() variants we can clearly observe the decreased opportunities for synergy during the computation, when the completion targets are set more tightly. Nevertheless, we do observe only marginally increased cost for the trade-off with strict completion guarantees, specifically when compared to the application of the more runtime efficient single-phase algorithm RDGA−. On the contrary, we even observe decreased cost for most FDGA−Soft parameter choices compared to the benchmark FDGA.
Next, we compare the solutions more thoroughly than just with regards to the cost performance, as our original goal was in fact not to improve the performance over the benchmark, but rather to produce better solutions in terms of other properties. A crucial observation on the solution structure of the algorithms is illustrated in Figure 2. The application of the standard FDGA algorithm completes the majority of newly added orders when they are added to the problem, but the set of remaining orders is not necessarily completed in reasonable time. More specifically, we observe pronounced diagonal lines which barely change over time, which represent the orders added in a given phase that are apparently ignored throughout the rest of the
Figure 2. Age distribution data of single runs of FDGA, FDGA–Soft(0.9), and FDGA–Cutoff(10) on a medium-fewzones instance.
While many orders are completed right away, many of them remain in the problem until the end of the experiment.
phases and increase the size of the backlog, as the algorithm is not able to accommodate them according to its objectives. This behavior motivated the development of our novel algorithms which fix this issue by design.
In Figure 2, we also provide exemplary data for the completion ages of orders for FDGA–Soft and FDGA–Cutoff, where all orders are being completed within around 10 phases after being added to the problem. Comparing these two algorithms against each other, we can also confirm that they accomplish the design goals: While FDGA–Soft prioritizes older orders over newer ones and their number declines systematically as they age, the distribution of ages remains more consistent in FDGA–Cutoff until all the respective orders are mandatorily completed at the cutoff age.
The same qualitative behavior can be observed for other parameter choices in these algorithms and we discuss them numerically next. Further data for this experiment in the multi-phase setting is displayed in the later columns in Table 6. This data is computed from the set of orders within the last phase of the multi-phase model, again averaged over all 5 independent runs. As such, we believe that it is representative of the convergence behavior of the application of these algorithms over time (where we suggest that some of the discussed effects could be even more drastic for longer time periods).
With regards to the current state of the warehouse in terms of orders, we list the average number of positions in each order in the warehouse. This confirms a similar observation from the single-phase experiments, where some algorithms strongly prefer shorter orders over longer orders, most likely due to the fact that fewer items are more likely to fit in well with the already selected routes. This is reflected very well in the comparison across different parameters for our new algorithm variants, where for stronger completion target choices, the proportion of longer orders in the warehouse is closer to the instance average.
Another interesting observation is the distribution of ages of orders, where we continue to observe very regular behavior in the parameters for the different variants. We can empirically confirm that the completion targets for FDGA-Linear and FDGA-Cutoff work as intended, while we also get a rough estimate for the effective upper bound on the targets for FDGA-Soft from the data. Most notably, we want to emphasize that the problematic behavior of non-fulfilled orders from the initial phase is confirmed by our experiments. The average order age is well controlled only by our newly introduced variants, while the effect is observable, but less pronounced in the median order age.
Another observation that we do not present numerically is that all of the observed algorithms prefer to pick items closer to the center of the warehouse. Due to the design of the objective, this is also expected behavior and we did not observe any notable differences between the algorithms in this regard.
Conclusion
Our contribution builds upon the model and algorithms DGA and RDGA from [3], which we reproduce in § 2.1. For our own implementation of FDGA, we improve upon DGA by efficiently using both data structures and problem-specific properties to significantly reduce the runtime. By skipping the computation of a subroutine, we observe qualitatively comparable outcomes with even faster runtime in the algorithm FDGA-Skip. Furthermore, we introduce a variant called RDGA-, which allows the user to compromise between runtime and performance via a single parameter, while experimentally maintaining decent solution quality compared to the reference of DGA for reasonable fixed parameter choices or a dynamic and instance dependent approach with RDGA-. Additionally, we present novel algorithmic approaches aiming to provide different (and configurable) trade-offs between runtime and cost. Thorough experimental evaluation of all approaches is contained in § 4.
We further extend the model by [3] to a multi-phase setting, more closely resembling the reality observed in warehouse operations. We show that a naive extension of the single-phase algorithms to this setting returns solutions with undesirable characteristics, such as arbitrarily long order delays and unbalanced warehouse utilization. Our novel algorithms address these shortcomings and are presented and analyzed in § 5. We show that surprisingly simple modifications can lead to solutions with strong guarantees, while maintaining solution quality or even improving upon the reference.
For both the single phase as well as the multi-phase model we additionally analyze instance variants which represent denser demand profiles with higher picker utilization than the ones given in [3]. We show that our results extend to this setting and are generally robust against input variations.
A limitation in this work is the simplified restocking model employed in the multi-phase setting. In our model, the restocked items are placed uniformly at random throughout the warehouse and are drawn uniformly from the total pool of available items. In real world settings, additional data can provide estimates for both the items being re-stocked as well as the items being ordered, which is taken into account during warehouse design and when deciding where to place newly arrived items. Incorporating such decisions and procedures into the algorithms could lead to further overall improvements in terms of costs and fulfillment guarantees. In a similar vein, extensions of the analysis performed in this work to other warehouse settings and structures as discussed in § 1 are of interest. Finally, testing both the algorithms from this work as well as potential variants for other settings using real historic data from warehouse operations would be an important step towards real world deployment.
Additional Details
Mathematical Model
In this section we give a full, self-contained statement of the mathematical model underlying the instances.
Denote by the set of articles and by the set of warehouse items. Each article has a volume . Each can fulfill its corresponding article and is located at a triple corresponding to zone, rack, and aisle number. The set of orders is given by , where each order is given as a set of articles.
Each picklist consists of items within the same zone. For items in the same zone, we can define a distance function , which represents the length of the route in the warehouse model outlined above and we refer an interested reader to the implementation for an explicit definition. We assume the location of the depot in each zone to be at and alter the notation to define the distance from the depot as a function as the distance from the depot in the corresponding zone to the item. The length or cost of a picklist, which is the main objective we optimize on, is thus given as
A collection of several picklists is called a batch . We do not require the items of a single picklist to correspond to a precise set of orders, as a picklist is restricted to a single zone and the corresponding items might have to be picked up across different zones. A batch, on the other hand, should always be comprised of picklists that pick up only those items that fulfill a certain set of orders, and no order should be fulfilled only partially.
Additional parameters for the problem are the picker capacity , the item goal , and a bound on the size of each batch .
A feasible solution for the batching problem consists of a list of batches (where is not fixed) and fulfilled orders with the following properties. Denote the set of feasible solutions as . Remember that any sets are to be considered as multisets.
Every item is only picked at most once across all picklists:
The total item goal is fulfilled:
For each we require:
(a) The total volume of items in each picklist in the batch does not exceed :
(b) The batch size is respected: .
(c) The requested orders for each batch are precisely fulfilled, i.e. the number of times each article is ordered corresponds to the articles of all picklists in the batch:
The objective function to be minimized is the total length of picklists among all feasible solutions:
FDGA with Strict Age Objective
While the previous approach accomplishes the completion of old orders implicitly due to the modification of the costs, we have also devised a second approach that gives explicit hard guarantees by design of the algorithm.
This variant of FDGA takes as input a list of non-increasing order numbers , where . We also call the bucket size of age or completion targets. Each indicates how many orders of age may be carried over to the next phase of the algorithm. Thus, no order can exceed age over the course of the algorithm.
As an example, consider . The algorithm can carry over 1000 new orders, 500 orders of age 1 and 250 orders of age 2 to the next phase. Any order older than age 2 must be completed in the given phase.
Clearly, these completion targets may interfere with the item goal if not appropriately set. When the number of orders (of any given age) in a phase vastly exceeds the bucket size, all but some of the orders have to be completed in this phase and the corresponding number of items may have to exceed the item goal substantially. For a regular warehouse setting with an approximately constant number of incoming orders in each phase, it suffices to have . The number of orders of age to be fulfilled in any given phase is no larger than , and therefore the total number is no larger than . Thus, if the warehouse manages to handle the incoming order stream, we can also apply this procedure without having to exceed the item goal in any way.
As a remark for the experimental implementation with synthetic data, we note that we start the initial phase with a certain amount of pre-existing orders in the warehouse. These orders are given artificial ages in the initial phase according to a backfill procedure which assigns ages to them such that the age buckets are entirely filled from the back. In the example above for 600 initial orders, we would have 250 randomly selected orders of age 2 and 350 of age 1. In order for this backfill procedure to be applied, the sum of bucket sizes must exceed the number of initial orders. After at most phases, all of the initial orders are completed and the order ages converge to the “natural” distribution of the algorithm.
Given completion targets , the algorithm computes the order selection in the following way:
From the average order size, estimate the number of batches required to approximately fulfill the completion target.
From each set of orders of a given age, randomly sample as many orders as necessary to achieve the completion targets. These orders form the set of mandatory orders.
Within each batch, we use the FDGA procedure on to find the first orders. Thereby, we attempt to evenly spread the mandatory orders across all batches.
Then, we use FDGA on the full order set to complete the batch up to the maximum batch size, i.e. we use both and the remaining orders that are not selected as mandatory.
If no more mandatory orders are left during the first phase, we simply use the remaining orders to compute a standard batch with FDGA.
In our experiments, we use the following implementations of the bucket sizes. Note that both of them implicitly use (an estimate of) the number of newly added orders in each phase.
FDGA-Linear() implements a linear decline of bucket sizes from to 0 at age . The buckets are thus given by
FDGA-Cutoff() does not impose any restrictions on the orders up to age , but then requires all orders of that age to be completed. Thus we have and .
Instance Parameters
Before we present our data, we outline some details of the computation that are not addressed in the abstract problem model in § 2.1. Our computational experiments and reference algorithms (DGA and RDGA as explained in the paper) are based on [3] and their public code repository for this project (https://github.com/zalandoresearch/batching-benchmarks/). To allow for better comparability with their results, we maintain their instance generation parameters for the different categories, which we reproduce in Table 1.
The complete generation procedure of [3] is not described in their article, but can only be found in their code repository, and is summarized in the following:
The number of different articles in the warehouse is approximately of the number of warehouse items. Each of these articles is assigned a random article volume taken as , where is drawn from a gamma distribution and denotes rounding to the nearest integer value.
Then, approximately three items are generated for each article. The remainder of the warehouse is filled with items that correspond to uniformly sampled articles. The location of each item is uniformly sampled across the available zones, rows and aisles.
The orders are finally generated from the list of available items. The order size is first sampled from a weighted distribution of sizes between 2 and 6 and then the articles of randomly chosen items are assigned. In order to ensure that every order can be completed, the chosen items are removed from the list for the generation of the next order.
Additional Data: Singlephase Instances in Different Variants
medium
| Algorithm | greedy routing | CVRP | Relative Performance | ||
| Cost | Time | Cost | Time | ||
| FDGA | 62354.4 | 8.7s | 61526.4 | 9.7s | -1.3% |
| FDGA-Skip | 62203.2 | 7.9s | 61215.6 | 8.9s | -1.6% |
| LocalDGA | 70684.4 | 5.7s | 68294.4 | 6.6s | -3.4% |
| RDGA- | 76453.2 | 1.8s | 75569.2 | 2.7s | -1.2% |
| RDGA-50 | 77449.2 | 1.4s | 77311.6 | 2.3s | -0.2% |
| RDGA | 139287.2 | 0.2s | 135510.8 | 1.0s | -2.7% |
Table 7. Comparing the heuristic routing subroutine with the improved CVRP-based solution for medium instances.
All values are averaged over five different instances and rounded to a tenth.
medium-fewzones
| Algorithm | medium-fewzones: Item distance from conveyor | medium-fewzones: Order size | medium-fewzones: Picklist length | medium-fewerzones: Item distance from conveyor | medium-fewerzones: Order size | medium-fewerzones: Picklist length |
| FDGA | 24.8 | 2.2 | 10.3 | 26.1 | 2.2 | 18.6 |
| FDGA-Skip | 24.9 | 2.2 | 10.3 | 26.1 | 2.2 | 18.6 |
| LocalDGA | 25.0 | 2.3 | 10.8 | 26.5 | 2.3 | 18.7 |
| RDGA-50 | 23.7 | 2.4 | 11.2 | 26.0 | 2.4 | 18.9 |
| RDGA- | 23.6 | 2.3 | 10.9 | 25.7 | 2.3 | 19.0 |
| RDGA | 36.1 | 2.7 | 13.0 | 38.9 | 2.6 | 19.2 |
| (Instance) | 33.93 | 2.65 | − | 34.01 | 2.64 | − |
Table 8. Further computational measures for medium instances with few and fewer zones.
All values are averaged over five different instances and represent the mean value over all batched items, picklists, and orders respectively. The reference values refer to all orders/items in the instance as compared to the ones picked by the algorithm. The picklist lengths correspond to average picker loads of 40% and 70-80%, respectively.
| Algorithm | greedy routing Cost | greedy routing Time | CVRP Cost | CVRP Time | Relative Performance |
| DGA | 41446.4 | 185.5s | 39017.2 | 191.2s | -5.9% |
| FDGA | 41446.4 | 30.4s | 39017.2 | 34.4s | -5.9% |
| FDGA–Skip | 41682.4 | 27.7s | 38881.2 | 29.8s | -6.7% |
| LocalDGA | 43815.6 | 9.1s | 41380.0 | 10.7s | -5.6% |
| LocalDGA-global | 44480.4 | 17.7s | 41004.8 | 19.3s | -7.8% |
| RDGA | 102917.6 | 0.2s | 91208.8 | 1.5s | -11.4% |
| RDGA–50 | 53383.2 | 2.3s | 51147.2 | 3.7s | -4.2% |
| RDGA– | 51320.4 | 2.9s | 49572.8 | 4.4s | -3.4% |
Table 9. Comparing the heuristic routing subroutine with the improved CVRP-based solution for medium-fewzones instances. All values are averaged over five different instances and rounded to a tenth.
medium-fewerzones
| Algorithm | greedy routing Cost | greedy routing Time | CVRP Cost | CVRP Time | Relative Performance |
| FDGA | 29281.6 | 74.7s | 26103.2 | 82.8s | -10.9% |
| FDGA–Skip | 28498.4 | 67.7s | 25474.0 | 72.9s | -10.6% |
| LocalDGA | 33404.4 | 21.1s | 29532.8 | 30.4s | -11.6% |
| RDGA– | 36911.6 | 6.1s | 34086.0 | 11.6s | -7.7% |
| RDGA–50 | 38494.0 | 4.7s | 35381.2 | 10.0s | -8.1% |
| RDGA | 83658.4 | 0.3s | 64500.4 | 6.2s | -22.9% |
Table 10. Comparing the heuristic routing subroutine with the improved CVRP-based solution for medium-fewerzones instances. All values are averaged over five different instances and rounded to a tenth.
medium-longbatch
| Algorithm | Cost | Relative Performance | Time |
| DGA | 57119.6 | +0.3% | 200.6s |
| FDGA | 57119.6 | +0.3% | 7.6s |
| FDGA–Skip | 56940.0 | (reference) | 7.1s |
| LocalDGA | 65272.8 | +14.6% | 9.1s |
| LocalDGA-global | 59092.8 | +3.8% | 9.8s |
| RDGA | 104873.2 | +84.2% | 0.3s |
| RDGA–50 | 63814.0 | +12.1% | 2.6s |
| RDGA– | 62356.0 | +9.5% | 3.3s |
Table 11. Benchmark data of selected algorithms for medium-longbatch instances. All values are averaged over five different medium-longbatch instances and rounded to the nearest tenth.
| Algorithm | Item distance from conveyor | Order size | Picklist length |
| DGA | 26.2 | 2.4 | 10.8 |
| FDGA | 26.2 | 2.4 | 10.8 |
| FDGA-Skip | 26.1 | 2.4 | 10.8 |
| LocalDGA | 27.1 | 2.5 | 11.6 |
| LocalDGA-global | 26.0 | 2.4 | 11.0 |
| RDGA | 35.8 | 2.7 | 12.9 |
| RDGA-50 | 24.9 | 2.4 | 11.1 |
| RDGA- | 24.7 | 2.4 | 11.1 |
| (Instance) | 34.03 | 2.65 | — |
Table 12. Further computational measures for medium-longbatch instances.
All values are averaged over five different medium-longbatch instances and represent the mean value over all batched items, picklists, and orders respectively. The reference values refer to all orders/items in the instance as compared to the ones picked by the algorithm.
| Algorithm | greedy routing Cost | greedy routing Time | CVRP Cost | CVRP Time | Relative Performance |
| DGA | 57119.6 | 200.6s | 53829.6 | 202.7s | -5.8% |
| FDGA | 57119.6 | 7.6s | 53829.6 | 9.6s | -5.8% |
| FDGA-Skip | 56940.0 | 7.1s | 53597.6 | 8.8s | -5.9% |
| LocalDGA | 65272.8 | 9.1s | 60786.8 | 10.6s | -6.9% |
| LocalDGA-global | 59092.8 | 9.8s | 56408.8 | 11.7s | -4.5% |
| RDGA | 104873.2 | 0.3s | 102068.8 | 1.7s | -2.7% |
| RDGA-50 | 63814.0 | 2.6s | 61192.0 | 4.3s | -4.1% |
| RDGA- | 62356.0 | 3.3s | 59592.8 | 4.9s | -4.4% |
Table 13. Comparing the heuristic routing subroutine with the improved CVRP-based solution for medium-longbatch instances.
All values are averaged over five different instances and rounded to a tenth.
large
| Algorithm | greedy routing Cost | greedy routing Time | CVRP Cost | CVRP Time | Relative Performance |
| DGA | 524925.2 | 10548.6s | 515961.6 | 10556.8s | -1.7% |
| FDGA | 524925.2 | 591.8s | 515961.6 | 603.6s | -1.7% |
| FDGA-Skip | 526366.8 | 545.5s | 517194.4 | 557.3s | -1.7% |
| LocalDGA | 597082.8 | 113.8s | 590370.4 | 123.4s | -1.1% |
| LocalDGA-global | 583514.4 | 198.4s | 574965.6 | 207.1s | -1.5% |
| RDGA | 1489700.8 | 9.8s | 1479903.2 | 19.7s | -0.7% |
| RDGA-50 | 843182.0 | 22.5s | 837952.4 | 31.5s | -0.6% |
| RDGA- | 734645.2 | 59.1s | 730166.0 | 68.7s | -0.6% |
Table 14. Comparing the heuristic routing subroutine with the improved CVRP-based solution for large instances.
All values are averaged over five different instances and rounded to a tenth.
large-fewzones
| Algorithm | Cost | Relative Performance | Time |
| DGA | 293734.0 | +0.2% | 19024.2s |
| FDGA | 293734.0 | +0.2% | 3142.6s |
| FDGA-Skip | 293233.6 | (reference) | 2841.0s |
| LocalDGA | 402608.4 | +37.3% | 569.5s |
| LocalDGA-global | 388380.8 | +32.4% | 1371.5s |
| RDGA | 1003955.2 | +242.4% | 9.4s |
| RDGA-50 | 513872.4 | +75.2% | 31.1s |
| RDGA- | 432059.6 | +47.3% | 100.6s |
Table 15. Benchmark data of selected algorithms for large-fewzones instances.
All values are averaged over five different large-fewzones instances and rounded to the nearest tenth.
| Algorithm | Item distance from conveyor | Order size | Picklist length |
| DGA | 24.8 | 2.2 | 10.0 |
| FDGA | 24.8 | 2.2 | 10.0 |
| FDGA-Skip | 24.7 | 2.2 | 10.0 |
| LocalDGA | 25.5 | 2.3 | 10.5 |
| LocalDGA-global | 24.7 | 2.3 | 10.5 |
| RDGA | 35.8 | 2.6 | 12.8 |
| RDGA-50 | 23.7 | 2.4 | 11.2 |
| RDGA- | 23.7 | 2.3 | 10.6 |
| (Instance) | 34.02 | 2.64 | — |
Table 16. Further computational measures for large-fewzones instances.
All values are averaged over five different large-fewzones instances and represent the mean value over all batched items, picklists, and orders respectively. The reference values refer to all orders/items in the instance as compared to the ones picked by the algorithm.
| Algorithm | greedy routing Cost | greedy routing Time | CVRP Cost | CVRP Time | Relative Performance |
| DGA | 293734.0 | 19024.2s | 273636.0 | 18974.8s | -6.8% |
| FDGA | 293734.0 | 3142.6s | 273649.6 | 3136.7s | -6.8% |
| FDGA-Skip | 293233.6 | 2841.0s | 274330.8 | 2861.8s | -6.4% |
| LocalDGA | 402608.4 | 569.5s | 374332.4 | 587.8s | -7.0% |
| LocalDGA-global | 388380.8 | 1371.5s | 366252.0 | 1384.7s | -5.7% |
| RDGA | 1003955.2 | 9.4s | 884936.4 | 21.7s | -11.9% |
| RDGA-50 | 513872.4 | 31.1s | 492736.0 | 45.4s | -4.1% |
| RDGA- | 432059.6 | 100.6s | 413892.8 | 119.9s | -4.2% |
Table 17. Comparing the heuristic routing subroutine with the improved CVRP-based solution for large-fewzones instances.
All values are averaged over five different instances and rounded to a tenth.
large-fewerzones
| Algorithm | Cost | Relative Performance | Time |
| DGA | 198821.6 | (reference) | 39523.7s |
| FDGA | 198824.8 | +0.0% | 7349.1s |
| FDGA-Skip | 199959.2 | +0.6% | 7387.5s |
| LocalDGA | 311075.2 | +56.5% | 1211.4s |
| RDGA- | 298406.0 | +50.1% | 199.0s |
| RDGA-50 | 369257.2 | +85.7% | 55.2s |
| RDGA | 826112.8 | +315.5% | 9.8s |
Table 18. Benchmark data of selected algorithms for large-fewerzones instances.
All values are averaged over five different large-fewerzones instances and rounded to the nearest tenth.
| Algorithm | Item distance from conveyor | Order size | Picklist length |
| DGA | 25.7 | 2.1 | 18.0 |
| FDGA | 25.7 | 2.1 | 18.0 |
| FDGA-Skip | 25.6 | 2.1 | 18.1 |
| LocalDGA | 26.5 | 2.3 | 18.7 |
| RDGA- | 24.8 | 2.3 | 18.7 |
| RDGA-50 | 25.3 | 2.3 | 18.8 |
| RDGA | 38.4 | 2.6 | 19.3 |
| (Instance) | 34.01 | 2.64 | − |
Table 19. Further computational measures for large-fewerzones instances.
All values are averaged over five different large-fewerzones instances and represent the mean value over all batched items, picklists, and orders respectively. The reference values refer to all orders/items in the instance as compared to the ones picked by the algorithm.
| Algorithm | greedy routing Cost | greedy routing Time | CVRP Cost | CVRP Time | Relative Performance |
| DGA | 198821.6 | 39523.7s | 175403.6 | 39742.8s | -11.8% |
| FDGA | 198824.8 | 7349.1s | 175394.4 | 7408.7s | -11.8% |
| FDGA-Skip | 199959.2 | 7387.5s | 176067.6 | 7628.1s | -11.9% |
| LocalDGA | 311075.2 | 1211.4s | 273192.0 | 1277.7s | -12.2% |
| RDGA- | 298406.0 | 199.0s | 272717.6 | 263.0s | -8.6% |
| RDGA-50 | 369257.2 | 55.2s | 337725.6 | 109.6s | -8.5% |
| RDGA | 826112.8 | 9.8s | 640261.2 | 81.5s | -22.5% |
Table 20. Comparing the heuristic routing subroutine with the improved CVRP-based solution for large-fewerzones instances.
All values are averaged over five different instances and rounded to a tenth.
large-longbatch
| Algorithm | Cost | Relative Performance | Time |
| DGA | 441973.2 | +0.1% | 14517.6s |
| FDGA | 441973.2 | +0.1% | 402.4s |
| FDGA–Skip | 441499.6 | (reference) | 375.0s |
| LocalDGA | 498312.4 | +12.9% | 127.2s |
| RDGA– | 534064.4 | +21.0% | 80.2s |
| RDGA–50 | 624935.6 | +41.5% | 27.6s |
| RDGA | 1164882.0 | +163.8% | 10.0s |
Table 21. Benchmark data of selected algorithms for large-longbatch instances.
All values are averaged over five different large-longbatch instances and rounded to the nearest tenth.
| Algorithm | Item distance from conveyor | Order size | Picklist length |
| DGA | 24.4 | 2.2 | 6.1 |
| FDGA | 24.4 | 2.2 | 6.1 |
| FDGA–Skip | 24.4 | 2.2 | 6.1 |
| LocalDGA | 24.5 | 2.3 | 6.2 |
| RDGA– | 23.1 | 2.3 | 6.1 |
| RDGA–50 | 22.9 | 2.4 | 6.2 |
| RDGA | 34.7 | 2.6 | 6.6 |
| (Instance) | 34.03 | 2.64 | – |
Table 22. Further computational measures for large-longbatch instances.
All values are averaged over five different large-longbatch instances and represent the mean value over all batched items, picklists, and orders respectively. The reference values refer to all orders/items in the instance as compared to the ones picked by the algorithm.
| Algorithm | greedy routing Cost | greedy routing Time | CVRP Cost | CVRP Time | Relative Performance |
| DGA | 441973.2 | 14517.6s | 425062.8 | 14444.7s | -3.8% |
| FDGA | 441973.2 | 402.4s | 425062.8 | 418.5s | -3.8% |
| FDGA–Skip | 441499.6 | 375.0s | 425532.8 | 390.8s | -3.6% |
| LocalDGA | 498312.4 | 127.2s | 478226.4 | 137.2s | -4.0% |
| RDGA– | 534064.4 | 80.2s | 520688.0 | 91.5s | -2.5% |
| RDGA–50 | 624935.6 | 27.6s | 613729.2 | 36.8s | -1.8% |
| RDGA | 1164882.0 | 10.0s | 1079676.8 | 17.9s | -7.3% |
Table 23. Comparing the heuristic routing subroutine with the improved CVRP-based solution for large-longbatch instances.
All values are averaged over five different instances and rounded to a tenth.
Additional Data: Multiphase Instances in Different Variants
In this section, we augment the discussion from the main text by providing additional numerical results for the medium and large instance variants not outlined there (and including the data already provided in the main text).
| Algorithm | Total cost | Rel. cost | Avg. cost per item | Avg. cost per order |
| FDGA | 9120363 | (reference) | 34.94 | 90.98 |
| FDGA-Cutoff (5) | 11291446 | +23.8% | 43.85 | 115.47 |
| FDGA-Cutoff (10) | 10673561 | +17.0% | 41.32 | 108.36 |
| FDGA-Cutoff (15) | 10173553 | +11.5% | 39.34 | 102.96 |
| FDGA-Cutoff (20) | 9893970 | +8.5% | 38.19 | 99.85 |
| FDGA-Cutoff (25) | 9728927 | +6.7% | 37.48 | 97.89 |
| FDGA-Cutoff (30) | 9600925 | +5.3% | 36.99 | 96.58 |
| FDGA-Linear (10) | 10900664 | +19.5% | 42.07 | 110.38 |
| FDGA-Linear (15) | 10290667 | +12.8% | 39.71 | 103.95 |
| FDGA-Linear (20) | 9941275 | +9.0% | 38.36 | 100.31 |
| FDGA-Linear (25) | 9752540 | +6.9% | 37.6 | 98.21 |
| FDGA-Linear (30) | 9650298 | +5.8% | 37.09 | 96.82 |
| FDGA-Soft (0.8) | 9307641 | +2.1% | 35.95 | 94.61 |
| FDGA-Soft (0.9) | 8840642 | −3.1% | 34.16 | 89.73 |
| FDGA-Soft (0.95) | 8697709 | −4.6% | 33.55 | 87.98 |
| FDGA-Soft (0.99) | 8849031 | −3.0% | 34.02 | 88.89 |
| LocalDGA | 9243751 | +1.4% | 35.61 | 93.16 |
| RDGA- | 10826678 | +18.7% | 41.6 | 108.8 |
Table 24. Benchmark data comparing different multi-phase algorithms for medium instances.
The parameter for the number of new orders is set to 1000 if applicable and approximately corresponds to the number of new orders in each phase. The column for relative cost compares to the reference of FDGA. The values are averaged over 5 instances and rounded to appropriate precision.
| Algorithm | Average order length | Maximum order age | Average order age | Median order age |
| FDGA | 3.52 | 100.0 | 16.88 | 4.8 |
| FDGA-Cutoff(5) | 2.71 | 5.0 | 2.34 | 2.0 |
| FDGA-Cutoff(10) | 2.96 | 10.0 | 3.63 | 3.0 |
| FDGA-Cutoff(15) | 3.1 | 15.0 | 4.67 | 3.0 |
| FDGA-Cutoff(20) | 3.18 | 20.0 | 5.58 | 3.2 |
| FDGA-Cutoff(25) | 3.25 | 25.0 | 6.54 | 4.0 |
| FDGA-Cutoff(30) | 3.28 | 30.0 | 7.25 | 4.0 |
| FDGA-Linear(10) | 2.93 | 10.0 | 3.42 | 3.0 |
| FDGA-Linear(15) | 3.08 | 15.0 | 4.58 | 3.0 |
| FDGA-Linear(20) | 3.16 | 20.0 | 5.52 | 3.2 |
| FDGA-Linear(25) | 3.23 | 25.0 | 6.43 | 4.0 |
| FDGA-Linear(30) | 3.29 | 30.0 | 7.23 | 4.0 |
| FDGA-Soft(0.8) | 2.74 | 7.6 | 2.22 | 2.0 |
| FDGA-Soft(0.9) | 2.85 | 10.8 | 2.53 | 2.0 |
| FDGA-Soft(0.95) | 2.95 | 17.2 | 3.17 | 2.0 |
| FDGA-Soft(0.99) | 3.23 | 48.8 | 6.0 | 3.0 |
| LocalDGA | 3.12 | 100.0 | 11.52 | 3.2 |
| RDGA- | 3.15 | 100.0 | 13.66 | 4.0 |
Table 25. Further computational measures for different algorithms on medium instances.
All values are averaged over five different instances. The values are computed for the set of orders in the last phase of each run.
Figure 3. Age distribution data of single runs of FDGA, FDGA-Soft(0.9), and FDGA-Cutoff(10), respectively, on a medium instance. While many orders are completed right away, many of them remain in the problem until the end of the experiment.
| Algorithm | Total cost | Rel. cost | Avg. cost per item | Avg. cost per order |
| FDGA | 5609744 | (reference) | 21.51 | 55.97 |
| FDGA-Cutoff(5) | 7023362 | +25.2% | 27.28 | 71.84 |
| FDGA-Cutoff(10) | 6652562 | +18.6% | 25.75 | 67.46 |
| FDGA-Cutoff(15) | 6352230 | +13.2% | 24.59 | 64.29 |
| FDGA-Cutoff(20) | 6188696 | +10.3% | 23.87 | 62.34 |
| FDGA-Cutoff(25) | 6067686 | +8.2% | 23.4 | 61.07 |
| FDGA-Cutoff(30) | 5991385 | +6.8% | 23.04 | 60.12 |
| FDGA-Linear(10) | 6750239 | +20.3% | 26.15 | 68.55 |
| FDGA-Linear(15) | 6423991 | +14.5% | 24.81 | 64.88 |
| FDGA-Linear(20) | 6226611 | +11.0% | 24.03 | 62.77 |
| FDGA-Linear(25) | 6113034 | +9.0% | 23.53 | 61.43 |
| FDGA-Linear(30) | 6018649 | +7.3% | 23.16 | 60.43 |
| FDGA-Soft(0.8) | 5539346 | −1.3% | 21.39 | 56.25 |
| FDGA-Soft(0.9) | 5315791 | −5.2% | 20.55 | 53.93 |
| FDGA-Soft(0.95) | 5299643 | −5.5% | 20.43 | 53.51 |
| FDGA-Soft(0.99) | 5469906 | −2.5% | 21.01 | 54.84 |
| LocalDGA | 5566124 | −0.8% | 21.41 | 55.9 |
| RDGA- | 6620678 | +18.0% | 25.44 | 66.5 |
Table 26. Benchmark data comparing different multi-phase algorithms for medium-fewzones instances.
The parameter for the number of new orders is set to 1000 if applicable and approximately corresponds to the number of new orders in each phase. The column for relative cost compares to the reference of FDGA. The values are averaged over 5 instances and rounded to appropriate precision.
| Algorithm | Average order length | Maximum order age | Average order age | Median order age |
| FDGA | 3.6 | 100.0 | 15.72 | 4.2 |
| FDGA-Cutoff(5) | 2.73 | 5.0 | 2.34 | 2.0 |
| FDGA-Cutoff(10) | 3.03 | 10.0 | 3.53 | 3.0 |
| FDGA-Cutoff(15) | 3.17 | 15.0 | 4.56 | 3.0 |
| FDGA-Cutoff(20) | 3.26 | 20.0 | 5.46 | 3.0 |
| FDGA-Cutoff(25) | 3.32 | 25.0 | 6.27 | 3.2 |
| FDGA-Cutoff(30) | 3.38 | 30.0 | 7.05 | 3.4 |
| FDGA-Linear(10) | 3.0 | 10.0 | 3.37 | 3.0 |
| FDGA-Linear(15) | 3.16 | 15.0 | 4.47 | 3.0 |
| FDGA-Linear(20) | 3.26 | 20.0 | 5.43 | 3.0 |
| FDGA-Linear(25) | 3.33 | 25.0 | 6.31 | 3.2 |
| FDGA-Linear(30) | 3.38 | 30.0 | 7.11 | 3.8 |
| FDGA-Soft(0.8) | 2.81 | 8.2 | 2.29 | 2.0 |
| FDGA-Soft(0.9) | 2.93 | 12.6 | 2.71 | 2.0 |
| FDGA-Soft(0.95) | 3.06 | 20.0 | 3.38 | 2.0 |
| FDGA-Soft(0.99) | 3.35 | 60.6 | 6.49 | 3.0 |
| LocalDGA | 3.31 | 100.0 | 12.35 | 3.0 |
| RDGA- | 3.21 | 100.0 | 12.11 | 4.0 |
Table 27. Further computational measures for different algorithms on medium-fewzones instances.
All values are averaged over five different instances. The values are computed for the set of orders in the last phase of each run.
Figure 4. Age distribution data of single runs of FDGA, FDGA-Soft(0.9), and FDGA-Cutoff(10) on a medium-fewzones instance.
While many orders are completed right away, many of them remain in the problem until the end of the experiment.
| Algorithm | Total cost | Rel. cost | Avg. cost per item | Avg. cost per order |
| FDGA | 3745953 | (reference) | 14.36 | 37.38 |
| FDGA-Cutoff(5) | 4883920 | +30.4% | 18.98 | 49.99 |
| FDGA-Cutoff(10) | 4546505 | +21.4% | 17.63 | 46.2 |
| FDGA-Cutoff(15) | 4329714 | +15.6% | 16.74 | 43.79 |
| FDGA-Cutoff(20) | 4192427 | +11.9% | 16.19 | 42.3 |
| FDGA-Cutoff(25) | 4097160 | +9.4% | 15.81 | 41.27 |
| FDGA-Cutoff(30) | 4041441 | +7.9% | 15.57 | 40.64 |
| FDGA-Linear(10) | 4621480 | +23.4% | 17.92 | 46.99 |
| FDGA-Linear(15) | 4367900 | +16.6% | 16.9 | 44.22 |
| FDGA-Linear(20) | 4233545 | +13.0% | 16.35 | 42.74 |
| FDGA-Linear(25) | 4137448 | +10.5% | 15.94 | 41.61 |
| FDGA-Linear(30) | 4073021 | +8.7% | 15.68 | 40.92 |
| FDGA-Soft(0.8) | 3583825 | −4.3% | 13.88 | 36.49 |
| FDGA-Soft(0.9) | 3476141 | −7.2% | 13.45 | 35.28 |
| FDGA-Soft(0.95) | 3495369 | −6.7% | 13.49 | 35.32 |
| FDGA-Soft(0.99) | 3659150 | −2.3% | 14.07 | 36.71 |
| LocalDGA | 3863173 | +3.1% | 14.88 | 38.9 |
| RDGA- | 4449204 | +18.8% | 17.14 | 44.82 |
Table 28. Benchmark data comparing different multi-phase algorithms for medium-fewerzones instances.
The parameter for the number of new orders is set to 1000 if applicable and corresponds approximately to the number of new orders in each phase. The column for relative cost compares to the reference of FDGA. The values are averaged over 5 instances and rounded to appropriate precision.
| Algorithm | Average order length | Maximum order age | Average order age | Median order age |
| FDGA | 3.63 | 100.0 | 15.52 | 4.0 |
| FDGA-Cutoff(5) | 2.74 | 5.0 | 2.33 | 2.0 |
| FDGA-Cutoff(10) | 3.07 | 10.0 | 3.54 | 3.0 |
| FDGA-Cutoff(15) | 3.21 | 15.0 | 4.52 | 3.0 |
| FDGA-Cutoff(20) | 3.3 | 20.0 | 5.48 | 3.0 |
| FDGA-Cutoff(25) | 3.36 | 25.0 | 6.32 | 3.6 |
| FDGA-Cutoff(30) | 3.4 | 30.0 | 7.11 | 3.8 |
| FDGA-Linear(10) | 3.04 | 10.0 | 3.36 | 3.0 |
| FDGA-Linear(15) | 3.21 | 15.0 | 4.49 | 3.0 |
| FDGA-Linear(20) | 3.29 | 20.0 | 5.42 | 3.0 |
| FDGA-Linear(25) | 3.36 | 25.0 | 6.3 | 3.2 |
| FDGA-Linear(30) | 3.39 | 30.0 | 7.07 | 3.8 |
| FDGA-Soft(0.8) | 2.88 | 9.4 | 2.43 | 2.0 |
| FDGA-Soft(0.9) | 3.02 | 13.4 | 2.91 | 2.0 |
| FDGA-Soft(0.95) | 3.14 | 21.4 | 3.69 | 2.4 |
| FDGA-Soft(0.99) | 3.42 | 68.8 | 7.27 | 3.0 |
| LocalDGA | 3.24 | 100.0 | 11.73 | 3.0 |
| RDGA– | 3.24 | 100.0 | 11.63 | 3.6 |
Table 29. Further computational measures for different algorithms on medium-fewerzones instances.
All values are averaged over five different instances. The values are computed for the set of orders in the last phase of each run.
Figure 5. Age distribution data of single runs of FDGA, FDGA-Soft(0.9), and FDGA-Cutoff(10) on a medium-fewerzones instance.
While many orders are completed right away, many of them remain in the problem until the end of the experiment.
| Algorithm | Total cost | Rel. cost | Avg. cost per item | Avg. cost per order |
| FDGA | 6563409 | (reference) | 24.61 | 64.41 |
| FDGA-Cutoff(5) | 8441069 | +28.6% | 31.62 | 83.37 |
| FDGA-Cutoff(10) | 7819809 | +19.1% | 29.17 | 76.66 |
| FDGA-Cutoff(15) | 7385350 | +12.5% | 27.62 | 72.51 |
| FDGA-Cutoff(20) | 7154438 | +9.0% | 26.77 | 70.21 |
| FDGA-Cutoff(25) | 7026946 | +7.1% | 26.3 | 68.96 |
| FDGA-Cutoff(30) | 6945899 | +5.8% | 26.0 | 68.16 |
| FDGA-Linear(10) | 7871377 | +19.9% | 29.55 | 77.7 |
| FDGA-Linear(15) | 7391335 | +12.6% | 27.76 | 72.86 |
| FDGA-Linear(20) | 7147220 | +8.9% | 26.83 | 70.38 |
| FDGA-Linear(25) | 6995720 | +6.6% | 26.29 | 68.92 |
| FDGA-Linear(30) | 6910578 | +5.3% | 25.97 | 68.05 |
| FDGA-Soft(0.8) | 6817485 | +3.9% | 25.46 | 67.13 |
| FDGA-Soft(0.9) | 6500641 | −1.0% | 24.3 | 63.98 |
| FDGA-Soft(0.95) | 6397924 | −2.5% | 23.95 | 62.97 |
| FDGA-Soft(0.99) | 6468726 | −1.4% | 24.21 | 63.48 |
| LocalDGA | 6412469 | −2.3% | 24.12 | 63.33 |
| RDGA- | 7052168 | +7.4% | 26.52 | 69.51 |
Table 30. Benchmark data comparing different multi-phase algorithms for medium-longbatch instances.
The parameter for the number of new orders is set to 1000 if applicable and corresponds approximately to the number of new orders in each phase. The column for relative cost compares to the reference of FDGA. The values are averaged over 5 instances and rounded to appropriate precision.
| Algorithm | Average order length | Maximum order age | Average order age | Median order age |
| FDGA | 3.23 | 100.0 | 10.58 | 3.0 |
| FDGA-Cutoff(5) | 2.72 | 5.0 | 2.29 | 2.0 |
| FDGA-Cutoff(10) | 2.93 | 10.0 | 3.38 | 3.0 |
| FDGA-Cutoff(15) | 3.0 | 15.0 | 4.2 | 3.0 |
| FDGA-Cutoff(20) | 3.06 | 20.0 | 4.93 | 3.0 |
| FDGA-Cutoff(25) | 3.09 | 25.0 | 5.49 | 3.0 |
| FDGA-Cutoff(30) | 3.11 | 30.0 | 6.01 | 3.0 |
| FDGA-Linear(10) | 2.89 | 10.0 | 3.25 | 3.0 |
| FDGA-Linear(15) | 3.0 | 15.0 | 4.16 | 3.0 |
| FDGA-Linear(20) | 3.05 | 20.0 | 4.87 | 3.0 |
| FDGA-Linear(25) | 3.09 | 25.0 | 5.49 | 3.0 |
| FDGA-Linear(30) | 3.12 | 30.0 | 6.04 | 3.0 |
| FDGA-Soft(0.8) | 2.73 | 7.8 | 2.19 | 2.0 |
| FDGA-Soft(0.9) | 2.81 | 11.2 | 2.52 | 2.0 |
| FDGA-Soft(0.95) | 2.9 | 18.4 | 3.06 | 2.0 |
| FDGA-Soft(0.99) | 3.08 | 53.8 | 5.14 | 3.0 |
| LocalDGA | 2.97 | 100.0 | 8.27 | 3.0 |
| RDGA- | 3.11 | 100.0 | 10.15 | 3.0 |
Table 31. Further computational measures for different algorithms on medium-longbatch instances.
All values are averaged over five different instances. The values are computed for the set of orders in the last phase of each run.
Figure 6. Age distribution data of single runs of FDGA, FDGA-Soft(0.9), and FDGA-Cutoff(10) on a medium-longbatch instance.
While many orders are completed right away, many of them remain in the problem until the end of the experiment.
| Algorithm | Total cost | Rel. cost | Avg. cost per item | Avg. cost per order |
| FDGA | 87550699 | (reference) | 34.57 | 89.72 |
| LocalDGA | 94800948 | +8.3% | 37.44 | 97.58 |
| RDGA- | 113283647 | +29.4% | 44.74 | 116.7 |
| FDGA-Cutoff(5) | 105116080 | +20.1% | 41.54 | 109.44 |
| FDGA-Cutoff(10) | 102316383 | +16.9% | 40.42 | 105.86 |
| FDGA-Cutoff(15) | 98299057 | +12.3% | 38.83 | 101.44 |
| FDGA-Cutoff(20) | 95859887 | +9.5% | 37.86 | 98.77 |
| FDGA-Cutoff(25) | 94138537 | +7.5% | 37.18 | 96.91 |
| FDGA-Cutoff(30) | 92982284 | +6.2% | 36.72 | 95.65 |
| FDGA-Linear(10) | 103842705 | +18.6% | 41.03 | 107.54 |
| FDGA-Linear(15) | 99300767 | +13.4% | 39.22 | 102.5 |
| FDGA-Linear(20) | 96571183 | +10.3% | 38.14 | 99.51 |
| FDGA-Linear(25) | 94728169 | +8.2% | 37.41 | 97.52 |
| FDGA-Linear(30) | 93511512 | +6.8% | 36.93 | 96.2 |
| FDGA-Soft(0.8) | 86994048 | −0.6% | 34.36 | 90.4 |
| FDGA-Soft(0.9) | 83130094 | −5.0% | 32.83 | 86.18 |
| FDGA-Soft(0.95) | 82055044 | −6.3% | 32.41 | 84.85 |
| FDGA-Soft(0.99) | 84573403 | −3.4% | 33.39 | 86.99 |
Table 32. Benchmark data comparing different multi-phase algorithms for large instances.
The parameter for the number of new orders is set to 10,000 if applicable and corresponds approximately to the number of new orders in each phase. The column for relative cost compares to the reference of FDGA. The values are averaged over 5 instances and rounded to appropriate precision.
| Algorithm | Average order length | Maximum order age | Average order age | Median order age |
| FDGA | 3.86 | 100.0 | 23.32 | 8.0 |
| LocalDGA | 3.45 | 100.0 | 17.37 | 5.0 |
| RDGA- | 3.37 | 100.0 | 18.12 | 6.0 |
| FDGA-Cutoff(5) | 2.72 | 5.0 | 2.36 | 2.0 |
| FDGA-Cutoff(10) | 3.07 | 10.0 | 3.73 | 3.0 |
| FDGA-Cutoff(15) | 3.26 | 15.0 | 4.96 | 4.0 |
| FDGA-Cutoff(20) | 3.37 | 20.0 | 6.11 | 4.0 |
| FDGA-Cutoff(25) | 3.45 | 25.0 | 7.21 | 4.0 |
| FDGA-Cutoff(30) | 3.51 | 30.0 | 8.25 | 5.0 |
| FDGA-Linear(10) | 3.01 | 10.0 | 3.49 | 3.0 |
| FDGA-Linear(15) | 3.24 | 15.0 | 4.82 | 4.0 |
| FDGA-Linear(20) | 3.36 | 20.0 | 6.02 | 4.0 |
| FDGA-Linear(25) | 3.44 | 25.0 | 7.12 | 4.0 |
| FDGA-Linear(30) | 3.51 | 30.0 | 8.18 | 5.0 |
| FDGA-Soft(0.8) | 2.79 | 8.2 | 2.29 | 2.0 |
| FDGA-Soft(0.9) | 2.93 | 12.0 | 2.66 | 2.0 |
| FDGA-Soft(0.95) | 3.1 | 19.0 | 3.37 | 2.4 |
| FDGA-Soft(0.99) | 3.49 | 62.2 | 7.23 | 4.0 |
Table 33. Further computational measures for different algorithms on large instances.
All values are averaged over five different instances. The values are computed for the set of orders in the last phase of each run.
Figure 7. Age distribution data of single runs of FDGA, FDGA-Soft(0.9), and FDGA-Cutoff(10) on a large instance.
While many orders are completed right away, many of them remain in the problem until the end of the experiment.
| Algorithm | Total cost | Rel. cost | Avg. cost per item | Avg. cost per order |
| FDGA | 43981250 | (reference) | 17.36 | 45.02 |
| FDGA-Cutoff(5) | 54296417 | +23.5% | 21.46 | 56.51 |
| FDGA-Cutoff(10) | 53246126 | +21.1% | 21.04 | 55.02 |
| FDGA-Cutoff(15) | 51400118 | +16.9% | 20.3 | 52.96 |
| FDGA-Cutoff(20) | 50092825 | +13.9% | 19.78 | 51.54 |
| FDGA-Cutoff(25) | 49028580 | +11.5% | 19.36 | 50.39 |
| FDGA-Cutoff(30) | 48185738 | +9.6% | 19.03 | 49.49 |
| FDGA-Linear(10) | 54051806 | +22.9% | 21.36 | 55.9 |
| FDGA-Linear(15) | 52250241 | +18.8% | 20.64 | 53.84 |
| FDGA-Linear(20) | 50807093 | +15.5% | 20.07 | 52.28 |
| FDGA-Linear(25) | 49638096 | +12.9% | 19.6 | 51.01 |
| FDGA-Linear(30) | 48764224 | +10.9% | 19.26 | 50.09 |
| FDGA-Soft(0.8) | 41342885 | −6.0% | 16.33 | 42.85 |
| FDGA-Soft(0.9) | 40298227 | −8.4% | 15.92 | 41.66 |
| FDGA-Soft(0.95) | 40632844 | −7.6% | 16.05 | 41.89 |
| FDGA-Soft(0.99) | 42683060 | −3.0% | 16.85 | 43.81 |
| LocalDGA | 51058898 | +16.1% | 20.16 | 52.61 |
| RDGA- | 57668601 | +31.1% | 22.77 | 59.32 |
Table 34. Benchmark data comparing different multi-phase algorithms for large-fewzones instances.
The parameter for the number of new orders is set to 10,000 if applicable and corresponds approximately to the number of new orders in each phase. The column for relative cost compares to the reference of FDGA. The values are averaged over 5 instances and rounded to appropriate precision.
| Algorithm | Average order length | Maximum order age | Average order age | Median order age |
| FDGA | 3.97 | 100.0 | 21.71 | 7.0 |
| FDGA-Cutoff(5) | 2.73 | 5.0 | 2.36 | 2.0 |
| FDGA-Cutoff(10) | 3.16 | 10.0 | 3.68 | 3.0 |
| FDGA-Cutoff(15) | 3.36 | 15.0 | 4.88 | 3.6 |
| FDGA-Cutoff(20) | 3.48 | 20.0 | 6.02 | 4.0 |
| FDGA-Cutoff(25) | 3.56 | 25.0 | 7.09 | 4.0 |
| FDGA-Cutoff(30) | 3.62 | 30.0 | 8.08 | 4.8 |
| FDGA-Linear(10) | 3.11 | 10.0 | 3.46 | 3.0 |
| FDGA-Linear(15) | 3.35 | 15.0 | 4.77 | 3.0 |
| FDGA-Linear(20) | 3.47 | 20.0 | 5.93 | 4.0 |
| FDGA-Linear(25) | 3.56 | 25.0 | 7.02 | 4.0 |
| FDGA-Linear(30) | 3.62 | 30.0 | 8.03 | 4.8 |
| FDGA-Soft(0.8) | 2.93 | 9.8 | 2.48 | 2.0 |
| FDGA-Soft(0.9) | 3.11 | 15.0 | 3.03 | 2.0 |
| FDGA-Soft(0.95) | 3.3 | 23.6 | 3.94 | 3.0 |
| FDGA-Soft(0.99) | 3.67 | 77.0 | 8.51 | 4.0 |
| LocalDGA | 3.35 | 100.0 | 13.62 | 4.0 |
| RDGA- | 3.49 | 100.0 | 15.76 | 4.2 |
Table 35. Further computational measures for different algorithms on large-fewzones instances.
All values are averaged over five different instances. The values are computed for the set of orders in the last phase of each run.
Figure 8. Age distribution data of single runs of FDGA, FDGA-Soft(0.9), and FDGA-Cutoff(10) on a large-fewzones instance.
While many orders are completed right away, many of them remain in the problem until the end of the experiment.
References
- [1][AAÖ25] Ozan Rıdvan Aksu, Necati Aras, and Temel Öncan. Solving the joint order batching and picker routeing selection problem in warehouses. Int. J. Prod. Res., pages 1–26, October 2025.DOI
- [2][ACS21] Babiche Aerts, Trijntje Cornelissens, and Kenneth Sörensen. The joint order batching and picker routing problem: Modelled and solved as a clustered vehicle routing problem. Comput. Oper. Res., 129(105168):105168, May 2021.DOI
- [3][AKK+25] Giorgio Abelli, Maximilian Katzmann, Imran Khan, Olaf Maurer, Julius Pätzold, Pawel Pszona, and Jan-David Salchow. Joint order selection, allocation, batching and picking for large scale warehouses, 2025.arxiv.org/abs/2401.04563
- [4][BBBS24] Stefan Bock, Stefan Bomsdorf, Nils Boysen, and Michael Schneider. A survey on the traveling salesman problem and its variants in a warehousing context. Eur. J. Oper. Res., April 2024.
- [5][BBV+24] Michele Bocelli, Eleonora Bottani, Andrea Volpi, Federico Solari, Natalya Lysova, and Roberto Montanari. Exploring the relationship between routing policies and market demand heterogeneity. J. Ind. Inf. Integr., 40(100634):100634, July 2024.DOI
- [6][BCC+20] Olivier Briant, Hadrien Cambazard, Diego Cattaruzza, Nicolas Catusse, Anne-Laure Ladier, and Maxime Ogier. An efficient and general approach for the joint order batching and picker routing problem. Eur. J. Oper. Res., 285(2):497–512, September 2020.
- [7][BdKW19] Nils Boysen, René de Koster, and Felix Weidinger. Warehousing in the e-commerce era: A survey. Eur. J. Oper. Res., 277(2):396–411, September 2019.DOI
- [8][CC18] Hadrien Cambazard and Nicolas Catusse. Fixed-parameter algorithms for rectilinear steiner tree and rectilinear traveling salesman problem in the plane. Eur. J. Oper. Res., 270(2):419–429, October 2018.DOI
- [9][CCCCE21] Jose Alejandro Cano, Pablo Cortés, Emiro Antonio Campo, and Alexander Alberto Correa-Espinal. Solving the order batching and sequencing problem with multiple pickers: A grouped genetic algorithm. Int. J. Electr. Comput. Eng. (IJECE), 11(3):2516, June 2021.DOI
- [10][CLSG24] Ruomeng Cui, Zhikun Lu, Tianshu Sun, and Joseph M Golden. Sooner or later? promising delivery speed in online retail. Manuf. Serv. Oper. Manag., 26(1):233–251, January 2024.
- [11][CSRM15] Luis F Cardona, Diego F Soto, Leonardo Rivera, and Hector J Martínez. Detailed design of fishbone warehouse layouts with vertical travel. Int. J. Prod. Econ., 170:825–837, December 2015.DOI
- [12][CVM+23] Giorgia Casella, Andrea Volpi, Roberto Montanari, Letizia Tebaldi, and Eleonora Bottani. Trends in order picking: a 2007–2022 review of the literature. Production & Manufacturing Research, 11(1), 2023.DOI
- [13][CZLZ23] Zhengcai Cao, Lijie Zhou, Chengran Lin, and Mengchu Zhou. Solving an order batching, picker assignment, batch sequencing and picker routing problem via information integration. J. Ind. Inf. Integr., 31(100414):100414, February 2023.DOI
- [14][DSL+25] George Dunn, Elizabeth Stojanovski, Bishnu Lamichhane, Hadi Charkhgard, and Ali Eshragh. Deterministic structure of vertical configurations in minimal picker tours for rectangular warehouses, 2025.arxiv.org/abs/2508.00365
- [15][FGX19] Marshall L Fisher, Santiago Gallino, and Joseph Jiaqi Xu. The value of rapid delivery in omnichannel retailing. J. Mark. Res., 56(5):732–748, October 2019.
- [16][FP26] Vincent Furnon and Laurent Perron. Or-tools routing library, 2026.
- [17][GV05] Noud Gademann and Steef Velde. Order batching to minimize total travel time in a parallel aisle warehouse. IIE Trans., 37(1):63–75, January 2005.
- [18][GVdBVDH01] Noud Gademann, Jeroen P Van den Berg, and Hassan H Van Der Hoff. An order batching algorithm for wave picking in a parallel-aisle warehouse. IIE Trans., 33(5):385–398, May 2001.
- [19][Kar72] Richard M Karp. Reducibility among combinatorial problems. In Complexity of Computer Computations, pages 85–103. Springer US, Boston, MA, 1972.
- [20][KGB20] Patrick Kübler, Christoph H Glock, and Thomas Bauernhansl. A new iterative method for solving the joint dynamic storage location assignment, order batching and picker routing problem in manual picker-to-parts warehouses. Comput. Ind. Eng., 147(106645):106645, September 2020.DOI
- [21][LBS22] Maximilian Löffler, Nils Boysen, and Michael Schneider. Picker routing in AGV-assisted order picking systems. INFORMS J. Comput., 34(1):440–462, January 2022.DOI
- [22][MGG20] Makusee Masae, Christoph H. Glock, and Eric H. Grosse. Order picker routing in warehouses: A systematic literature review. Int. J. Prod. Econ., 224(107564):107564, June 2020.DOI
- [23][MGV21] Makusee Masae, Christoph H Glock, and Panupong Vichitkunakorn. A method for efficiently routing order pickers in the leaf warehouse. Int. J. Prod. Econ., 234(108069):108069, April 2021.DOI
- [24]Oxford Economics. The economic impact of zalando in europe. Technical report, Oxford Economics, Zalando SE, Marienstraße 15, 60329, Frankfurt, Germany, December 2024.
- [25]Sevilay Onal, Jingran Zhang, and Sanchoy Das. Modelling and performance evaluation of explosive storage policies in internet fulfilment warehouses. Int. J. Prod. Res., 55(20):5902–5915, October 2017.DOI
- [26]Lucie Pansart, Nicolas Catusse, and Hadrien Cambazard. Exact algorithms for the order picking problem. Comput. Oper. Res., 100:117–127, December 2018.
- [27]Eduardo G. Pardo, Sergio Gil-Borrás, Antonio Alonso-Ayuso, and Abraham Duarte. Order batching problems: Taxonomy and literature review. European Journal of Operational Research, 313(1):1–24, 2024.DOI
- [28]Anderson Rogério Faia Pinto and Marcelo Seido Nagano. A comprehensive review of batching problems in low-level picker-to-parts systems with order due dates: Main gaps, trade-offs, and prospects for future research. J. Manuf. Syst., 65:1–18, October 2022.DOI
- [29]Kees Jan Roodbergen and René de Koster. Routing order pickers in a warehouse with a middle aisle. Eur. J. Oper. Res., 133(1):32–43, August 2001.DOI
- [30]Kimiya Rahmani Mokarrari, Taraneh Sow lati, Jeffrey English, and Michael Starkey. Optimization of warehouse picking to maximize the picked orders considering practical aspects. Appl. Math. Model., 137(115585):115585, January 2025.DOI
- [31]H Donald Ratliff and Arnon S Rosenthal. Order-picking in a rectangular warehouse: A solvable case of the traveling salesman problem. Oper. Res., 31(3):507–521, June 1983.DOI
- [32]Kees Jan Roodbergen and Iris F A Vis. A model for warehouse layout. IIE Trans., 38(10):799–811, October 2006.DOI
- [33]Maximilian Schiffer, Nils Boysen, Patrick S Klein, Gilbert Laporte, and Marco Pavone. Optimal picking policies in e-commerce warehouses. Manage. Sci., 68(10):7497–7517, October 2022.DOI
- [34]Son Thai Tran, Rui Jorge Almeida, Christof Defryn, and Inneke Van Nieuwenhuyse. Synchronous parallel heuristics for solving the joint order batching and picker routing problem. In 2024 IEEE Congress on Evolutionary Computation (CEC), pages 01–08. IEEE, June 2024.DOI
- [35]Mahmut Tutam and René De Koster. To walk or not to walk? designing intelligent order picking warehouses with collaborative robots. Transp. Res. Part E: Logist. Trans. Rev., 190(103696):103696, October 2024.DOI
- [36]James A Tompkins, John A White, Yavuz A Bozer, and J Tanchoco. Facilities Planning. Wiley-Blackwell, Hoboken, NJ, 4 edition, January 2010.







