Efficient Graph-Based Multi-Story Path Planning with Optimized Elevator Selection for Indoor Delivery Robots

Abstract

Multi-story path planning (MSPP) for indoor delivery robots presents unique challenges in modern logistics systems, particularly in efficiently handling multiple deliveries across different floors. This paper proposes a graph-based path planning algorithm that optimizes delivery routes in multi-story buildings while maintaining computational efficiency. The algorithm, with a complexity of O(|E|log|V|), integrates three key components: (1) a floor-based parcel grouping strategy, (2) an optimized Dijkstra-based path planning system, and (3) an efficient elevator selection mechanism. The modular design allows for adaptability to diverse building layouts and logistics scenarios. Evaluated in a 15-story simulation with varying parcel counts (n = 1 to 7), the algorithm demonstrated minimal runtime increase (1.28 s to 1.35 s) while ensuring optimal path selection. Delivery distances ranged from 48 m (single-parcel) to 126 m (seven parcels), demonstrating the system’s scalability and efficiency in complex multi-story environments. Unlike traditional methods such as A*, the proposed approach guarantees optimality while effectively addressing vertical navigation challenges. These results validate its practical applicability in smart building environments and modern logistics systems, offering a robust solution for real-world delivery challenges.

1. Introduction

The rapid growth of e-commerce has made last-mile delivery using mobile robots a crucial challenge in modern logistics [1,2]. Recent studies indicate that autonomous delivery robots can significantly improve efficiency and reduce operational costs [3,4]. However, the increasing complexity of indoor environments, particularly in multi-story buildings, presents unique challenges for autonomous navigation and delivery optimization [5].

Path planning algorithms have traditionally focused on single-floor navigation scenarios. While algorithms like A* [6] and Dijkstra [7] have proven effective for two-dimensional environments, they face significant limitations in multi-story buildings [8]. Recent surveys highlight that vertical navigation and elevator integration remain critical challenges in indoor robotics [9,10]. For example, A* algorithm’s heuristic-based approach faces fundamental challenges in multi-story environments, particularly when incorporating elevator selection. This limitation becomes even more pronounced when attempting to integrate elevator waiting times and floor transition costs into the heuristic function, often leading to suboptimal path selection and inefficient resource utilization in real-world scenarios.

The emergence of machine learning approaches, particularly deep reinforcement learning [11,12], has introduced new possibilities for robot navigation. However, these methods often require significant computational resources and may lack the reliability needed for commercial delivery applications [13]. Furthermore, they require direct communication between robots and elevator systems for state observation and action execution, which poses significant practical challenges. Such integration often demands proprietary access to elevator control systems, requirements that are often unfeasible due to security concerns and restricted access to elevator manufacturers’ systems in real-world deployments.

To address these challenges, we propose a graph-based Multi-Story Path Planning (MSPP) algorithm that introduces three key innovations:

• A memory-efficient weighted graph representation that simplifies multi-floor connectivity while maintaining computational scalability.
• A novel elevator function for effective vertical navigation, optimizing floor transitions and reducing waiting times.
• An intelligent parcel grouping strategy that streamlines delivery sequencing across multiple floors.

Unlike the traditional Dijkstra’s algorithm, which exhaustively explores all possible paths from the source to multiple destinations across floors, our grouping strategy allows for localized path calculations within each floor. This significantly reduces the computational complexity by eliminating the need to explore unnecessary inter-floor paths, while maintaining delivery optimization.

To illustrate our approach, Figure 1 shows an example of the underlying layer structure for a 15-floor building. Each node in the graph contains essential information including node ID, connectivity information, edge values, and coordinates. The graph uses destination nodes to represent customer doorsteps and elevator nodes to represent elevator locations, providing an efficient representation of the building’s structure. Figure 2 demonstrates how these underlying layers are stacked to create a complete multi-story representation. Instead of using vertical edges to connect elevator nodes directly, we introduce an elevator function $E_{a\to b}=(a, b)$, where a represents the current floor and b represents the destination floor. This approach provides more flexibility in handling elevator transitions while maintaining the graph’s structural clarity.

Our approach builds upon recent advances in hierarchical path planning [14] and graph-based navigation systems [15], while introducing novel solutions for elevator integration and delivery optimization. The proposed method has been evaluated in a 15-story building environment, demonstrating robust performance with varying numbers of parcels.

The remainder of this paper is organized as follows: Section 2 reviews related work in path planning and multi-story navigation. Section 3 formally defines the problem and outlines our key assumptions. Section 4 details the proposed Algorithm 1 and its implementation. Section 5 provides experimental results and a performance analysis. Finally, Section 6 concludes with a discussion of practical applications and future research directions.

2. Related Work

2.1. Path Planning Algorithms

Path planning algorithms are generally categorized into global path planning and local path planning approaches [16]. Global path planning, which is the focus of this paper, assumes complete environment knowledge beforehand [6,7], enabling comprehensive route optimization in known spaces such as indoor building layouts. In contrast, local planning relies on real-time sensor data for navigation [9,10,17] Traditional approaches like Dijkstra [7] and A* [6] have been fundamental in path planning, with their computational complexity thoroughly analyzed.

Building upon traditional path planning algorithms, hierarchical approaches [18] improve computational efficiency by grouping similar regions and allowing path planning algorithms to skip detailed explorations within these regions, effectively reducing the search space. These methods have shown significant performance improvements in complex environments by abstracting the search space into different levels of granularity [19]. Our approach similarly leverages this concept by treating each floor as a distinct region, avoiding the need for an exhaustive search across all possible inter-floor combinations.

Recent developments have focused on machine learning approaches [20], particularly deep reinforcement learning [12,13], which have shown promising results in handling dynamic environments [11]. However, as discussed in Section 1, these approaches face numerous challenges in real-world multi-story deployments due to elevator system integration requirements and security concerns. Graph-based methods have emerged as an efficient alternative for structured indoor environments [21], offering a more practical solution that can operate without requiring direct elevator system integration or real-time state predictions [22].

2.2. Multi-Story Delivery Systems

Multi-story delivery systems present unique operational challenges beyond traditional single-floor robotics applications. The integration of robots with the building infrastructure, particularly elevators, has emerged as a crucial research area [23]. Recent surveys [24,25] highlight several key challenges in autonomous delivery systems, including route optimization [26] and system integration [27]. The complexity of coordinating multiple robots in multi-floor environments [28] and optimizing delivery schedules [29] remains an active area of research.

Studies in robotic Mobile Fulfillment Systems (RMFS) have shown that heterogeneous robot fleets can significantly improve operational efficiency [30], particularly in scenarios involving elevator scheduling and multi-delivery coordination. Our graph-based path planning algorithm addresses these challenges while maintaining practical feasibility [31,32], offering a robust solution for complex multi-story delivery operations.

Current research trends indicate a move toward more integrated approaches that combine traditional path planning with learning-based methods [33]. These hybrid systems aim to leverage the reliability of classical algorithms while incorporating the adaptability needed for complex multi-story environments. However, challenges remain in developing truly efficient and scalable solutions for real-world applications [34].

3. Problem Definition

3.1. Multi-Dimensional Navigation Parameters

Traditional path planning algorithms such as A* and Dijkstra require two distinct positions as input data to identify the shortest path within a two-dimensional environment [6,7]. However, for multi-story path planning, it is necessary to add parameters representing vertical transitions between floors [8]. As the driving environment changes from a two-dimensional to three-dimensional structure, the absence of floor parameters results in distorted paths between floors [5]. Furthermore, recent studies have shown that optimizing paths based solely on two locations (start and goal positions) is insufficient for multi-story environments [35].

3.2. Start-Goal Position Constraints

In the context of last-mile delivery services [1,4], the mobile robot must return to a designated station point after completing deliveries to recharge or collect new parcels from staging areas. This return-to-start requirement creates a unique constraint where the start and goal positions are identical, contrary to the assumptions of traditional path planning algorithms [16]. While this return point could theoretically be positioned at any accessible location within the building (e.g., charging stations or staging areas on different floors), for systematic experimental validation of our 15-story test environment, we specifically consider scenarios where robots start from and return to nodes near the ground floor entrance. This experimental design choice enables a comprehensive testing of vertical navigation capabilities across the full range of floors (1st to 15th floor).

A key challenge in our approach is handling the identical start and goal positions, as illustrated in Figure 3. Unlike traditional path planning problems where the start and goal positions differ, our algorithm must efficiently handle these return trips while considering practical operational requirements such as battery management and parcel collection. The global planner receives information about each parcel’s destination (specifically, the destination floor and node) and the total number of parcels as input data.

3.3. Delivery Sequence Optimization

Prior to the commencement of the delivery service, the global planner must optimize the sequence of deliveries [36]. Recent research in delivery robotics [3] has shown that the efficiency of multi-story deliveries heavily depends on the following:

• The efficient grouping of deliveries by floor;
• Optimal elevator selection and scheduling;
• The minimization of unnecessary floor transitions.

The global planner must determine the optimal route considering these factors, as this initial path plan serves as the primary reference for the mobile robot’s navigation within the building [20]. The overall structure of our Algorithm 1 is shown in Figure 4. The algorithm takes parcel information as input and processes it through hierarchical layers, applying the Dijkstra algorithm at each level while maintaining elevator connectivity.

3.4. Elevator Integration

The algorithm must determine which elevator to take at any given point and inform the robot of the necessary next steps [23]. Two specific challenges arise in this process:

• Buildings typically contain multiple elevators, requiring the mobile robot to identify and select the nearest elevator to optimize the path.
• The robot must determine the correct elevator selection based on both current location and delivery destinations.

To address these challenges, we introduce the elevator function $E_{a\to b}=(a, b)$, where a represents the current floor and b represents the destination floor. For example, when a robot on the 3rd floor needs to deliver parcels to the 7th floor, the function $E_{3\to 7}$ is invoked. This function considers several practical constraints, as follows:

• Elevator Availability: The function maintains a list of available elevators on the current floor a and evaluates their proximity to the robot’s current position.
• Floor Connectivity: Not all elevators may serve all floors, requiring the function to consider only elevators that connect both a and b floors.
• Path Optimization: When multiple elevators are available, the function selects the one that minimizes the total path length, considering both the distance to reach the elevator and the distance from the elevator to the delivery point on floor b.

3.5. Local–Global Planning Integration

The global planner must transmit the generated plan to the local planner in a format that enables real-time navigation [37]. Recent advances in robot navigation have emphasized the importance of seamless integration between global and local planning systems [38], particularly in dynamic indoor environments where obstacle avoidance and human interaction must be considered [34].

4. Solution

The proposed MSPP (Multi-Story Path Planning) algorithm introduces a novel integration of hierarchical Dijkstra’s algorithm with an elevator function to efficiently address path planning challenges in multi-story buildings. Our approach combines the computational efficiency of hierarchical path decomposition with an intelligent elevator selection mechanism, enabling optimal route planning across multiple floors while maintaining practical feasibility.

4.1. Graph-Design

4.1.1. Weighted Graph Representation

In graph theory [39], the shortest paths are typically calculated using directed and weighted graphs. Our approach utilizes weighted graphs to represent indoor environments, offering superior memory efficiency and computational performance compared to grid-based methods. In indoor environments, paths are not strictly governed by directional rules. Thus, the edges in the graph represent only traversable paths, and their weights correspond to the distances between nodes. Let $G=(V,E)$ represent the graph, where V is the set of vertices (nodes), and E is the set of edges. Each vertex represents a location the robot must visit, while edges represent the relative distances between these locations. This weighted graph significantly reduces memory usage, particularly in large, multi-story environments.

4.1.2. Parameters

To adapt Dijkstra’s algorithm for the Algorithm 1, several additional parameters are introduced. The floor parameter, denoted as $f_n$, represents the destination floor and its hierarchical weight, where $n=\{1, 2, 3,\cdots \}$. This parameter is essential for coordinating vertical movements. The input parameter, $i_n=(v_n, f_n)$, combines node and floor information, where $v_n$ is the node and $f_n$ is the floor. Parcel information encoded as QR codes stores this data, enabling efficient parcel sorting and route optimization. Additionally, elevator nodes, denoted as $el{e}_n$, are added to the graph $G=(V,E)$ to facilitate vertical movement. While $el{e}_n$ and $v_n$ are both vertices, elevator nodes are distinguished by their role in inter-floor connectivity. These parameters collectively enable the algorithm to handle the complexities of multi-story environments effectively.

4.2. Hierarchical Dijkstra Implementation

4.2.1. Grouping Mechanism

The Algorithm 1 begins by processing multiple parcel inputs $i_n$. Let I denote a set of parcel information $I=[(v_6, f_4),(v_2, f_7),(v_3, f_1),\cdots ]$. Initially, the input data $i_n$ are grouped into delivery groups $D_n$ based on their floor parameter $f_n$, ensuring that nodes sharing the same floor are grouped together, as shown in Figure 5. For each delivery group, the algorithm applies Dijkstra’s algorithm to compute optimal paths. These delivery groups $D_n$ serve as hierarchical input layers for our modified Dijkstra’s algorithm. Each $D_n$ represents a distinct floor-level subgraph, allowing the hierarchical Dijkstra implementation to process path planning efficiently by decomposing the multi-story navigation problem into manageable floor-specific components.

4.2.2. Hierarchical Dijkstra

The hierarchical Dijkstra algorithm traditionally improves efficiency by grouping similar regions and skipping the detailed exploration within these regions. In our approach, we leverage this concept by treating each floor as a distinct region with shared characteristics. The algorithm divides the environment into distinct layers based on floors, treating each floor as an independent subgraph. Weight values are assigned to represent inter-floor transitions, allowing vertical movements to be managed as transitions between layers. This separation of horizontal and vertical movements reduces computational complexity and improves memory efficiency. The method allocates missions for each floor based on input data I. After exploring each floor, the optimized paths are stored in layers. By isolating vertical transitions and utilizing the floor-based hierarchical structure, the algorithm achieves significant efficiency improvements in handling multi-story environments, as it can skip unnecessary path calculations in regions (floors) that share similar characteristics.

4.3. Elevator Function Integration

Elevator Fuction Description

However, elevators operate in real-time with movements that are difficult to predict accurately. Rather than connecting floors directly with static edges, we introduce an elevator function to handle the dynamic nature of elevator transitions and their associated floor-specific weights. This approach enables our system to adapt to the varying states of elevators and their impact on inter-floor movement costs. Each node in our graph maintains information about elevator states, connectivity, and the location of the nearest elevator. When the elevator function identifies the optimal elevator for transition, MSPP can creates a path to the corresponding elevator node based on this stored information. Once the robot reaches the elevator node, the elevator function guarantees the transition to the target floor by coordinating with the building’s elevator system.

Figure 6 illustrates the hierarchical structure and the role of elevator nodes in connecting layers.The GetSuccessors function is a crucial component of the Algorithm 1. It processes delivery groups and computes shortest paths for each group using Dijkstra’s algorithm. This function begins by initializing the necessary data structures, including the distance and predecessor information for each node. For each delivery group $D_n$, the function iterates through the nodes and calculates the shortest paths, storing the results in $Pat{h}_n$. Additionally, it integrates elevator nodes into the paths, ensuring seamless vertical transitions between floors. The function assigns weights to each path segment and appends the results to the corresponding hierarchical layer. At the final step, each path’s endpoint is connected to the nearest elevator node, preparing the data for subsequent processing by the GetSuccessors2 function.

Figure 6. Hierarchical structure of the Algorithm 1, showing layer separation and elevator node connectivity.

Figure 6. Hierarchical structure of the Algorithm 1, showing layer separation and elevator node connectivity.

Algorithm 1 MSPP

1:   function Grouping($i_n=(v_n, f_n)$) 2:       $I\leftarrow [i_1, i_2, i_3, i_4,\dots ]$ 3:       Open $\leftarrow I$, $D_{\mathrm{group}}\leftarrow \varnothing$ 4:       while Open $\ne \varnothing$ do 5:           for $i_n\in I$ do 6:              if $\mathrm{group}=f_n$ then 7:                $D_n\leftarrow i_n$ 8:              else 9:                continue 10:            end if 11:         end for 12:     end while 13:     return $D_{\mathrm{group}}\leftarrow [D_1, D_2, D_3,\dots ]$ 14: end function 15: function GetSuccessors($D_{\mathrm{group}}, G=(V,E)$) 16:     Successors $\leftarrow D_{\mathrm{group}}$, $\mathrm{Layer}\leftarrow \varnothing$, $\mathrm{Path}\leftarrow \varnothing$ 17:     while Successors $\ne \varnothing$ do 18:         for $D_n\in D_{\mathrm{group}}$ do 19:            Add Weight Value to ${\mathrm{Path}}_n$ 20:            $\mathrm{dist}\left(v_n\right)\leftarrow \varphi$, $\mathrm{pred}\left(v_n\right)\leftarrow \varphi$ 21:            for $v_n\in D_n$ do 22:                if $\mathrm{dist}\left(v_n\right)<\mathrm{pred}\left(v_n\right)$ then 23:                    Add $\mathrm{dist}\left(v_n\right)$ to ${\mathrm{Path}}_n$ 24:                    $\mathrm{pred}\left(v_n\right)\leftarrow \mathrm{dist}\left(v_n\right)$ 25:                else 26:                    $\mathrm{pred}\left(v_n\right)\leftarrow \mathrm{dist}\left(v_n\right)$, $\mathrm{dist}\left(v_n\right)\leftarrow \varphi$ 27:                end if 28:            end for 29:            Add ${\mathrm{ele}}_n$ to ${\mathrm{Path}}_n$ 30:         end for 31:     end while 32:     return $\mathrm{Layer}\leftarrow [{\mathrm{Path}}_1,{\mathrm{Path}}_2,{\mathrm{Path}}_3,\dots ]$ 33: end function 34: function GetSuccessors2(Layer) 35:     Successors2 $\leftarrow \varnothing$ 36:     for $j\leftarrow 0\mathrm{to}n$ do 37:         sort Layer 38:         for ${\mathrm{Path}}_n\in \mathrm{Layer}$ do 39:            Add ${\mathrm{ele}}_n-1$ to ${\mathrm{Path}}_n$ 40:            if $\mathrm{Layer}=\varphi$ then 41:                Add ${\mathrm{Path}}_1$ to Successors2 42:                Successors2 $\leftarrow \mathrm{starting}\mathrm{position}$ 43:            else 44:                Add ${\mathrm{Path}}_n$ to Successors2 45:                ${\mathrm{ele}}_n\leftarrow {\mathrm{ele}}_n-1$ 46:            end if 47:         end for 48:     end for 49:     return Successors2 50: end function

4.4. Algorithm Complexity and Validation

The computational complexity of the Algorithm 1 is primarily determined by the hierarchical Dijkstra implementation. By isolating vertical transitions and using weighted graphs, the algorithm achieves significant improvements in scalability and memory usage. The hierarchical structure allows the algorithm to handle multi-dimensional path planning efficiently, even in complex environments. The use of elevator nodes and floor weights ensures that the algorithm maintains optimality in path computation. Compared to traditional methods, the Algorithm 1 demonstrates enhanced performance, particularly in large-scale multi-story environments.

5. Experiment

To evaluate the performance of the proposed Algorithm 1, we conducted experiments in a graph-based environment representing a 15-story building. The evaluation included scenarios with varying numbers of parcels, denoted as $n=1, 3, 5, 7$. For each scenario, the algorithm computed the shortest paths while optimizing delivery sequences and integrating elevator usage.

5.1. Evaluation Setup

The building environment was represented as a weighted graph with nodes corresponding to delivery destinations and edges indicating traversable paths. Input data, I, contained parcel information including node and floor numbers. The graph structure, weighted edges, and elevator nodes were tailored to the experiments to ensure realistic conditions.

5.2. Results and Analysis

Figure 7 illustrates the paths generated by the Algorithm 1 for varying numbers of parcels. Cases (a), (b), (c), and (d) represent scenarios with n = 1, 3, 5, 7. In these path visualizations, blue lines indicate upward paths from the starting position to delivery points, while red lines represent downward paths as the robot returns from the highest floor delivery point. This color-coded representation helps visualize the complete delivery sequence, from the initial ascent to the final descent.

The input data for these scenarios were as follows:

• (a): $I=\left[\right(v11, f7\left)\right]$;
• (b): $I=\left[\right(v2, f2), (v4, f7), (v1, f10\left)\right]$;
• (c): $I=\left[\right(v9, f1), (v10, f3), (v6, f7), (v7, f9), (v1, f14\left)\right]$;
• (d): $I=\left[\right(v4, f3), (v7, f3), (v4, f7), (v6, f7), (v2, f15), (v7, f15), (v11, f15\left)\right]$.

These scenarios were designed to validate different aspects of the algorithm: Case (a) demonstrates the basic path planning capability with a single parcel, verifying optimal elevator selection and return path generation. Cases (b) and (c) test the algorithm’s performance with multiple parcels distributed across different floors, validating its ability to find the nearest elevators, optimize delivery sequences, and efficiently return to the starting position. Case (d) specifically evaluates the algorithm’s efficiency in handling multiple deliveries to the same floor, ensuring optimal path planning even when multiple parcels share destination floors.

The algorithm demonstrated its ability to efficiently group parcels by floor and optimize both horizontal and vertical movements. Elevator nodes were seamlessly integrated into the paths, as seen in the transitions between floors.

Figure 8 shows the potential range of total distances for scenarios with different numbers of parcels and the corresponding distances achieved by the Algorithm 1. For example, when $n=5$, the total travel distance ranges from 0 m (when all five delivery points are at the starting position $(v_1, f_1)$) to 103 m (when deliveries must be made to consecutive highest floors with destinations $i_1=(v_1, f_{11})$, $i_2=(v_1, f_{12})$, $i_3=(v_1, f_{13})$, $i_4=(v_1, f_{14})$, $i_5=(v_1, f_{15})$). Unlike traditional single-destination path planning, the optimal travel distance can vary significantly when multiple delivery points must be visited, and the black line in Figure 8 represents the actual travel distances achieved in the test cases shown in Figure 7. The results indicate that the algorithm consistently minimized travel distances, even with increasing delivery complexity.

Table 1. Comparison of result data for each case.

Case	Runtime	Stack Size	Total Distance	Elevator
$n=1$	1.28 s	10	48 m	2
$n=3$	1.30 s	20	73 m	4
$n=5$	1.33 s	50	103 m	5
$n=7$	1.35 s	100	126 m	4

summarizes the runtime, stack size, total distance, and elevator usage for each case. Even with an increasing number of parcels, the runtime increased marginally, from 1.28 s for $n=1$ to 1.35 s for $n=7$. The results validate the scalability of the algorithm in handling complex delivery scenarios.

Table 2. Comparison of time complexity and properties.

Algorithm	Worst-Case Complexity	Properties
Dijkstra	$O\left(\right|E|log|V\left|\right)$	Optimal
Proposed	$n\times O\left(\right|E|log|V\left|\right)$	Optimal
A*	$O\left(\right|E\left|\right)$	Heuristic-based, not optimal

compares the worst-case time complexity and properties of the proposed Algorithm 1, Dijkstra, and A*. The Algorithm 1 achieves optimal performance by leveraging hierarchical planning and efficient elevator integration. The results demonstrate that the Algorithm 1 maintains computational scalability and generates optimal paths for multi-story environments.

Figure 9 compares the average runtime of the proposed Algorithm 1 with the standard Dijkstra algorithm. For a controlled comparison, we manually configured the elevator function values to match each test scenario’s requirements. The Algorithm 1 achieved comparable runtimes to Dijkstra, demonstrating its computational efficiency despite the added complexity of multi-story navigation and delivery optimization.

5.3. Discussion

The experimental results highlight the effectiveness of the Algorithm 1 in addressing the unique challenges of multi-story delivery scenarios. The integration of elevator nodes and hierarchical planning enables efficient navigation, even in large and complex environments. The algorithm consistently achieves optimal performance in terms of path planning, runtime, and memory efficiency, making it a promising solution for autonomous delivery applications.

6. Conclusions

This paper presents a novel graph-based path planning algorithm, the MSPP, for multi-story buildings, addressing critical challenges in autonomous delivery systems. The research offers significant advancements in the field of indoor robotics and logistics automation. The proposed Algorithm 1 effectively handles multi-story navigation by employing a weighted graph representation that overcomes the limitations of traditional path planning methods. Our integration of elevator scheduling with path planning proves crucial, transforming the traditional vertical movement problem into a manageable graph traversal task while ensuring seamless transitions between floors. This integration, combined with our hierarchical approach, achieves an optimal computational complexity of O(|E|log|V|), matching the efficiency of the single-floor Dijkstra’s algorithm despite its handling the additional complexity of multi-story navigation.

The experimental results demonstrated the algorithm’s exceptional scalability, maintaining consistent performance even as the parcel counts increased from $n=1$ to $n=7$ with a minimal impact on runtime. This computational efficiency, coupled with optimal path selection, sets our approach apart from existing solutions. The findings of this study have practical implications for the deployment of autonomous delivery robots in complex indoor environments. The experimental evaluation confirms the algorithm’s consistent performance across various delivery scenarios, efficient resource utilization in terms of memory and computation, and applicability to real-world multi-story buildings. These achievements align with the industry demands for automation in logistics, as highlighted in recent studies on autonomous delivery systems.

While the proposed approach demonstrates promising results, it is not without limitations. Future work should address the adaptation of the algorithm to dynamic environments, particularly in diverse building settings such as healthcare facilities and residential complexes. In healthcare logistics, for example, the algorithm could be extended to handle priority-based deliveries in multi-story hospitals, where time-sensitive medical supplies require optimized routing. Similarly, for residential deliveries in apartment complexes, the system would need to account for varying access restrictions and resident-specific delivery preferences.

Future research should explore the integration of learning-based methods to enhance system resilience against elevator uncertainties. By incorporating reinforcement learning techniques, the algorithm could learn to predict and adapt to elevator failures, maintenance patterns, and traffic-based delays, moving beyond our current assumption of perfect elevator functionality. The development of more sophisticated elevator scheduling algorithms that account for real-world elevator conditions and historical performance data would enable robust path planning even under system faults. These advancements will further solidify the role of autonomous delivery robots in urban logistics, enabling efficient and sustainable solutions for complex indoor environments.