Nattee Niparnan SHORTEST PATH Graph with Length Dijkstras

Nattee Niparnan SHORTEST PATH

Graph with Length Dijkstra’s Algorithm

Edge with Length function l(a, b) = distance from a to b

Finding Shortest Path BFS can give us the shortest path Just convert the length edge into unit edge However, this is very slow Imagine a case when the length is 1, 000

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

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 + l(u, v). �If v's alarm is set for later than T + l(u, v), then reset it to this earlier time.

Dijkstra’s Algo from BFS procedure dijkstra(G, l, s) //Input: Graph G = (V; E), directed or undirected; vertex s V; positive edge lengths l // 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] + l(v, u) dist[u] = dist[v] + l(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, l, s) //Input: Graph G = (V; E), directed or undirected; vertex s V; positive edge lengths l // 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] + l(v, u) dist[u] = dist[v] + l(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) �Can be O (V 2 lg V) Good when the graph is sparse

Fibonacci Heap Using simple array 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 throught a node closer than v 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] + l(v, z)) dist[z] = dist[v] + l(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) + l(u, v) ) (u, v) over all edges Initial d(*, s) = 0, d(|V| - 1, v) = inf

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, l, s) //Input: Graph G = (V, E), directed; vertex s V; edge lengths l (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] + l(a, b) dist[b] = dist[a] + l(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] + l(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] + l(a, b) printf(“negative cyclen”)

Shortest Path in DAG appears in linearized order procedure dag-shortest-path(G, l, s) //Input: DAG G = (V; E), vertex s V; edge lengths l (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] + l(u, v) dist[v] = dist[u] + l(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) + l(k, b) ) over all edges (k, b) Initial d 0(a, a) = 0, d 0 (a, b) = inf , d 1(a, b) = l(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 l (may be negative), no negative cycle // Output: dist[u, v] is the shortest distance from u to v. dist = l 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)