Nattee Niparnan

Distance of nodes  The distance between two nodes is the length of the shortest path between them S  A 1 S  C 1 S  B 2

DFS and Length  DFS finds all nodes reachable from the starting node  But it might not be “visited” according to the distance

Ball and Strings We can compute distance by proceeding from “layer” to “layer”

Shortest Path Problem (Undi, Unit)  Input:  A graph, undirected  A starting node S  Output:  A label on every node, giving the distance from S to that node

Breadth-First-Search  Visit node according to its layer procedure bfs(G; s) //Input: Graph G = (V,E), directed or undirected; vertex s  V //Output: visit[u] is set to true for all nodes u reachable from v for all u  V : visit[u] = false visit[s] = true Queue Q = [s] (queue containing just s) while Q is not empty: u = eject(Q) previsit(u) visit[u] = true; for all edges (u,v)  E: if visit[v] = false: visit[v] = true; inject(Q,v); postvisit(u)

Distance using BFS procedure shortest_bfs(G, s) //Input: Graph G = (V,E), directed or undirected; vertex s  V //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] = -1 dist[s] = 0 Queue Q = [s] (queue containing just s) while Q is not empty: u = eject(Q); for all edges (u,v)  E: if dist[v] = -1: inject(Q,v); dist[v] = dist[u] + 1; Use dist as visit

DFS by Stack procedure dfs(G, s) //Input: Graph G = (V,E), directed or undirected; vertex s  V //Output: visit[u] is set to true for all nodes u reachable from v for all u  V : visit[u] = false visit[s] = true Stack S = [s] (queue containing just s) while S is not empty: u = pop(S) previsit(u) for all edges (u,v)  E: if visit [v] = false: push(S,v) visit[v] = true; postvisit(u)

DFS vs BFS  DFS goes depth first  Trying to go further if possible  Backtrack only when no other possible way to go  Using Stack  BFS goes breadth first  Trying to visit node by the distance from the starting node  Using Queue

Dijkstra’s Algorithm Graph with Length

Edge with Length 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,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 u  V : dist[u] = + prev(u) = nil dist[s] = 0 H = makequeue(V) (using dist-values as keys) while H is not empty: u = deletemin(H) for all edges (u; v)  E: if dist[v] > dist[u] + l(u, v): dist[v] = dist[u] + l(u, v) prev[v] = u decreasekey(H, 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,z)  E: if dist[z] > dist[v] + l(v,z): dist[z] = dist[v] + l(v,z)

Analysis  There are |V| ExtractMin  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 ExtractMin uses O(V)  Each change of dist[] uses O(1)  Result = O(V 2 + E) = O(V 2 )  Using binary heap  Each ExtractMin 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) Might be V 2 Good when the graph is sparse

Fibonacci Heap  Using simple array  Each ExtractMin 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  now, a shortest path must has at most |V| - 1 edges

Bellman-Ford Algorithm procedure BellmanFord(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)

Shortest Path in DAG  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)