# Difference and advantages between dijkstra & A star

AlgorithmGraphPath Finding## Algorithm Problem Overview

I read this: http://en.wikipedia.org/wiki/A*_search_algorithm

It says A* is faster than using dijkstra and uses best-first-search to speed things up.

If I need the algorithm to run in milliseconds, when does A* become the most prominent choice.

From what I understand it does not necessarily return the best results.

If I need quick results, is it better to pre-compute the paths? It may take megabytes of space to store them.

## Algorithm Solutions

## Solution 1 - Algorithm

> It says A* is faster than using dijkstra and uses best-first-search to > speed things up.

A* is basically an informed variation of Dijkstra.

A* is considered a "best first search" because it greedily chooses which vertex to explore next, according to the value of `f(v)`

[`f(v) = h(v) + g(v)`

] - where `h`

is the heuristic and `g`

is the cost so far.

Note that if you use a non informative heuristic function: `h(v) = 0`

for each `v`

: you get that A* chooses which vertex to develop next according to the "so far cost" (`g(v)`

) only, same as Dijkstra's algorithm - so if `h(v) = 0`

, A* defaults to Dijkstra's Algorithm.

> If I need the algorithm to run in milliseconds, when does A* become > the most prominent choice.

Not quite, it depends on a lot of things. If you have a descent heuristic function - from my personal experience, greedy best first (choosing according to the heuristic function alone) - is usually significantly faster than A* (but is not even near optimal).

> From what I understand it does not necessarily return the best > results.

A* is both complete (finds a path if one exists) and optimal (always finds the shortest path) if you use an Admissible heuristic function. If your function is not admissible - all bets are off.

> If I need quick results, is it better to pre-compute the paths? It may > take megabytes of space to store them.

This is a common optimization done on some problems, for example on the 15-puzzle problem, but it is more advanced. A path from point A to point B is called a Macro. Some paths are very useful and should be remembered. A Machine Learning component is added to the algorithm in order to speed things up by remembering these Macros.

Note that the path from point A to point B in here is usually not on the states graph - but in the problem itself (for example, how to move a square from the lowest line to the upper line...)

**To speed things up:**

If you have a heuristic and you find it too slow, and you want a quicker solution, even if not optimal - A* Epsilon is usually faster then A*, while giving you a bound on the optimality of the path (how close it is to being optimal).

## Solution 2 - Algorithm

Dijkstra is a special case for A* (when the heuristics is zero).

A* search:

It has two cost function.

```
g(n): same as Dijkstra. The real cost to reach a node n.
h(n): approximate cost from node n to goal node. It is a heuristic function. This heuristic function should never overestimate the cost. That means, the real cost to reach goal node from node n should be greater than or equal h(n). It is called admissible heuristic.
```

The total cost of each node is calculated by f(n)=g(n)+h(n)

Dijkstra's:

It has one cost function, which is real cost value from source to each node: f(n)=g(n) It finds the shortest path from source to every other node by considering only real cost.

## Solution 3 - Algorithm

**A*** is just like **Dijkstra**, the only difference is that A* tries to look for a better path by using a heuristic function which gives priority to nodes that are supposed to be better than others while Dijkstra's just explore all possible paths.

Its optimality depends on the heuristic function used, so yes it can return a non optimal result because of this and at the same time better the heuristic for your specific layout, and better will be the results (and possibly the speed).

It is meant to be faster than Dijkstra even if it requires more memory and more operations per node since it explores a lot less nodes and the gain is good in any case.

Precomputing the paths could be the only way if you need realtime results and the graph is quite large, but usually you wish to pathfind the route less frequently (I'm assuming you want to calculate it often).

## Solution 4 - Algorithm

These algorithems can be used in pathfinding and graph traversal, the process of plotting an efficiently directed path between multiple points, called nodes.

Formula for `a* is f =g + h.`

, `g`

means actual cost and h means heuristic cost.
formula for Dijktras is `f = g`

. there is no heuristic cost. when we are using `a*`

and if heuristic cost is `0`

then it'll equal to Dijktras algorithem.

## Solution 5 - Algorithm

Short answer: A* uses heuristics to optimize the search. That is, you are able to define a function that to some degree can estimate the cost from one node to the target. This is particulary useful when you are searching for a path on a geographical representation (map) where you can, for instance, guess the distance to the target from a given graph node. Hence, typically A* is used for path finding in games etc. Where Djikstra is used in more generic cases.

No, A* won't always give the best path. If heuristic is the "geographical" distance, the following example might give the non optimal path.

```
[airport] - [road] - [start] -> [road] -> [road] -> [road] -> [road] -> [target] - [airport]
|----------------------------------------------------------------|
```