A* Pathfinding - Euclidean Distance Heuristic Behaving Worse Than Diagonal Distance

15 March 2018 - 1 answer

I implemented the A* pathfinding algorithm according to this: https://www.redblobgames.com/pathfinding/a-star/introduction.html

My grid has a lot of obstacles (more than ten thousand) and is very big. I understand that, in order to get one of the shortest paths, I need to implement an admissible heuristic, so it doesn't over-estimate the distance between the current point and the goal. In theory, euclidean distance must always be less or equal. However, using it, I don't get the shortest path at all, because using diagonal (Chebyshev or octile) distance I get a shorter path. Why is that? Am I missing something? Here is the code:

graph.cost always returns 1

graph.neighbors returns the 8 adiacent positions (less if there are obstacles)

``````def a_star_search(graph, start, goal):
frontier = PriorityQueue()
frontier.put(start, 0)
came_from = {}
cost_so_far = {}
came_from[start] = None
cost_so_far[start] = 0

while not frontier.empty():
current = frontier.get()

if current == goal:
break

for next in graph.neighbors(current):
new_cost = cost_so_far[current] + graph.cost(current, next)
if next not in cost_so_far or new_cost < cost_so_far[next]:
cost_so_far[next] = new_cost
priority = new_cost + heuristic(goal, next)
frontier.put(next, priority)
came_from[next] = current

return get_path(came_from, start, goal)

def heuristic(a, b):
dx = abs(b[0] - a[0])
dy = abs(b[1] - a[1])
D = 1
#with D2 = 1 it's even slower but more accurate
D2 = math.sqrt(2)
#Diagonal distance - this is more accurate
#return D*(dx + dy) + (D2 - 2*D)*min(dx, dy)
#Euclidean distance - this is faster and less accurate
return math.sqrt(dx*dx + dy*dy)
``````