1. Eager Prim Dijkstra

2. 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

3. 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

4. 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

5. 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); }

6. 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

7. 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

8. 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

9. 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]); }

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

11. 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

12. 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

13. 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

14. 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.