Eager Prim Dijkstra

Minimum spanning tree Minimum spanning tree (MST) Prim v.s. Kruskal is a spanning tree whose weight is no larger than any other spanning tree Prim v.s. Kruskal Prim: At each time, add an edge connecting tree vertex and non-tree vertex Minimum-weight crossing edge MinPQ, IndexMinPQ Kruskal gradually add minimum-weight edge to the MST, avoid forming cycle Union-find, MinPQ

Prim Look for the minimum-weight crossing edge Tree edge (thick black) Ineligible edge (dotted line) Crossing edge (solid line) Minimum-weight crossing edge (thick red) Minimum-weight crossing edge

Prim Look for the minimum-weight crossing edge Vertices on the MST masked[v]==true/false Edges on the tree edgeTo[v] is the Edge that connects v to the tree Crossing edges MinPQ<Edge> that compares edges by weight Minimum-weight crossing edge

Lazy Prim private void prim(EdgeWeightedGraph G, int s) { scan(G, s); while (!pq.isEmpty()) Edge e = pq.delMin(); int v = e.either(), w = e.other(v); if (marked[v] && marked[w]) continue mst.enqueue(e); weight += e.weight(); if (!marked[v]) scan(G, v); if (!marked[w]) scan(G, w); } W After putting V into to MST, both of the edges associated with W are in the priority queue private void scan(EdgeWeightedGraph G, int v) { marked[v] = true; for (Edge e : G.adj(v)) if (!marked[e.other(v)]) pq.insert(e); }

Lazy Prim v.s. Eager Prim Is that necessary? We already have <A,W> in the PQ, now we want to add <V,W> to the PQ. One of the edge is redundant since they connected to the same vertex W. We only need the smaller of the two since we are looking for minimum-weight crossing edge. How about this, we store <?,W> in the PQ, <?,W> denotes the minimum weight from MST to non-MST vertex W. (EdgeTo[w] and distTo[w]) After putting V into to MST, both of the edges associated with W are in the priority queue V W A

Lazy Prim v.s. Eager Prim Is that necessary? When we want to put <V,W> into the PQ, we search for index key W to see if <?,W> exists. Therefore, we need to use a IndexPriority Queue. In which the vertex numbers (e.g. W) are the index key and the weights are the sorting key. After putting V into to MST, both of the edges associated with W are in the priority queue V W A

Lazy Prim v.s. Eager Prim private void scan(EdgeWeightedGraph G, int v) { marked[v] = true; for (Edge e : G.adj(v)) { int w = e.other(v); if (marked[w]) continue if (e.weight() < distTo[w]) { distTo[w] = e.weight(); edgeTo[w] = e; if (pq.contains(w)) pq.changeKey(w, distTo[w]); else pq.insert(w, distTo[w]); } V W A Eager Prim keeps only the smaller of <A,W> and <V,W> in the IndexPriorityQueue

Eager Prim private void prim(EdgeWeightedGraph G, int s) { distTo[s] = 0.0; pq.insert(s, distTo[s]); while (!pq.isEmpty()) { int v = pq.delMin(); scan(G, v); } Eager Prim public PrimMST(EdgeWeightedGraph G) { edgeTo = new Edge[G.V()]; distTo = new double[G.V()]; marked = new boolean[G.V()]; pq = new IndexMinPQ<Double>(G.V()); for (int v = 0; v < G.V(); v++) distTo[v] = Double.POSITIVE_INFINITY; if (!marked[v]) prim(G, v); assert check(G); } private void scan(EdgeWeightedGraph G, int v) { marked[v] = true; for (Edge e : G.adj(v)) { int w = e.other(v); if (marked[w]) continue if (e.weight() < distTo[w]) { distTo[w] = e.weight(); edgeTo[w] = e; if (pq.contains(w)) pq.changeKey(w, distTo[w]); else pq.insert(w, distTo[w]); }

Dijkstra Similar idea is used in Dijkstra algorithm Dijkstra Digraph Single-source shortest paths

Dijkstra General idea Compare to Eager Prim After getting the shortest path from S to V, we want to update the distance from S to W. A previous path to W is through A, we do not not need to keep both the path from A and the path from V. We only keep the shorter one in the IndexPriority Queue. S A W Compare to Eager Prim In Eager Prim, <?, W> (distTo[w], edgeTo[w]) denotes the minimum-weight edge from the spanning tree to vertex W In Dijkstra, <?, W>. (distTo[w], edgeTo[w]) denotes the shortest path from start point S to vertex W V

Dijkstra General idea Y In the IndexPriority queue, we keep track only one path to Y, only one path to W, and so on. Y S A W V

Dijkstra private void relax(DirectedEdge e) { int v = e.from(), w = e.to(); if (distTo[w] > distTo[v] + e.weight()) { distTo[w] = distTo[v] + e.weight(); edgeTo[w] = e; if (pq.contains(w)) pq.changeKey(w, distTo[w]); else pq.insert(w, distTo[w]); } S A W V

Prim MST v.s. Dijkstra private void relax(DirectedEdge e) { private void scan(EdgeWeightedGraph G, int v) { marked[v] = true; for (Edge e : G.adj(v)) { int w = e.other(v); if (marked[w]) continue if (e.weight() < distTo[w]) { distTo[w] = e.weight(); edgeTo[w] = e; if (pq.contains(w)) pq.changeKey(w, distTo[w]); else pq.insert(w, distTo[w]); } private void relax(DirectedEdge e) { int v = e.from(), w = e.to(); if (distTo[w] > distTo[v] + e.weight()) { distTo[w] = distTo[v] + e.weight(); edgeTo[w] = e; if (pq.contains(w)) pq.changeKey(w, distTo[w]); else pq.insert(w, distTo[w]); } In Prim, distTo[w] stores the minimum-weight crossing edge connecting MST vertex to non-MST vertex W In Dijsktra, distTo[w] stores the minimum-weight from single source point S to non-explored vertex W. This is a acummulated value.