ERA*: Enhanced Relaxed A* algorithm for Solving the Shortest Path Problem in Regular Grid Maps

1. Introduction

The shortest path problem is a well-established and important problem that finds applications in various fields, including robotics ([1,2]), VLSI design ([3]), wireless sensor networks ([4]), and transportation ([5,6]). This problem can be represented either on a grid or a more general graph, with different techniques employed for each representation. Grid-based approaches are commonly favored in scenarios like extensive VLSI design, particularly when there are numerous obstacles to navigate around.

Traditionally, two types of methods have been used to address the global path planning problem. The first type is exhaustive search, which involves thorough exploration of the entire search space to find the optimal solution. Examples of exact search algorithms commonly used for this purpose include Dijkstra’s algorithm (([7,8])) and $A^{*}$ algorithm ([9]). These algorithms guarantee finding the shortest path but may become impractical when dealing with large grids due to their computational complexity.

The second type is local search, which employs metaheuristic algorithms to explore only a portion of the search space. These algorithms, such as Tabu Search ([10]), Ant Colony Optimization ([11]), Genetic Algorithm ([12]), Particle Swarm Optimization ([13,14]), and their multiple variants, provide approximate solutions and are often used when the exhaustive search is not feasible due to the large size of the grid. By exploring a limited subset of the search space, local search algorithms can find reasonably good solutions efficiently.

Recently, some relaxed alternatives of exhaustive search algorithms have emerged. These approaches aim to find a balance between the constraint of achieving optimality in path length and the need for faster search times. The work being discussed here falls into this category. It is demonstrated that the proposed Enhanced Relaxed $A^{*}$ ($ER{A}^{*}$) algorithm is theoretically equivalent to the relaxed $A^{*}$ ($R{A}^{*}$,15]) algorithm in terms of the path length of the solutions it provides. However, it achieves significant savings in terms of time and memory requirements by employing a completely different computation strategy.

By relaxing the constraint of path length optimality to some extent, this approach manages to expedite the search process while still delivering solutions that are comparable in terms of path length to those obtained through the $R{A}^{*}$ algorithm. The key advantage lies in the adoption of a novel computation strategy based on lookup matrices. These matrices store precomputed values that can be efficiently accessed during the search, eliminating the need for redundant calculations and resulting in substantial time and memory savings.

The remaining of this paper is organized as follows: Section 2 discussed the most relevant related works. Section 3 presents the proposed $ER{A}^{*}$ algorithm and proves its equivalence to $R{A}^{*}$ in terms of path cost. Section 4 presents the results of the evaluation of $ER{A}^{*}$ on a benchmark of representative grid maps, and compares it to $A^{*}$ and $R{A}^{*}$ in terms of path cost and execution time. Finally, Section 5 concludes the paper and suggests some future works.

2. Related Works

Shortest path algorithms are a crucial tool in the field of computer science and are used to solve a wide range of problems. In general, point-to-point shortest path algorithms work by starting at a source node and exploring the neighboring nodes until they reach the destination node. Along the way, the algorithm keeps track of the shortest distance from the source to each node, using this information to guide the search and ensure that the shortest path is found. There are a variety of shortest path algorithms that have been developed for finding the shortest path between two points in a regular grid ([16]). These algorithms typically involve searching through the grid to identify the optimal path, taking into account factors such as the cost of moving from one cell to another and any obstacles that may be present in the grid.

One of the most popular and well-known shortest path algorithms for regular grids is Dijkstra’s algorithm, which was first proposed by Dutch computer scientist Edsger Dijkstra ([7,8]). Dijkstra’s algorithm is a general-purpose algorithm that can be used to find the shortest path between any two points in a weighted, directed graph. It is based on the idea of building a "shortest path tree" from the source point to all other points in the grid, with the shortest path to each point being the minimum sum of the weights of the edges along the path. Although Dijkstra’s algorithm is relatively simple and easy to implement, it has a time complexity of O($\left|E\right|+\left|V\right|log\left|V\right|$) when using a suitable data structure (Fibonacci heaps), where $\left|E\right|$ is the number of edges in the graph and $\left|V\right|$ is the number of vertices. This makes it less efficient for larger grids.

Another popular shortest path algorithm for regular grids is $A^{*}$[9], which was proposed as an improvement of Dijkstra’s algorithm. $A^{*}$ is a heuristic search algorithm that uses a combination of a best-first search and a cost-estimation function to guide the search towards the goal. Unlike Dijkstra’s algorithm, which considers all paths from the source to the goal, $A^{*}$ only considers paths that are likely to lead to the goal, based on the cost-estimation function. This makes $A^{*}$ more efficient than Dijkstra’s algorithm for many grid-based problems, although the performance of $A^{*}$ can be sensitive to the choice of cost-estimation function.

[17] proposed the first Maze-solving algorithm that is based on target-directed grid propagation and is memory-efficient. It was extensively employed in the field of printed circuit board design for finding wire paths. However, [18] later revealed that the original claim of the algorithm’s generality regarding the path cost function is incorrect.

More recent shortest path algorithms for regular grids include the Jump Point Search (JPS) algorithm, proposed by [19] as an improvement over $A^{*}$ in grid maps. It is based on a selective node expanding process that specifically identifies and expands certain nodes in the grid map, referred to as jump points. Thus, intermediate nodes along a path between two jump points are not expanded at all, which enhances the speed of $A^{*}$ search by an order of magnitude.

[20] proposed the Minimum Detour (MD) algorithm in G4 regular grids. Its main idea is to calculate the detour number d(P), defined as the number of nodes on the path P that are directed away from the goal. Then, the path length is calculated as M(S,G) + 2d(P), where M(S,G) is the Manhattan distance between the start S and the goal G nodes. This is because any move opposed to the direction of the goal necessarily needs to be compensated to reach the goal. Since M(S,G) is constant for a given (S,G) pair, minimizing the path length is equivalent to minimizing the detour number. Nodes that have lower detour numbers are given higher priority in the grid expansion process, in a breath-first search style. Since then, no similar algorithm has been proposed in G8 grids, because the detour computation is not as simple as in G4 grids. This paper proposes to bridge this gap by introducing a Hadlock-inspired algorithm applicable to G8 grids.

Relaxed Dijkstra and Relaxed $A^{*}$ ($R{A}^{*}$) algorithms proposed by [15] exploit the grid-map structure to establish an accurate approximation of the optimal path, without visiting any cell more than once. The path length is approximated in terms of number of moves on the grid. This approach distinguishes itself from previous bounded relaxation algorithms of $A^{*}$ ([21,22,23,24]) primarily by performing relaxation on the exact cost, denoted as g, of the evaluation function f (where f = g + h). This sets it apart from existing relaxations of the $A^{*}$ algorithm, which typically focus on relaxing the heuristic h. The current work proposes aims to further accelerate the execution of the $R{A}^{*}$ algorithm by completely changing its computing paradigm, drawing inspiration from the Hadlock algorithm.

It is worth noting that path planning in a grid map can be substantially accelerated in a completely different way by building connection graphs before applying a search algorithm ([25]). Nevertheless, the fact that the proposed $ER{A}^{*}$ algorithm does not construct connection graphs is a significant advantage in many cases. For instance, in large VLSI design problems with a high number of obstacles, the construction of the entire connection graph could be extremely costly.

3. Methodology

The proposed algorithm is based on calculating detour penalties that are propagated from the source node S to the the goal node G. For a given current node C, we define:

• $\alpha$: the angle between the x-axis and the $\overrightarrow{CG}$ vector.
• ${\Delta }_x=x_G-x_C$, where $x_G$ and $x_C$ are the abscissas of the goal node and the current node, respectively.
• ${\Delta }_y=y_G-y_C$, where $y_G$ and $y_C$ are the ordinates of the goal node and the current node, respectively.

Figure 1 clarifies the definition of the variables $\alpha$, ${\Delta }_x$, and ${\Delta }_y$ on an example. Figure 2 presents the five first matrices of incremental detour penalty for $\alpha \in [0^{\circ },{90}^{\circ }]$. These 3x3 matrices store the incremental detour (penalty) from the goal expressed as:

$$D\left(n_i\right)-D\left(n_{i-1}\right)=dist(n_{i-1},n_i)+h\left(n_i\right)-h\left(n_{i-1}\right)$$

(1)

Where h is the shortcut distance to goal (shortest path assuming there are no obstacles, see Figure 1).

The value of some penalties, which are denoted as NE (North-East), SE (South-East), and NW (North-West), depend on the value of ${\Delta }_x$ and ${\Delta }_y$. For instance, in case (a), corresponding to $\alpha =0$ (C and G on the same row, with G on the right, so that the optimal path between them is equal to ${\Delta }_x$), if ${\Delta }_x=1$, it means that the goal is adjacent to the current node on its right. Consequently, if we move towards NE or SE, we will reach the goal with a minimum cost of $\sqrt{2}+1$ instead of just 1 for the optimal path between C and G. That is why the penalty is $\sqrt{2}$. Whereas, for all other values of ${\Delta }_x>1$, if we move towards NE, we can return back to the row containing G with a total cost of $2\sqrt{2}$ instead of 2 for the optimal path. That is why the penalty is $2\sqrt{2}-2$. Obviously, the case ${\Delta }_x<1$ cannot correspond to angle $\alpha =0$. The reasoning is similar for the other cases.

Notice that the matrix (e) can be obtained from the matrix (a) by applying a 90° anti-clockwise rotation and substituting ${\Delta }_x$ for ${\Delta }_y$ in the formulas of NE/SE that becomes NW/NE. Likewise:

• (f) $90<\alpha <135$: is obtained from (b) by applying a 90° anti-clockwise rotation.
• (g) $\alpha =135$: is obtained from (c) by applying a 90° anti-clockwise rotation.
• (h) $135<\alpha <180$: is obtained from (d) by applying a 90° anti-clockwise rotation.

In total, we have 28 fixed $3\times 3$ matrices (counting the cases of different ${\Delta }_x$ and ${\Delta }_y$ values), that we store before running the search algorithm.

As in [20], nodes that have lower detour numbers are given higher priority in the grid expansion process. This process proceeds until the goal position is reached. Then the path is reconstructed backwards from the goal cell, by moving from each cell to its parent cell that expanded it, until the starting cell is reached.

Instead of two matrices (actual cost g and combined score f) as in $A^{*}$ and $R{A}^{*}$, only one matrix of detour penalties (D) is stored in memory. At a give node $n_i$, the detour value can be calculated recursively, using the euclidean distance $dist$ and the heuristic function h (shortcut distance), as:

$$\begin{array}{cc}\hfill D\left(n_i\right)& =D\left(n_{i-1}\right)+dist(n_{i-1},n_i)+h\left(n_i\right)-h\left(n_{i-1}\right)\hfill \\ \hfill & =D\left(n_{i-2}\right)+dist(n_{i-2},n_{i-1})+dist(n_{i-1},n_i)+h\left(n_{i-1}\right)-h\left(n_{i-2}\right)+h\left(n_i\right)-h\left(n_{i-1}\right)\hfill \\ \hfill & =...\hfill \\ \hfill & =D\left(n_0\right)+\sum _{k=0}^{i-1}dist(n_k,n_{k+1})+\sum _{k=1}^{i}h\left(n_k\right)-h\left(n_{k-1}\right)\hfill \end{array}$$

(2)

With:

$$\begin{array}{cc}\hfill & D\left(n_0\right)=0\hfill \\ \hfill & \sum _{k=0}^{i-1}dist(n_k,n_{k+1})=g\left(n_i\right)\hfill \\ \hfill & \sum _{k=1}^{i}h\left(n_k\right)-h\left(n_{k-1}\right)=h\left(n_i\right)-h\left(n_0\right)\hfill \end{array}$$

(3)

Therefore:

$$\begin{array}{cc}\hfill D\left(n_i\right)& =g\left(n_i\right)+h\left(n_i\right)-h\left(n_0\right)\hfill \\ \hfill & =f\left(n_i\right)-h\left(n_0\right)\hfill \end{array}$$

(4)

Consequently, since $h\left(n_0\right)$ is constant, optimizing D is equivalent to optimizing f.

Algorithm 1 presents the main steps for path exploration in $ER{A}^{*}$. The algorithm takes as input a grid represented by a 2D matrix ($map$) where obstacles are marked with a predefined value, and the coordinates of the start (S) and goal (G) nodes. It calculates the penalty matrix D with a finite value for all explored nodes. The algorithm stops when the node exploration reaches G, or when a predefined maximum number of iterations is reached. We first store the 28 $3\times 3$ incremental penalty matrices (see Figure 2), and initialize the priority queue I of expanded nodes to the start node S with associated penalty 0 (line 4). The penalty matrix D and the Predecessor matrix P (used for path reconstruction) are both initialized with default infinity values (lines 6-8), except for the penalty associated with S which is initialized to 0 (line 10). Then, we iterate over the priority queue I by dequeuing each time the node that has the minimum penalty value $D(i,j)$. Based on the value of $\Delta x$ and $\Delta y$ between this current node C and the goal node, we choose the corresponding incremental penalty matrix $D_i$. This choice is accomplished through a series of if statements where the most likely cases (e.g., inequalities such as $\Delta y\ge 1$) are placed before less likely cases (e.g., equalities such as $\Delta x=0$), in order to optimize execution time. We define J (line 16) as the set of all free (i.e., non-obstacle) neighbor nodes of C for which the penalty value $D(i,j)$ is infinite (i.e., has not been calculated yet). For each node in J, we save its predecessor C in the P matrix (line 17) for later path reconstruction, and we calculate its penalty value $D(i_P,j_P)$ as the sum of the current node’s penalty plus the corresponding incremental penalty in the $3\times 3$$D_i$ matrix (line 18). Then, we enqueue J in I (line 21), where the priorities correspond to the D values. If there is a path between S and G, G will be reached and its penalty value calculated, unless the predefined maximum number of iteration is attained.

Algorithm 1:$ER{A}^{*}$ search algorithm.

Once Algorithm 1 reaches the goal G, Algorithm 2 is used to reconstruct the path backward. It takes as input the penalty matrix D and predecessors matrix P that were both generated in Algorithm 1, and the start and goal coordinates on the grid. If $D(i_G,j_G)\ne +\infty$ (line 1), it means that Algorithm 1 has reached the goal and a path from S to G has been found. The path reconstruction algorithm starts from the goal $(i_G,j_G)$ (line 3), and prepends the current node’s predecessor to the path at each iteration (line 14), while adding 1 (for horizontal and vertical moves) or $\sqrt{2}$ (for diagonal moves) until it reaches the start node S. Alternatively, we can count the number of diagonal moves, and multiply it by $\sqrt{2}$ only at the end to avoid accumulating numerical inaccuracies.   

Algorithm 2: path reconstruction algorithm.

4. Evaluation and discussion

4.1. Dataset

The simulation study was performed using Matlab R2012a on a laptop with an Intel Core i7 processor (2.4 GHz) and 16 GB of RAM. The evaluation of the algorithms was based on the same benchmark used in [15], which is composed of four categories of maps:

• 26 maps with randomly placed rectangular obstacles of various obstacle sizes and ratios, ranging from 100 x 100 to 2000 x 2000 in size.
• 6 mazes with passages of different sizes, all 512 x 512 in size, with variable corridor size.
• 4 room maps (512 x 512) filled with random square rooms of variable size.
• 6 maps from video games and 1 real-world map (Willow Garage), ranging from 512 x 512 to 1024 x 1024 in size and selected for their varying levels of difficulty.

We designed and generated the first category of random maps, while the other three categories (mazes, rooms, and video games) were selected from a large set of benchmarking maps provided by [26]. For each map, we conducted 30 runs with randomly selected start and goal nodes each time. Thus, the total number of runs is 1290 (43 maps × 30) for each algorithm.

We compared the proposed $ER{A}^{*}$ algorithm to the original A${}_t^{*}$ ($A^{*}$ using path tie-breaks) and to $R{A}^{*}$${}_{wot}$ (Relaxed $A^{*}$ without using path tie-breaks) which was proven in [15] to provide the best tradeoff between path cost and execution time among the tested relaxed variants in G8 grids.

4.2. Results

Two main performance metrics are considered to evaluate the three global planners:

• The path length: it represents the length of the shortest global path found by the planner.
• The execution time: time spent by an algorithm to find its best (or optimal) solution.

Table 1 shows the percentage of optimal paths (when a path exists) for the three tested algorithms, per environment. The original $A^{*}$ provides the optimal in all cases, since no relaxation is applied to it. We observe that $ER{A}^{*}$ yields a slightly higher rate of optimal paths than $R{A}_{wot}^{*}$ for random environments of different sizes, a slightly lower rate for rooms and video games, and a markedly lower rate for mazes, in which path lengths are the longest in average, as shown in Table 2. This is due to the numerical issues entailed by the incremental computation. Nevertheless, Table 3 shows that the percentage of extra length compared to the optimal path remains low at 2.3% in average, and a maximum of 10.4%, which is slightly lower than the maximum extra length produced by $R{A}_{wot}^{*}$.

On the other hand, Table 4 shows the average execution time of each algorithm in each grid environment. $ER{A}^{*}$ is 2.25 times faster in average than $R{A}_{wot}^{*}$. This ratio varies from 1.74× to 2.47× depending on the type of grid environment. Figure 3 displays the histogram of this ratio. It shows that $R{A}_{wot}^{*}$ is faster than $ER{A}^{*}$ in only very few cases.

When compared to $A^{*}$, $ER{A}^{*}$ is 17.13 times faster in average, with a range from 7.27× to 24.3×. Table 5 shows that $ER{A}^{*}$ has consistently the fastest execution time among the three algorithms in nearly 90% of cases. This superiority applies in all tested grid environments as can be seen in the scatter plots in Figure 4 (randomly generated environments of various sizes) and Figure 5 (structured environments) which compare $ER{A}^{*}$ and $R{A}_{wot}^{*}$ in the Cost/Time space. These two figures also show that the range of path length for the two algorithms is similar.

Figure 6 depicts the box plot of the ratio between the execution time and the optimal path for the three algorithms. It shows a markedly reduced range for $ER{A}^{*}$ and $R{A}^{*}$ compared to $A^{*}$. On a closer scale, Figure 7 shows that $ER{A}^{*}$ further reduces this range by almost one half compared to $R{A}^{*}$.

Figure 8 provides a comprehensive evaluation of the performance of the three algorithms by representing them in cost/time space, in terms of average and standard deviation. The aim of this comparison is to evaluate the performance of different algorithms for both the path cost and the execution time. The cost/time space, therefore, shows the trade-off between the cost and time incurred by each algorithm. The evaluation is done based on two metrics: average and standard deviation. The width of each rectangle is proportional to the path cost standard deviation, while the height is proportional to the execution time standard deviation. The average is represented by a star at the center of each rectangle. The figure shows that $ER{A}^{*}$ provides the best tradeoff between cost and time, a reduced range of execution time, and a range of path cost that is close to $R{A}^{*}$’s.

Furthermore, we conducted an analysis on the cost and time performance of the three algorithms on the described set of experiments, using a T-test. The first comparison was between the $ER{A}^{*}$ and $R{A}_{wot}^{*}$ algorithms, where the null hypothesis of equal means for time was rejected with a very low p-value of $1.1216e^{-20}$. Whereas, the null hypothesis for cost was accepted with a p-value of 0.91, indicating that the difference in cost between the two algorithms is not statistically significant. The second comparison was between the $ER{A}^{*}$ and $A_t^{*}$ algorithms. Again, the null hypothesis for equal means in time was rejected with a very low p-value of $1.1002e^{-35}$, indicating that there is a statistically significant difference in time performance between the two algorithms. While the null hypothesis for cost was accepted with a p-value of 0.7607, indicating that the cost difference between the two algorithms is not statistically significant.

5. Conclusion

In conclusion, this paper introduced a novel algorithm for solving the point-to-point shortest path problem on a static regular 8-neighbor connectivity (G8) grid. The algorithm is a generalized version of the Hadlock algorithm specifically designed for G8 grids. This work falls within the category of relaxed alternative algorithms that balance the trade-off between path length optimality and search time. By relaxing the constraint of path length optimality to some extent, the proposed Enhanced Relaxed A* (ERA*) algorithm accelerates the search process while still providing solutions with similar path lengths to those obtained using RA*. The key advantage lies in the novel computation strategy utilizing lookup matrices, which significantly reduces redundant calculations, resulting in substantial time and memory savings.

Experimental results obtained through extensive testing on various grid maps validate the algorithm’s effectiveness. On average, it is 2.25 times faster than RA* and 17 times faster than the original A* algorithm. Additionally, it exhibits improved memory efficiency since it eliminates the need for storing a G score matrix.

Future research can focus on exploring further optimizations and extensions of the ERA* algorithm. This could involve investigating its performance in dynamic or uncertain environments, incorporating additional constraints or cost factors, and exploring possibilities for parallelization or distributed computation. Additionally, the algorithm’s applicability to other grid types or graph structures can be explored. The insights gained from this work lay the foundation for potential advancements in efficient path planning algorithms for various domains and applications.