Scheduling automated guided vehicles in very narrow aisle warehouses

: In this paper, we study the scheduling of storage and retrieval of unit loads from very narrow aisles using automated guided vehicles (AGVs). As AGVs cannot pass each other in the aisles, sequencing the aisle access is essential. We propose two access policies, present multiple complexity results and formulate MIP models. We then present a large neighborhood search that produces solutions within less than 2.5% of the optimum solu-tion on average in a short amount of time for instances with hundreds of jobs. We use our heuristic to derive insights into the best access policy, number of AGVs, as well as the optimal layout of very narrow aisle warehouses.


Introduction
Warehousing is a central element of basically all supply chains.It is estimated that warehousing accounts for about 20% of all logistics cost [10].Among the warehousing processes, order picking is by far the most capital and / or labor intensive one.About 50-75% of all operational cost in warehouses are commonly attributed to picking processes [33].To save on manual labor and increase space utilization, many companies have started to switch to fully or partially automated warehousing systems, like automated storage and retrieval systems [ASRS, e.g. , 35], robotic mobile fulfillment systems [RMFS, e.g., 4], or mobile rack warehouses [5].
One technological innovation that is gaining increasing traction is automated guided vehicles (AGVs) in very narrow aisle warehouses.In such a warehouse, driverless reach trucks carry unit loads (often pallets) between an input / output (I/O) station and a high rack storage area.Apart from the obvious efficiency gains and savings on manual labor, these AGVs also require very little clearance and can therefore safely operate in densely packed warehouses (see Figure 1b).
We observed such a system at the raw materials warehouse of a large European manufacturer of packaging equipment.The incoming materials are delivered only twice per week, therefore at most times there are only either storage or retrieval requests, but rarely both.The warehouse is divided into one broad cross-aisle running perpendicular to several very narrow storage aisles.The layout is schematically depicted in Figure 1a.Incoming pallets are stored in a buffer area, to be picked up by one of several AGVs.They are then taken to a very narrow aisle high rack area, whereupon the AGV returns to the buffer area to pick up the next pallet.The process for outgoing pallets is the same except in reverse.
In this context we consider the following problem.Given a set of transport jobs, which consist of going from the I/O station to one specific storage position and back, and a fleet of AGVs: which AGV processes which job at what time such that the last job finishes as soon as possible?The problem is made more complicated by the fact that, while the cross aisle is wide, AGVs inside the narrow aisles must observe non-crossing constraints, as they block each other in the narrow aisles and cannot pass each other.We refer to this problem as the multi-aisle access scheduling problem (MAAP).
Note that while we specifically observed this problem in a high-rack very narrow aisle warehouse, the general structure is also applicable to other use cases where a set of vehicles needs to access many one-dimensional paths that do not allow crossing.For example, Boysen et al. [6] discuss a case where multiple straddle carriers need to access the same railway track to (un-)load a freight train.Our problem can be seen as a generalization of this problem.We discuss the model of Boysen et al. [6] in more detail in the next section.
The contribution of this paper is as follows.Building on the work of Boysen et al. [6], we model the problem of scheduling AGVs in a very narrow aisle warehouse under the assumption of two different aisle access policies: exclusive, where an aisle must not be accessed if another AGV is already inside; and parallel, where multiple AGVs can enter the same aisle as long as they do not cross.We analyze the computational complexity and develop a suitable solution procedure based on large neighborhood search, which is shown to be efficient on instances of realistic size.We also investigate whether the more complicated parallel aisle access scheme can significantly improve AGV utilization.We compare the efficiency of a very narrow aisle warehouse both under the exclusive and the parallel access policy to a normal wide-aisle warehouse.Furthermore, we derive some insights into the optimum design of the warehouse in terms of size, shape, and number of AGVs.
The remainder of this paper is organized as follows.In Section 2, we review the relevant literature.We formalize the problem, present MIP models, and investigate the computational complexity in Section 3. We develop solution methods in Section 4, which we test in a computational study (Section https://doi.org/10.1016/j.omega.2020.1022045).Finally, Section 6 concludes this article.
(a) Schematic depiction of a warehouse with two AGVs.
(b) Picture of an AGV in a very narrow aisle 1 .

Literature review
A lot of research has been done to optimize the efficiency of automated storage and retrieval systems and the scheduling of retrieval devices (usually cranes).For a general overview of automated storage and retrieval systems see Roodbergen and Vis [35], Gagliardi et al. [15].While in AS/RS, cranes can usually not move between aisles (i.e., these systems are mostly aisle-captive), this is not true for AGVs.Among the comparatively few studies which take non-captive aisles served by multiple cranes into consideration are Rosenblatt et al. [36], Malmborg [28], Lerher [27], who provide analytical models and simulation tools to aid in the design of such systems.An overview of AGV-based systems, including in warehouses, is given by Le-Anh and De Koster [26].Specific scheduling problems dealing with AGVs in warehouses are provided by Ballestín et al. [3], who minimize the makespan of different kinds of forklifts by assigning storage locations and routing these forklifts for a given set of S/R requests.They decompose the problem, apply metaheuristics and priority rules, and study their effectiveness in a simulation.Ekren and Heragu [11] use simulation to derive insight into the optimal warehouse design, in particular the difference between standard cranes and automated vehicles.Boysen et al. [4], Lamballais et al. [25] deal with order picking in robotic mobile fulfilment systems, where semi-autonomous robots lift entire shelves.The literature on these systems is reviewed by Azadeh et al. [2].Öztürkoglu et al. [29] study the optimal arrangement of aisles, where almost all arrangements fit our assumptions.More notable https://doi.org/10.1016/j.omega.2020.102204ence between the no-waiting and the blocking scheduling problems.However, the MAAP is different from all previously studied problems in that we need the AGVs for the duration of the entire job but the aisles only for a part in the middle.

Problem description
The multi-aisle access scheduling problem (MAAP) entails assigning a given set of jobs consisting of either storage or retrieval of one specific stock keeping unit (SKU) at one specific location in the warehouse to a set of AGVs, and determining the sequence in which each AGV should handle the assigned jobs.Each job consists of traveling from the I/O station to the aisle where the item to be accessed is stored, accessing the item in the aisle, and going back to the I/O station.Traveling from / to the aisles through the cross aisle, AGVs can move without significant obstruction because the cross aisle is comparatively spacious.However, the individual aisles are very narrow, such that non-crossing constraints need to be observed.The goal is to finish the last job as early as possible.
Like all models, the formalization of MAAP is based on several assumptions.
• A job, once started, must be finished without preemption by the same AGV.
• All jobs are ready to be processed at time 0, and they do not have deadlines.While in many storage system, new transport requests tend to arrive over time, abstracting from this is not uncommon.Usually, it is suggested to replan the processing sequence periodically in a rolling fashion [20].Note that we discuss the inclusion of due dates in Section 4.3.
• AGVs accessing the same aisle must not cross.Otherwise, no safety distances are considered.
• Outside the aisles, AGVs can always move without obstruction.This is a slight simplification from reality as it is of course possible that two AGVs trying to access the I/O station at the same time might obstruct each other.Seeing that the cross-aisle is much wider than the storage aisles in most warehouses, usually permitting two-way traffic, these delays are comparatively minor.The delays at the depot are mostly dictated by the number of operators and space at the I/O station.They can therefore be assumed to be constant.
• Aisles can only be accessed from one side (from the cross aisle).Inside the aisles, AGVs never move past the position where they have to access the rack, i.e., AGVs always move from the I/O station to the assigned rack position and then back to the I/O station on the shortest path without detour.Note that this does not preclude AGVs from waiting for each other if necessary as long as this does not entail a detour.
• The AGV fleet is homogeneous.There are no differences between the individual vehicles.

Formal definition
Let J = {1, . . ., n} be the set of transport requests, referred to as jobs.Without loss of generality, we speak only of retrieval operations in the following; however, our model can also be used for storage https://doi.org/10.1016/j.omega.2020.102204operations as long as retrieval and storage jobs are not mixed on the same trip (i.e., no dual command cycles).Without loss of generality, we assume that jobs with a higher index j ′ are not closer to the front of the aisle than jobs with a lower index j < j ′ .Each job j ∈ J requires accessing one specific aisle i(j) ∈ I = {1, . . ., m}.An AGV traveling from the I/O station to aisle i(j) takes d t j time units.Retrieving item j from aisle i(j) takes p j time units; this includes the time it takes to travel from the front of the aisle to the rack location to be accessed, taking the item, and returning to the front of the aisle.Returning from the front of aisle i(j) to the depot then takes d f j time units.Finally, let K = {1, . . ., κ} be the set of AGVs.
A schedule Ω is a set of 4-tuples (j, k, r, w) ∈ Ω, indicating that job j ∈ J is processed such that AGV k accesses aisle i(j) at time r ∈ R + and exits the aisle at time r + p j + w, w ∈ R + .Note that w can be interpreted as the waiting time of AGV k during the execution of job j inside aisle i(j).A schedule is feasible if it satisfies the following conditions.
1.For each job j ∈ J, there is exactly one 4-tuple (j, k, r, w) ∈ Ω, i.e., each job is processed exactly once by one AGV.
2. For each (j, k, r, w) ∈ Ω, it must hold that r ≥ d t j , i.e., no job can start before time 0.
3. For each two distinct tuples (j, k, r, w) ∈ Ω and , no AGV can perform two jobs at the same time.
Finally, a feasible schedule must also observe the non-crossing constraints in the aisles.We consider two different access policies, analogous to Boysen et al. [6].First, we consider the exclusive aisle access policy.For each two distinct tuples (j, k, r, w) ∈ Ω and (j ′ , k ′ , r ′ , w ′ ) ∈ Ω where k ̸ = k ′ and i(j) = i(j ′ ), it must hold that r ′ + p j ′ + w ′ ≤ r or r + p j + w ≤ r ′ , i.e., no aisle is accessed by two vehicles concurrently.Note that under the exclusive policy, without loss of generality, we can assume that AGVs always wait at the I/O station if the aisle they want to access is not clear, i.e., w = 0, ∀(j, k, r, w) ∈ Ω.Given that under the exclusive policy, no two AGVs can share the same aisle anyway, waiting inside an aisle makes little sense, hence there is always an optimal solution where all w are zero.We refer to this problem version as MAAP-EX.
Alternatively, we consider access policy parallel.Using this policy, multiple AGVs may enter the same aisle.However, if a vehicle is blocking the exit, waiting time may ensue.For each two distinct tuples (j, k, r, w) ∈ Ω and (j ′ , k ′ , r ′ , w ′ ) ∈ Ω where k ̸ = k ′ and i(j) = i(j ′ ) and j < j ′ , it must hold that • if r < r ′ then r + p j + w ≤ r ′ , and The first condition is the same as for MAAP-EX.It states that if AGV k enters before AGV k ′ , k must leave before k ′ enters.The second condition covers the case different from the exclusive case, where two AGVs k and k ′ can enter the same aisle i(j) = i(j ′ ).In this case, AGV k processing job j, which is closer to the front of the aisle than j ′ , can enter the aisle while AGV k ′ is already in it, but in this case AGV k ′ cannot leave the aisle before AGV k does because k is blocking the exit.Of course, another AGV k ′′ can enter while both k and k ′ are in the aisle if it leaves before k (which implies that it leaves before k ′ ).In other words, a first-in-last-out order must be maintained if multiple AGV are in an aisle simultaneously.We refer to this problem version as MAAP-PA.
Regarding the objective, minimizing the completion time of the last job, i.e., the makespan, is usually seen as desirable, as this frees the AGVs for successive planning runs and ensures speedy processing of the schedule, which is especially important in a rolling horizon framework.Consequently, among all feasible schedules Ω, we seek one where all AGVs are back at the I/O station as early as possible, i.e., minimize

Example schedule
Consider an example problem with κ = 2 AGVs serving the warehouse with m = 3 aisles depicted in Figure 2b.A total of n = 5 jobs needs to be processed; the processing times inside the aisles are in Figure 2a.

MIP models
Using the notation from Table 1, to enable the use of default solvers, we adapt the mixed-integer programming models by Boysen et al. [6] to the MAAP as follows.First, under the exclusive access policy, we get the following model.processing time of job j inside the aisle M big integer x kj binary variables: 1, if AGV k is assigned to job j; 0, otherwise y jj ′ binary variables: 1, if the AGV processing job j leaves aisle i(j) = i(j ′ ) no later than the AGV processing job j ′ enters it; 0, otherwise z jj ′ binary variables: 1, if the AGV processing job j leaves aisle i(j) = i(j ′ ) sooner than the AGV processing j ′ leaves it; 0, otherwise r j continuous variables: time when aisle i(j) is accessed for job j w j continuous variables: waiting time within aisle i(j) while processing job j x kj ∈ {0; 1} ∀k ∈ K; j ∈ J (8) As r j + p j + d f j is the return time of the AGV processing job j, objective function (2) corresponds to minimizing the makespan of the schedule.Constraints (3) are MAAP-EX specific, guaranteeing no two AGVs enter the same aisle at the same time.Inequalities (4) force each AGV to finish one job before the next is started.Equations ( 5) enforce the sequencing decision and ( 6) ensure that each job is assigned to an AGV.Constraints (7) make sure that the AGVs have time to drive to the aisles before accessing them.Finally, ( 8) and ( 9) are the binary constraints.
Under the parallel access policy, we formulate MAAP-PA as the following mixed-integer programming model.

(MAAP-PA) Minimize
subject to ( 5) -( 9) and Accepted manuscript.Article published in Omega: The International Journal of Management Science available from https://doi.org/10.1016/j.omega.2020.102204 To account for the different access policy, Inequalities (3) and ( 4) are replaced by ( 11) through (15).Objective (10) additionally considers the waiting time inside the aisle.If the front of an aisle is already blocked, no other AGV can access it, as enforced by Constraints ( 12), equivalent to (3). ( 13) make it impossible for an AGV to start a job before the previous job is finished, analogous to (4).If the AGV blocking the front of an aisle arrives not sooner than an AGV accessing the back of an aisle, (11) establish that a later job in the permutation cannot start before an earlier job.Then, depending on the value of z jj ′ , either ( 14) make sure that the later job waits until the earlier job finishes before even entering the aisle, or (15) demand that the earlier job will not leave the aisle before the later job, which is blocking the aisle, finishes and leaves the aisle.Finally, ( 16) and ( 17) define the domain of the additional variables.
To illustrate the effect of the non-collision constraints in model MAAP-PA, consider the following example.Under the assumptions outlined in Section 3, a collision inside an aisle can occur in one of two cases: Given two jobs j 0 and j 1 both accessing the same aisle (i.e., i(j 0 ) = i(j 1 )), where, w.l.o.g., we assume that job j 1 is farther inside the aisle than job j 0 , i.e., j 0 < j 1 , there is a collision if one of the following conditions is satisfied.
1.The AGV processing job j 0 enters the aisle before the AGV processing job j 1 but leaves later, i.e., r j 0 < r j 1 < r j 0 + p j 0 + w j 0 .In plain words: the AGV processing job j 0 blocks the aisle while the other AGV wants to enter.In this case, Constraint (11) forces y j 1 j 0 = 0.By Constraint (5), this implies that y j 0 j 1 = 1.This, in turn, makes Constraint (12) unsatisfiable.
2. The AGV processing job j 0 enters the aisle while the AGV processing job j 1 is in it but the former leaves the aisle later than the latter, i.e., r j 1 + p j 1 + w j 1 > r j 0 ≥ r j 1 ∧ r j 0 + p j 0 + w j 0 > r j 1 + p j 1 + w j 1 .In plain words: the AGV processing job j 0 blocks the aisle when the other AGV wants to exit.In this case, Constraint ( 14) forces z j 1 j 0 = 0, while Constraint ( 15) is only satisfied if z j 1 j 0 = 1, i.e., the solution is infeasible.
Note that in the case that the AGV processing job j 0 enters the aisle while the AGV processing job j 1 is in it but the former leaves no later than the latter (i.e., r j 1 +p j 1 +w j 1 > r j 0 ≥ r j 1 ∧r j 0 +p j 0 +w j 0 ≤ r j 1 + p j 1 + w j 1 ), there is no conflict, because both Constraints ( 14) and ( 15) are satisfied if z j 1 j 0 = 0.
This corresponds to the case that two AGVs are accessing the same aisle concurrently, but the firstin-last-out order is maintained, that is, the AGV blocking the exit leaves no later than the other AGV.

Time complexity
At first glance, it seems clear that MAAP is a hard problem.Boysen et al. [6] analyze a simpler problem version with only one single aisle and find it to be NP-hard in the strong sense.The results of Boysen et al. [6, Section 3.2] imply that MAAP-PA under a parallel access policy is NP-hard in the strong sense even if there are only κ = 2 AGVs and m = 1 aisle, and it holds that the assignment of jobs to AGVs is already fixed.Their results do not, however, resolve the complexity status of https://doi.org/10.1016/j.omega.2020.102204 MAAP-EX under an exclusive access policy if the assignment of jobs to AGVs is already given.Note that this is an important result in that it can give a hint on whether decomposition approaches may be viable.Unfortunately, this is unlikely to be the case.
Proposition 3.1.MAAP-EX is NP-hard in the strong sense even if the assignment of AGVs to jobs is fixed and the order of jobs on each AGV is fixed.
Proof.In the appendix.
Note that the proof also works when switching the roles of the AGVs and the aisles, i.e., if the permutation is fixed for aisle access instead of the AGVs.Under a parallel access policy, MAAP-PA is intractable even if the job assignment to AGVs, the order of jobs per AGV, and the order of when jobs may access each aisle are given, that is, if only the decision of which AGV should wait inside the aisles remains open.Proposition 3.2.MAAP-PA is NP-hard in the strong sense even if the assignment of jobs to AGVs, the permutation of jobs on each AGV, and, for each aisle, the order in which jobs may enter the aisle are fixed.
Proof.In the appendix.
Moreover, regardless of access policy, given a sequence of jobs such that each AGV can only process jobs in the fixed order, merely assigning jobs to AGVs is NP-hard, even if there are no conflicts in the aisles.Proposition 3.3.Given a permutation of jobs such that for each two jobs j, j ′ ∈ J, j ̸ = j ′ , processed by the same AGV, job j must be completed no later than j ′ is started iff j comes before j ′ in the sequence, it is NP-hard to determine an optimal assignment of jobs to AGVs, even if each job is in a separate aisle.
Proof.In the appendix.

Solution methods
Given the NP-hard nature of MAAP and its subproblems regardless of access policy, default solvers are unlikely to be very effective, as is confirmed by our computational experiments (Section 5).To propose an algorithm that is useful for realistic instances, we develop a large neighborhood search heuristic [LNS,37].Our LNS operates on permutations of jobs, which are efficiently decoded into complete solutions.We first describe how solutions are en-and decoded in Section 4.1, and then explain our LNS in detail in Section 4.2.Finally, we address some important generalizations, namely dual command cycles and due dates, in Section 4.3.

Solution encoding and decoding
For our LNS, a solution is encoded as a permutation Σ = ⟨σ 1 , . . ., σ n ⟩ of job set J, prescribing in what order jobs access aisles.Let r j be the time when the AGV assigned to job j accesses aisle i(j).Let k(j) be the AGV that has been assigned job j.Then a permutation Σ implies that r σ l ≤ r σ l ′ , for all 1 ≤ l < l ′ ≤ n where i(σ l ) = i(σ l ′ ) ∨ k(σ l ) = k(σ l ′ ).Decoding such a sequence to a complete MAAP solution is NP-hard per the proof of Proposition 3.3.We therefore use heuristics for the decoding.
An MAAP solution Ω can easily be encoded as a permutation Σ by ordering the jobs according to their aisle access time r.Note that the concatenation of encoding and decoding is not the identity function.The decoding mechanism depends on which access policy is employed.First, we discuss MAAP-EX.
Given a permutation Σ, we assign each job in the given sequence to the AGV that is the earliest available (where ties are broken randomly).To this end, we maintain a list of AGVs sorted by the next time t k they are available to depart from the I/O station.We also save the next time a i each aisle is available, i.e., not blocked by an AGV.We take the next job j in the permutation and schedule it as early as possible, that is, the earliest time both aisle i(j) and an AGV are available.We then update our structures t k as well as a i , and proceed with the next job until all jobs are assigned.The whole procedure is outlined in Algorithm 1.
for l ← 1 to n do 5: k(σ l ) ← arg min q∈K {t q } ▷ Find first available AGV 6: Proof.We have to schedule n jobs.For each of these jobs, we need to find the next available AGV k, update its availability time t k , and re-insert it in the sorted list of AGVs.This is possible in O(log 2 (κ)) time, for example, by using an AVL tree.
We modify this procedure for MAAP-PA.The difference lies in how aisle access is managed.For this, we maintain two additional structures.The first is a pointer α(i) ∈ J, denoting the last job which increases a i , i.e., whose AGV will leave aisle i the latest out of all already scheduled jobs.The second is a pointer θ(j) ∈ J for each job j to the last job j ′ that is processed concurrently in the same aisle i(j) = i(j ′ ), j ′ < j.If there is no such job, i.e., there is no AGV in aisle i(j) closer to the front of the aisle than the AGV processing job j, then θ(j) = j.
Going through permutation Σ job by job, whenever a job j is to be assigned to an aisle that is currently occupied by another AGV, we try to process j concurrently.There might be multiple AGVs https://doi.org/10.1016/j.omega.2020.102204already in the aisle.We want to "nest" the current job inside the already busy aisle as long as this is possible without causing collisions and excessive waiting time by blocking the aisle exit.To store the jobs we try to process j concurrently with, we maintain a stack S.
Starting from j = α(i(j)) (i.e., the innermost job already in aisle i(j)), we check if j < j, i.e., if jobs j and j can be processed concurrently.If j ̸ = θ( j) and j < j, we place j on S and set j := θ( j) and start again with the new j.If j = θ( j), i.e., the outermost job in the aisle, and j < j, i.e., job j could potentially be processed at the same time as j and is the innermost such job, we schedule job j for aisle access at time r j = max{d t j + t k , rj} if job j is not delayed by more than 70% of j's processing time p j , i.e., if 0.7 • p j ≥ wj, where wj is the idle waiting time inside the aisle of the AGV processing job j caused by job j blocking the exit.If this is not the case, for example because we find j > j, we try again with the previous value j popped from stack S. Recall that the first time the aisle is available depends on the time the job θ( j) finishes.If we did not place the job and the stack is empty, we schedule job j as we would for the MAAP-EX.The procedure is outlined in Algorithm 2. Note that the "delay factor" of 70% in Line 13 is chosen empirically; in Section 5.2.1 we provide some more insight into this.Proposition 4.2.Algorithm 2 for MAAP-PA runs in O(n 2 ) time.
Proof.We have to schedule n jobs.For each of these, the stack S needs to be stepped through, which contains O(n) items.The proposition follows.
Example (cont.from Section 3.2) We apply both decoders to the permutation Σ = ⟨5, 4, 1, 3, 2⟩ for the instance from Section 3.2.Figure 3 depicts the resulting decoded schedules.In the MAAP-PA case, job 4 can be processed during job 5 and job 2 during job 3.
for l ← 1 to n do 6: k(σ l ) ← arg min q∈K {t q } ▷ Find first available AGV 7: if t k(σ l ) + d t σ l < a i(σ l ) and σ l < j then 9: S ← ∅ 10: while j ̸ = θ( j) and σ l < θ( j) do 11: Push j on stack S 12: j ← θ( j) 13: if 0.7 • p σ l ≥ wj then ▷ wj is the waiting time of job j caused by job σ l blocking the aisle 14: if θ( j) ̸ = j then 15: a i(σ l ) ← max{r σ l + p σ l , a i(σ l ) } 19: Update tj, wj for all j ∈ S to reflect change Accepted manuscript.Article published in Omega: The International Journal of Management Science available from https://doi.org/10.1016/j.omega.2020.102204 Note that both decoders are heuristics; by Proposition 3.3, exact procedures would take worst-case exponential time to decode a sequence unless P = N P .Figure 4 illustrates this for the MAAP-EX decoder (Algorithm 1).The depicted instance has κ = 2 AGVs, no driving times, and three jobs with processing time 1, 2, and 3, each in its own aisle.The upper Gantt chart shows the decoded MAAP-EX solution for the permutation ⟨1, 2, 3⟩.The solution depicted at the bottom of the figure respects the permutation ⟨1, 2, 3⟩ but improves on the makespan.It is actually optimal and is the decoded solution for the permutation ⟨1, 3, 2⟩ and for ⟨3, 1, 2⟩.

Large neighborhood search
LNS was first introduced by Shaw [37]; a more recent description and overview is given by Pisinger and Ropke [34].LNS has proven successful in solving difficult sequencing and scheduling problems [e.g., 30,22].We adapt it to MAAP as follows.
Algorithm 3 Large neighborhood search LNS works on permutations Σ, which are evaluated by using the decoders from Section 4.1.Starting from an initial solution, the current permutation Σ is improved via local search.Then the best solution found by local search is destroyed and repaired in a diversification phase.We restart the local search with this sequence and repeat the previous steps.Finally we return the best solution we found.The whole procedure is outlined in Algorithm 3.
The initial sequence is obtained by sorting the jobs by their processing time p j , i.e., by applying the longest processing time rule (LPT).Ties are broken randomly.
The local search considers solutions reached from the current incumbent by one of three moves.
Each of these can be indexed by two numbers (l, l ′ ) ∈ J × J.For each pair of indices, we try in the given order: • Switching the position of the two jobs σ l and σ l ′ .
• Moving the block of jobs beginning at l and ending at l ′ to the end of the permutation.
• Switching σ l and σ l ′ and reversing the order of all jobs between them (2-opt).
The local search is based on the first-fit principle, i.e., as soon as one of the moves for some (l, l ′ ) leads to an improvement over the incumbent solution, it is accepted.We iterate through l and l ′ in lexicographical order.Every permutation is evaluated by using the decoder described in Section 4.1.Once a neighbor is accepted, it replaces the current incumbent and the neighborhood search starts

Extensions
In the literature, many different objectives and problem variants are discussed for order picking problems in automated warehouses [e.g., 7].Our LNS is flexible enough to handle many different problem versions.Representatively, we present two specific aspects that are often considered particularly relevant in the literature [e.g., 12,38,35,14] in the following.
In Section 4.3.1,we extend the MAAP by due dates, i.e., each job is assigned a time by which it should be processed.In Section 4.3.2,we propose to use dual instead of single command cycles, i.e., we allow an AGV to first store and then retrieve an item on the same trip.The MIP models can be found in Appendix E.

Jobs with due dates
In addition to the other instance data, we have due dates b j ≥ 0, ∀j ∈ J.The goal is no longer to minimize the makespan but to minimize the maximum lateness L max = max (j,k,r,w)∈Ω {r + p j + w + d f j − b j }.A schedule remains feasible under the same conditions as before.We therefore have to change the LNS acceptance mechanism to consider the lateness instead of the makespan.The decoder can compute L max for a given solution without changing its asymptotic runtime as follows.
The decoder works by adding one job after another in the given sequence.Once a job is scheduled, we know its completion time and can look up the due date.Computing the difference gives us the lateness of the job.Algorithm 4 describes the MAAP-EX decoder such that it returns L max instead of the makespan.Note lines 4, 10, and 11.The same can be done analogously for the MAAP-PA decoder.

Dual command cycles
For dual command cycles, we need additional input data.For each job j ∈ J, let g j ∈ {0; 1} denote if job j is a storage (g j = 0) or a retrieval (g j = 1) request.We use G = {(j, j ′ ) ∈ J 2 |g j = 0 ∧ g j ′ = 1} to denote the set of possible dual command cycles.Moreover, let d jj ′ be the distance between jobs j ∈ J and j ′ ∈ J, and let p jj ′ be the combined processing time for each pair of storage and retrieval jobs (j, j) ∈ G in the same aisle (i(j) = i(j ′ )).
Our model extends feasibility as we do not force a return to the I/O point for all storage jobs j followed by a retrieval job j ′ .If the two jobs are in different aisles, we assume that an AGV can take the direct path, which takes time d jj ′ instead of d f j + d t j ′ .If the two jobs are in the same aisle, we can treat them as one job with time d t j to get to the aisle, processing time p jj ′ inside the aisle, and time d f j ′ to return to the I/O point.Clearly, these changes in the model require no change in LNS, but significant changes in the decoder.
When decoding a given job sequence, we consider dual command cycles in two places.
1. First, when a storage job j is directly followed by a retrieval job j ′ in the permutation Σ, we can just assign the two jobs conjointly to the next AGV to be available.However, this need not be beneficial, because another AGV could conceivably have processed the retrieval request while the first AGV is still busy with the storage request.However, this potential downside of combining requests really only matters if jobs j and j ′ are in two different aisles.Therefore, we assign the jobs to the same AGV only when they are in the same aisle (i(j) = i(j ′ )).
2. Second, when an AGV returns from a storage job and is assigned a retrieval job next, there is no downside.Since the AGV enroute to the I/O point is idle anyway, it is almost always advantageous to use it to process the retrieval request without returning to the I/O point first, even if the two requests are not in the same aisle.
In Algorithm 5, we see the MAAP-EX decoder adjusted accordingly.For the MAAP-PA decoder, the modifications are similar; however, we need to be careful when adding "nested" jobs (i.e., more than one AGV accesses the same aisle concurrently).If multiple jobs are processed at the same time in the same aisle by different AGVs and at least one of them is a dual command cycle job, we need to check that all pairs of involved jobs satisfy the "nestability condition" j < j ′ .This can be done without increasing the asymptotic runtime.An example of how the decoder works is given in Figure 5 for the example from Section 3.2.
Algorithm 5 MAAP-EX decoder with dual command cycles 1: procedure DECODEREXDUALCOMMAND(Σ) 2: ▷ Stores the current job on the AGV 4: for l ← 1 to n do 6: k(σ l ) ← arg min q∈K {t q } ▷ Find first available AGV 7: a i(σ l ) ← r σ l + p σ l ,σ l+1 10: else 13: if g q k(σ l ) = 0 ∧ g σ l = 1 then ▷ AGV enroute to I/O point after storage performs retrieval 14: else if a i(σ l ) = r q k(σ l ) + p q k(σ l ) then ▷ if aisle has not been blocked in the meantime 19: else ▷ the jobs cannot be combined -assign them sequentially 25: q k(σ l ) ← σ l

Computational study
The computational study is divided into three major parts.First, in Section 5.1, we describe our test bed.In Section 5.2, we tune and test our LNS heuristic to gauge its quality.In Section 5.3, we use our heuristic to derive a number of managerial insights on the ideal size and layout of very narrow aisle warehouses as well as access policies.

Benchmark instances and computational environment
Since the MAAP is a new problem, there are no established test data.We implement an instance generator that takes a number of parameters, namely the number of jobs, the number of AGVs, the number of aisles, a seed for pseudo-random number generation, the maximum length of an aisle (denoted as ℓ), as well as the maximum and the minimum driving time in the cross aisle (denoted as d and d, respectively).We then randomly draw for each job the aisle in which it is located uniformly from the set of aisles.Next, we randomly draw the duration of each job uniformly from [1, ℓ], using a different pseudo-random number generator that is initialized with the seed plus one.Finally, we draw for each aisle the driving time di uniformly from [d, d], where we round down di to the nearest multiple of 5, again using a different pseudo-random number generator initialized with the seed plus two.All jobs j ∈ J : i(j) = i in a given aisle i take driving time  We use this generator to obtain realistic instances.We assume that there is a strictly linear correlation between driving time and distance, and that the speed of the AGVs is uniform in the entire warehouse.We design the layout with the euro pallet in mind, which is 1.2 × 0.8 meters large.The short side points toward the aisle.An aisle itself is about 1.6 meters wide.This means that the distance between two aisles is 4 meters.For safety reasons, most AGVs do not drive faster than walking speed.We therefore assume a speed of 0.8 m/s.This means the driving time between two neighboring rack positions is 1 second.The driving time between two neighboring aisles is 5 seconds.The time to lift or place a pallet is roughly 30 seconds.This does not include the time it takes to lift the fork to high shelves.However, as we are only interested in the total processing time, we do not care whether the time is used to drive further into the aisle or to lift the fork to a higher shelf.The difference between the two only shows in the precedence constraints (i.e., in the order of the indices of the jobs).
For the dual command cycle instances, we randomly (coin flip) make each job either a retrieval or a storage job.The processing time p jj ′ of combined jobs is drawn uniformly from {max(p j , p j ′ ), . . ., p j + p j ′ }.The driving distance between two jobs d jj ′ is drawn uniformly randomly from {min(d f j , d t j ′ ), max(d f j , d t j ′ )}.We draw due dates uniformly randomly from {0, 1, ..., j p j |K| }.We set the following parameters: the minimum time in the aisle is equal to 30 seconds.The maximum driving time is equal to 5 seconds times the number of aisles in the warehouse.Similarly, the maximum processing time is 7 seconds times the number of aisles plus 30 seconds for lifting the object in the rack.The remaining parameters are chosen specifically for each experiment and described below.This choice of generator and parameters follows the principles laid out by Hall and Posner [18].
We implement LNS in C# 7.0.The default solver used to solve the models is IBM ILOG CPLEX 12.7.Tests are run on an x64 PC equipped with a 4 GHz Intel i7-6700K CPU and 64 GB of RAM.

Tuning and testing the LNS heuristic
Before using LNS to derive managerial insights, we first adjust its parameters for maximum performance and analyze its efficiency.In Section 5.2.1, we tune the decoders from Section 4.1, whose quality we evaluate in Section 5.2.2.In Sections 5.2.3 and 5.2.4,we investigate how much the individual components of LNS contribute to its efficacy and provide computational tests to evaluate its performance, respectively.Finally, in Section 5.2.5, we test the extensions of LNS from Section 4.3.

Decoder parameter
In a first experiment, we test how the quality of the MAAP-PA decoder (Algorithm 2) depends on the value we choose for the maximum amount we allow an inner job to delay an outer job.We test instances with 5 to 255 jobs in steps of 10, with 1 to 91 aisles in steps of 10, with 2 to 18 AGVs in steps of 4. For each of them we generate 10 random permutations and test the parameters 0% to 145% in steps of 5 percentage points.We get the optimal decoding by using the models in Section 3.3 and fixing the y variables to force the given permutation.The test concludes that the minimal average value of decoded solution cost is obtained for 70%. Figure 6 shows that for an increasing parameter value, there are substantial improvements up to 65%.Then we see a plateau up to 95%.Following that, any increase leads to visibly worse average solutions.Consequently, we set the decoder parameter to 70%.

Decoder quality
In the next experiment, we evaluate the quality of the decoders.We generate instances with 2, 4, 8, 12, and 16 AGVs and 1 to 17 aisles in steps of 4. We start with 3 jobs and increase the number of jobs by 4 until the optimal decoding using the MIP models with fixed permutation takes more than 1 minute.This turns out to be at most 25 jobs.We then generate 10 random permutations and decode them using the PA and EX decoders.This gives us values EX and PA for the decoder and EX-OPT and PA-OPT for the optimal decoding for each strategy.Next we compute the errors: this gives us 27% for PA relative to PA-OPT and 9% for EX relative to EX-OPT.Since we tested 10 random permutations for each instance we also compare the minimum of these 10 for PA to the same minimum for PA-OPT which gives us an error of 15% and 3% for the analogous value for EX.The error for PA drops to 7% once we only look at instances that have at least twice as many jobs as AGVs.

LNS component test
In this experiment, we determine the contribution of each neighborhood as well as the improvement in each iteration.We test instances with 5 to 75 jobs in steps of 10, 1 to 41 aisles in steps of 5 and 2 to 22 AGVs in steps of 5.For each instance, we test 1 to 20 iterations of LNS using any combination of the neighborhoods.
We find no substantial improvement (only 0.2%) from iteration 10 to iteration 20 compared to the improvement of 2% from iteration 1 to iteration 10.Details are in Figure 7. Regarding the neighborhoods, we find that including the switch neighborhood gives an average improvement of 2.65%, the block neighborhood an improvement of 1.52%, and the 2-opt neighborhood an improvement of 1.05%.All of these results are statistically significant if one controls for the lower bound of the instance.

Quality of LNS
We use three different instance sets to test our LNS heuristic.The first set consists of 13 small instances with 10 jobs, 5 AGVs and 1 to 13 aisles.This is about the maximum instance size that CPLEX can still solve with reasonable resources.Adding just one additional AGV or job leads to at least some instances where CPLEX cannot prove optimality within a time limit of two hours.For larger instances, we propose the following lower bound (LB).It is the maximum of two values.The first is the total workload divided by the number of AGVs, rounded up, i.e., ⌈ j∈J p j /κ⌉.The second differs depending on the access policy.For MAAP-EX, it is the maximum workload in one aisle plus the driving time to and from that aisle, i.e., max i∈I j∈J: i(j)=i p j + dt i + df i , where dt/f i denotes the driving time from/to the I/O point to/from aisle i.For MAAP-PA, it is the longest job in any aisle plus the time to drive to and from it, i.e., max j∈J {d t j + d f j + p j }.Tables 3 and 4 show the results for the small instances under an exclusive and parallel access policy, respectively.In all but 6 out of 26 instances, LNS found the optimal solution.The average relative optimality gap over all small instances is 0.8%.The runtime is negligible in all cases, never exceeding 20 milliseconds, whereas CPLEX took several seconds of CPU time in some cases.The second instance set contains 10 medium-size problems with 30 jobs, 10 AGVs, and 3 to 30 aisles.These instances are already too large for CPLEX to prove optimality within two hours.In

Insights into optimal design and operation of a VNA warehouse
We conduct three experiments to gain managerial insights into how best to operate very narrow aisle warehouses.We investigate the main factor contributing to low utilization of AGVs, the effect of different access policies, and the effect of the shape/layout of the storage facility.

Access policy
This first experiment tests three different access strategies (PA, EX, and NC) each on the same instances with 100 jobs, 2, 6, 10, 15, 20, and 35 AGVs, and 2, 5, 10, 20, and 50 aisles.NC stands for no collisions.This corresponds to a classic wide-aisle warehouse, where AGVs can pass each other inside the aisles.We model it as a standard parallel machine scheduling problem, which CPLEX is able to solve optimally for our instances.For reference, the MIP model is in Appendix D. As NC is a relaxation of PA and EX, it is expected to lead to improvement compared to the very narrow aisles policies.The question is whether the improvement is large enough to outweigh the additional cost of larger facilities and longer driving times.
The average utilization, i.e., the percentage of time that AGVs spend doing actual work as opposed to waiting for aisle access, is displayed in Figure 8.For comparison, we also include the best result we get from a set of different priority rules with exclusive and parallel access.The priority rules are: shortest processing time within aisle, shortest processing time including driving times, longest processing time within aisle, longest processing time including driving times.We obtain a solution from these by applying the decoder to them.Note that, to avoid clutter, we only print the result of the best priority rule in the figure (which may differ from instance to instance).
We find that there is a cut roughly where the number of AGVs equals the number of the aisles.After that point the solutions fall into two groups.One group is the priority rules.The other group consists of NC, EX, and PA, between which we are unable to find major differences.However, we get the unsurprising ordering NC is better than PA is better than EX.We also find that the PA priority rule consistently beats the EX priority rule.In the region where there are more AGVs than aisles, PA is still close to the NC strategy; however, the EX policy is significantly worse.For the largest mismatch between AGVs and number of aisles, EX is even outperformed by the PA priority rule.
These findings can be summarized as: the more AGVs and the fewer aisles, the more one should focus on the access strategy.The PA accesses strategy works well in these cases.On the other hand, if there are many aisles and few AGVs, one should focus on optimizing the job sequence, as it has a much greater impact than the access strategy.While NC outperforms PA, it does not do so by much, and this is most likely offset by the additional driving times to the aisles in a wide-aisle warehouse, which we ignore in this test.Therefore an optimized PA narrow aisle system might outperform a classic wide-aisle warehouse.

Shape of the facility
Our final experiment tests for the best shape of a very narrow aisle warehouse.We use instances with 90, 100, and 110 jobs; 5 to 19 AGVs in steps of 2; and 2520 individual storage slots in all aisles in  total, in all the possible whole numbered divisions into number of aisles and length of aisles.We set the maximum driving time to an aisle equal to the number of aisles times the driving time per aisle (5 seconds).This covers the horizontal width of the storage facility.The vertical length is modeled by the maximum work time within an aisle.We set the length such that the total area of the storage facility remains constant.Consequently, the maximum processing time inside an aisle is 2520 divided by the number of aisles.Figure 9 plots the average of the logarithm of the makespan (cost) against the logarithm of the number of aisles once for 5 AGVs and once for 19 AGVs.Note that the greater the number of aisles, the wider the warehouse (that is, the longer the cross aisle) and the shorter the individual aislesthe total area is always the same.We find (not only in the depicted cases) a unique minimum in dependence of the number of aisles.The lower part of Figure 9 plots these numbers of aisles where the minimum is attained against the number of AGVs.We see that the optimal shape is almost independent of the number of aisles in the PA case.We find a strong correlation for the EX strategy.This result can be explained by the same logic as the results in 5.3.1:The EX strategy has much greater problems when there are fewer aisles than there are AGVs, as only as many AGVs can work in aisles as there are aisles.It seems advisable to keep this ratio in mind when designing new very narrow aisle warehouses.In particular, our experiments strongly suggest that it is not a good idea to build facilities with a short cross aisle; this leads to an almost exponential increase in blockages and makespan.

Conclusion
We study the problem of scheduling AGVs to fulfill retrieval requests in aisles so narrow that AGVs must observe non-crossing constraints.We suggest two access policies, exclusive and parallel, and develop mixed-integer programming formulations.We show strong NP-hardness for the problem and for multiple sub problems.We present a large neighborhood search heuristic for both problem variants and find that even instances with hundreds of jobs can on average be solved to near-optimality within less than ten minutes.This is in stark contrast to the commercial MIP solver, which struggles to find useful solutions within two hours in many cases.
For operators of very narrow aisle warehouses, or companies planning to erect them, we derive the following take-home messages.
• We find that, from an operational viewpoint, there is little advantage in wide aisles over very narrow aisles when using the parallel access policy, because the advantage of no blockages inside the aisles is offset by the longer driving times.This indicates that very narrow aisle warehouses can generally achieve throughput levels close to, if not in excess of, those of classic warehouses.
• We find that for optimal AGV utilization, fewer AGVs than aisles are recommended.If many AGVs are employed, the parallel access policy can help to drastically increase utilization.Therefore, while parallel access is harder to manage, it may well be worth the additional effort due to better efficiency.
• It is dependent on the ratio of aisles to AGVs whether there is more to gain from a switch to a more complicated parallel access strategy and use a priority rule or to optimize the order of access and use the simpler exclusive access strategy.
• Finally, for the exclusive access strategy, it is better to have a long cross aisle and short narrow aisles, especially when there are many AGVs.The parallel access strategy is less sensitive to the number of AGVs.Nonetheless, it is not recommended to have a short cross aisle and very long narrow aisles.
Our solution techniques may be extended to different layouts in the future, e.g., with additional cross aisles.Optimizing the position of the I/O station, or use of multiple I/O stations, bears some potential.It is an open question whether allowing AGVs to drive farther into aisles to allow parallel access without respecting the j < j ′ condition can significantly improve system performance.Moreover, modelling the problem such that positive safety distances between AGVs are observed may be worthwhile.Finally, integrating other planing steps, e.g., storage assignment, might yield additional potential.Proof.We reduce 3-SAT to our problem as in Proposition 3.1.Given a 3-SAT formula (a 1 ∨ a 2 ∨ a 3 ) ∧ ... ∧ (a 3k−2 ∨ a 3k−1 ∨ a 3k ) with variables x 1 , ..., x m , we model a choice of literal for each clause such that it is satisfied.Then we add jobs to make sure we never have contradictory choices, i.e., x i and ¬x i .
The best way to explain the instance is to first introduce a number of gadgets, see Figure 11.A complete instance is presented in Figure 12.
The first is an XOR gadget.It consists of four jobs in three aisles processed by two AGVs, two jobs of length (that is, processing time) 2 on each AGV and the same aisle and two jobs of length 1 on each AGV each with its own aisle.One AGV first has to do the short and then the long job, the other AGV has to do first the long and then the short job.The given permutation demands that the second long job follow the first long job in the aisle.If both AGVs start their first job at the same time, there is a conflict that can either be resolved by the second long job starting later or the first long job waiting for the second long job to finish.This gadget can be used to represent a simple yes or no decision, e.g. a literal or variable being true or not.
The second gadget is a mechanism to transfer the decision in one XOR-gadget to multiple AGVs.The transfer gadget contains four jobs of length 1 on two AGVs k 0 and k 1 each with two jobs and they are all on the same aisle.The order of the jobs in the aisle imposes that the two AGVs must enter the aisle in order ⟨k 0 , k 1 , k 1 , k 0 ⟩.Therefore, AGV k 1 , the "copy AGV", cannot enter the aisle before AGV k 1 , the "input AGV".This gadget could also be called maximum gadget, as the second job for each AGV ends at the same time.This way we can transfer movement of one AGV to another.The other AGV becomes a copy with respect to the past of the other AGV.
The third gadget takes three XOR gadgets and two transfer gadgets to build a clause gadget.This corresponds to the function of the long jobs in the proof of Proposition 3.1.We can take one AGV k 0 and have it go through three XOR-Gates.Now each XOR gate represents the choice for one literal in the 3-SAT instance.Giving k 0 priority in an XOR gate means we choose the corresponding literal to satisfy the clause.If no decision gives k 0 priority the clause is not satisfied.This then corresponds to AGV k 0 having the longest possible processing time.Between the XOR gadgets we add transfer gadgets to make sure that independent of the decision in the early XOR gadgets we still need to make a choice in the later gadgets.Adding a final job of appropriate length at the end for k 0 makes the decision critical.Critical means that at least one decision must give k 0 priority or the processing time of k 0 pushes the makespan over the makespan border.Note that to satisfy the clause we only care about the first literal satisfying it.
We now need a mechanism to avoid allowing one literal to be true while at a different place the negation is also true.This corresponds to the function of the short jobs in the proof of Proposition 3.1.We achieve this with the final conflict gadget.
Let AGVs k 1 and k 2 correspond to conflicting literals from the XOR in the respective clause gadgets.Now we add a job of appropriate length behind k 1 or behind k 2 such that both k 1 and k 2 finish at the same time if the choice of the literal XOR in both clauses come to the same result.Then we add a XOR gadget between k 1 and k 2 and add final jobs of a length to make the decision critical for the makespan.
The conflict for the XOR arises only if both input XORs make the same choice.Therefore the length of the final job is chosen such that if and only if contradicting literals are both chosen to satisfy their clause, the makespan border is exceeded.Note that this is only true for the first literal (i.e., XOR) in time from each clause chosen to satisfy that clause.This is, however, not a problem because we only need one literal per clause to be true without conflict.
One literal may be used in its negated form in multiple different clauses.In that case, we need a different AGV for each of these possible conflicts.To this end, we make multiple copies of the decision of one literal.We do this with the transfer gadget.Then we can create an AGV for each pair of possibly conflicting literals, and our reduction is done.
The instance consists of an AGV for each clause and an AGV for each pair of contradicting literals.

(
MAAP-EX) Minimize C EX = max j∈J r j + p j + d f j

Figure 6 :
Figure 6: Average cost of random decoded permutations depending on fitting parameter.

Figure 7 :
Figure 7: Objective value for different numbers of iterations in LNS.

Figure 8 :
Figure 8: AGV utilization (productive time divided by total time) is on the Y-axis.The number of aisles is on the X-axis.Each chart shows the results for a different number of AGVs.

Figure 9 :
Figure 9: Makespan per instance versus the ratio of number of aisles to length of aisles.

Figure 11 :
Figure 11: The gadgets: Rows are AGVs, the columns correspond to time inside an aisle; rectangles denote jobs, with the number inside signifying the aisle, and the number in brackets the the order in which the jobs may access the aisle.

Table 1 :
Notation for the MIP models.Accepted manuscript.Article published in Omega: The International Journal of Management Science available from https://doi.org/10.1016/j.omega.2020.102204 Accepted manuscript.Article published in Omega: The International Journal of Management Science available from https://doi.org/10.1016/j.omega.2020.102204

Table 3 :
Results for the small EX instances.

Table 4 :
Results for the small PA instances.