Shortest path GRAPH WITH LENGTH Dijkstras Algorithm Edge

Shortest path

GRAPH WITH LENGTH Dijkstra’s Algorithm

Edge with Length 3 4 4 10 Distance / time / resource , etc. . 3 2 2 Pattaya

Finding Shortest Path • BFS can give us the shortest path • Just convert the length edge into unit edge B 2 A 1 1 C 2 D 2 3 4 E B D C E A However, this is very slow Imagine a case when the length is 1, 000

Alarm Clock Analogy No need to walk to every node 100 S A 50 200 B Since it won’t change anything We skip to the “actual” node Set up the clock at alarm at the target node A S B

Alarm Clock Algorithm • Set an alarm clock for node s at time 0. • Repeat until there are no more alarms: – Say the next alarm goes off at time T, for node u. Then: • The distance from s to u is T. • For each neighbor v of u in G: – If there is no alarm yet for v set one for time T + w(u, v). – If v's alarm is set for later than T + w(u, v), then reset it to this earlier time.

Dijkstra’s Algo from BFS procedure dijkstra(G, w, s) //Input: Graph G = (V, E), directed or undirected; vertex s V; positive edge lengths w // Output: For all vertices u reachable from s, dist[u] is set to the distance from s to u. for all v V dist[v] = + prev[v] = nil dist[s] = 0 Priority_Queue H = makequeue(V) // enqueue all vertices (using dist as keys) while H is not empty v = H. deletemin() for each edge (v, u) E if dist[u] > dist[v] + w(v, u) dist[u] = dist[v] + w(v, u) prev[u] = v H. decreasekey(v, dist[v]) // change the value of v to dist[v]

Another Implementation of Dijkstra’s • Growing from Known Region of shortest path • Given a graph and a starting node s – What if we know a shortest path from s to some subset S’ V? • Divide and Conquer Approach?

Dijktra’s Algo #2 procedure dijkstra(G, w, s) //Input: Graph G = (V, E), directed or undirected; vertex s V; positive edge lengths w // Output: For all vertices u reachable from s, dist[u] is set to the distance from s to u. for all u V : dist[u] = + prev[u] = nil dist[s] = 0 R = {} // (the “known region”) while R ≠ V : Pick the node v R with smallest dist[] Add v to R for all edges (v, u) E: if dist[u] > dist[v] + w(v, u) dist[u] = dist[v] + w(v, u) prev[u] = v

Analysis • There are |V| Extract. Min • Need to check all edges – At most |E|, if we use adjacency list – Maybe |V 2|, if we use adjacency matrix – Value of dist[] might be changed • Depends on underlying data structure

Choice of DS • Using simple array – Each Extract. Min uses O(V) – Each change of dist[] uses O(1) – Result = O(V 2 + E) = O(V 2) • Using binary heap Might be V 2 – Each Extract. Min uses O(lg V) – Each change of dist[] uses O(lg V) – Result = O( (V + E) lg V) • Beware!!! Can be O (V 2 lg V) • if the graph is not sparse Good when the graph is sparse

Fibonacci Heap • Using Fibonacci Heap – Each Extract. Min uses O( lg V) (amortized) – Each change of dist[] uses O(1) (amortized) – Result = O(V lg V + E)

Graph with Negative Edge • Disjktra’s works because a shortest path to v must pass through a node closer than v A 3 S -2 4 B • Shortest path to A pass through B which is… in BFS sense… is further than A

Negative Cycle • A graph with a negative cycle has no shortest path – The shortest. . makes no sense. . • Hence, negative edge must be a directed

Key Idea in Shortest Path • Update the distance if (dist[z] > dist[v] + w(v, z)) dist[z] = dist[v] + w(v, z) • This is safe to perform

Another Approach to Shortest Path • A shortest path must has at most |V| - 1 edges • Writing a recurrent • d(n, v) = shortest distance from s to v using at most n edges • d(n, v) = min of – d(n – 1, v) – min( d(n – 1, u) + w(u, v) ) over all edges (u, v) • Initial d(*, s) = 0, d(0, v) =

Bellman-Ford Algorithm • Dynamic Programming • Since d(n, *) use d(n – 1, *), we use only 1 D array to store D

Bellman-Ford Algorithm procedure Bellman. Ford(G, w, s) //Input: Graph G = (V, E), directed; vertex s V; edge lengths w (may be negative), no negative cycle // Output: For all vertices u reachable from s, dist[u] is set to the distance from s to u. for all u V : dist[u] = + prev[u] = nil dist[s] = 0 repeat |V| - 1 times: for all edges (a, b) E: if dist[b] > dist[a] + w(a, b) dist[b] = dist[a] + w(a, b) prev[b] = a

Analysis • Very simple • Loop |V| times • Each loop takes |E| iterations • O(V E) – Dense graph O(V 3) • Bellman-Ford is slower but can detect negative cycle

Detecting Negative Cycle • After repeat the loop |V|-1 times • If we can still do – dist[v] = dist[u] + w(y, v) • Then, there is a negative cycle – Because there is a shorter path eventhough we have repeat this |V|-1 time for all edges (a, b) E if dist[b] > dist[a] + w(a, b) printf(“negative cyclen”)

Shortest Path in DAG • Path in DAG appears in linearized order procedure dag-shortest-path(G, w, s) //Input: DAG G = (V, E), vertex s V; edge lengths w (may be negative) // Output: For all vertices u reachable from s, dist[u] is set to the distance from s to u. for all u V dist[u] = + prev[u] = nil dist[s] = 0 Linearize G For each u V , in linearized order: for all edges (u, v) E: if dist[v] > dist[u] + w(u, v) dist[v] = dist[u] + w(y, v) prev[b] = a

ALL PAIR SHORTEST PATH

All Pair Shortest Path Problem • Input: – A graph • Output: – A matrix D[1. . v, 1. . v] giving the shortest distance between every pair of vertices

Approach • Standard shortest path gives shortest path from a given vertex s to every vertex – Repeat this for every starting vertex s – Dijkstra O(|V| * (|E| log |V|) ) – Bellman-Ford O(|V| * (|V|3) ) • Dynamic Algorithm Approach – Floyd-Warshall

Dynamic Algorithm Approach • Using the previous recurrent – d(n, v) = shortest distance from s to v using at most n edges – Change to • dn(a, b) = shortest distance from a to b using at most n edges • dn(a, b) = min of – dn-1(a, b) – min(dn-1(a, k) + w(k, b) ) over all edges (k, b) • Initial d 0(a, a) = 0, d 0 (a, b) = , d 1(a, b) = w(a, b)

Dynamic Algorithm Approach • Again, A shortest path must has at most |V| 1 edges • What we need to find is d|V|(a, b) • Let D{M} be the matrix dm(a, b) • Start with D{1} and compute D{2} – Similar to computation of dist[] in Bellman-Ford – Repeat until we have D{|V|}

Floyd-Warshall • Use another recurrent • dk(a, b) is a shortest distance from a to b that can travel via a set of vertex {1, 2, 3, …, k} • d 0(a, b) = l(a, b) because it can not go pass any vertex • d 1(a, b) means a shortest distance that the path can have only vertex 1 (not including a and b)

Recurrent Relation • dk(a, b) = min of – dk-1(a, b) – dk-1(a, k) + dk-1 (k, b) • Initial d 0(a, b) = l(a, b)

Floyd-Warshall procedure Floyd. Warshall(G, l) //Input: Graph G = (V, E); vertex s V; edge lengths w (may be negative), no negative cycle // Output: dist[u, v] is the shortest distance from u to v. dist = w for k = 0 to |V| - 1 for i = 0 to |V| - 1 for j = 0 to |V| - 1 dist[i][j] = min (dist[i][j], dist[i][k] + dist[k][j])

Analysis • Very simple • 3 nested loops of |V| • O(|V|3)