0% found this document useful (0 votes)
8 views31 pages

Dijk Stra Algorithms

Dijkstra's Algorithm solves the single-source shortest path problem in graph theory, finding the shortest paths from a source vertex to all other vertices in a graph with nonnegative edge weights. The algorithm maintains a set of known distances and iteratively updates the shortest paths using a priority queue for efficiency. Its time complexity varies based on implementation, with O(|V|^2) for simple lists and O(|E| log |V|) for priority queues, making it suitable for both dense and sparse graphs.

Uploaded by

mehersaini48
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
8 views31 pages

Dijk Stra Algorithms

Dijkstra's Algorithm solves the single-source shortest path problem in graph theory, finding the shortest paths from a source vertex to all other vertices in a graph with nonnegative edge weights. The algorithm maintains a set of known distances and iteratively updates the shortest paths using a priority queue for efficiency. Its time complexity varies based on implementation, with O(|V|^2) for simple lists and O(|E| log |V|) for priority queues, making it suitable for both dense and sparse graphs.

Uploaded by

mehersaini48
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 31

Dijkstra’s Algorithm

Slide Courtesy: Uwash, UT


Single-Source Shortest Path Problem

Single-Source Shortest Path Problem - The


problem of finding shortest paths from a source
vertex v to all other vertices in the graph.
Applications
- Maps (Map Quest, Google Maps)
- Routing Systems
Dijkstra's algorithm
Dijkstra's algorithm - is a solution to the single-source
shortest path problem in graph theory.

Works on both directed and undirected graphs. However,


all edges must have nonnegative weights.

Input: Weighted graph G={E,V} and source vertex v∈V,


such that all edge weights are nonnegative

Output: Lengths of shortest paths (or the shortest paths


themselves) from a given source vertex v∈V to all other
vertices
Approach
• The algorithm computes for each vertex u the distance to u
from the start vertex v, that is, the weight of a shortest path
between v and u.
• the algorithm keeps track of the set of vertices for which the
distance has been computed, called the cloud C
• Every vertex has a label D associated with it. For any vertex u,
D[u] stores an approximation of the distance between v and
u. The algorithm will update a D[u] value when it finds a
shorter path from v to u.
• When a vertex u is added to the cloud, its label D[u] is equal
to the actual (final) distance between the starting vertex v and
vertex u.
Dijkstra pseudocode
Dijkstra(v1, v2):
for each vertex v: // Initialization
v's distance := infinity.
v's previous := none.
v1's distance := 0.
List := {all vertices}.

while List is not empty:


v := remove List vertex with minimum distance.
mark v as known.
for each unknown neighbor n of v:
dist := v's distance + edge (v, n)'s weight.

if dist is smaller than n's distance:


n's distance := dist.
n's previous := v.

reconstruct path from v2 back to v1,


following previous pointers.
Example: Initialization

Distance(source) = 0 0 ∞ Distance (all vertices


A
2
B but source) = ∞

4 1 3 10

2 2 ∞
∞ C D E

5 8 ∞ 4 6

1
F G

∞ ∞

Pick vertex in List with minimum distance.


Example: Update neighbors'
distance
0 2
2
A B

4 1 3 10

2 2 ∞
∞ C D E

5 8 1 4 6

Distance(B) = 2 1
F G
Distance(D) = 1
∞ ∞
Example: Remove vertex with
minimum distance
0 2
2
A B

4 1 3 10

2 2 ∞
∞ C D E

5 8 1 4 6

1
F G

∞ ∞

Pick vertex in List with minimum distance, i.e., D


Example: Update neighbors

0 2
2
A B

4 1 3 10

2 2
3 C D E 3

5 8 1 4 6

Distance(C) = 1 + 2 = 3 1
F G
Distance(E) = 1 + 2 = 3
Distance(F) = 1 + 8 = 9 9 5
Distance(G) = 1 + 4 = 5
Example: Continued...
Pick vertex in List with minimum distance (B) and update neighbors
0 2
2
A B

4 1 3 10

2 2
3 C D E 3

5 8 1 4 6
Note : distance(D) not
1
F G updated since D is
already known and
9 5 distance(E) not updated
since it is larger than
previously computed
Example: Continued...
Pick vertex List with minimum distance (E) and update neighbors

0 2
2
A B

4 1 3 10

2 2
3 C D E 3

5 8 1 4 6

1
F G
No updating
9 5
Example: Continued...
Pick vertex List with minimum distance (C) and update neighbors

0 2
2
A B

4 1 3 10

2 2
3 C D E 3

5 8 1 4 6

Distance(F) = 3 + 5 = 8 1
F G

8 5
Example: Continued...
Pick vertex List with minimum distance (G) and update neighbors

0 2
2
A B

4 1 3 10

2 2
3 C D E 3

5 8 1 4 6

1
F G
Previous distance
6 5
Distance(F) = min (8, 5+1) = 6
Example (end)

0 2
2
A B

4 1 3 10

2 2
3 C D E 3

5 8 1 4 6

1
F G

6 5
Pick vertex not in S with lowest cost (F) and update neighbors
Another Example
Another Example
Another Example
Another Example
Another Example
Another Example
Another Example
Another Example
Another Example
Correctness :“Cloudy” Proof
When a vertex is added to the cloud, it has shortest
distance to source.

Least cost node v P: Next shortest path from


inside the known cloud

THE KNOWN
competitor v'
CLOUD
Source

• If the path to v is the next shortest path, the path to v' must be at
least as long. Therefore, any path through v' to v cannot be shorter!
Dijkstra’s Correctness
• We will prove that whenever u is added to S, d[u] =
d(s,u), i.e., that d[u] is minimum, and that equality is
maintained thereafter
• Proof
– Note that for all v, d[v] ≥ d(s,v)
– Let u be the first vertex picked such that there is a shorter
path than d[u], i.e., that d[u] > d(s,u)
– We will show that this assumption leads to a contradiction
Dijkstra Correctness (2)
• Let y be the first vertex in V – S on the actual shortest
path from s to u, then it must be that d[y] = d(s,y)
because
– d[x] is set correctly for y's predecessor x in S on the
shortest path (by choice of u as the first vertex for which d
is set incorrectly)
– when the algorithm inserted x into S, it relaxed the edge
(x,y), assigning d[y] the correct value
Dijkstra Correctness (3)

d [u ]  ( s , u ) (initial assumption)
  ( s , y )  ( y , u ) (optimal substructure)
 d [ y ]  ( y , u ) (correctness of d [ y ])
 d[ y] (no negative weights)
• But if d[u] > d[y], the algorithm would have chosen y
(from the Q) to process next, not u -- Contradiction
• Thus d[u] = d(s,u) at time of insertion of u into S, and
Dijkstra's algorithm is correct
Dijkstra’s Pseudo Code
• Graph G, weight function w, root s

relaxing
edges
Time Complexity: Using List
The simplest implementation of the Dijkstra's algorithm
stores vertices in an ordinary linked list or array
– Good for dense graphs (many edges)

• |V| vertices and |E| edges


• Initialization O(|V|)
• While loop O(|V|)
– Find and remove min distance vertices O(|V|)
• Potentially |E| updates
• Update costs O(1)

Total time O(|V2| + |E|) = O(|V2| )


Time Complexity: Priority Queue
For sparse graphs, (i.e. graphs with much less than |V2| edges)
Dijkstra's implemented more efficiently by priority queue

• Initialization O(|V|) using O(|V|) buildHeap


• While loop O(|V|)
• Find and remove min distance vertices O(log |V|) using O(log |V|)
deleteMin

• Potentially |E| updates


• Update costs O(log |V|) using decreaseKey

Total time O(|V|log|V| + |E|log|V|) = O(|E|log|V|)


• |V| = O(|E|) assuming a connected graph

You might also like