In graph theory, Prim’s algorithm is a solution to the minimum spanning tree problem, i.e., given a positive weighted connected undirected graph , it finds an MST such that the edges have the minimum weight. It does this by using a greedy approach (much like Dijkstra’s algorithm).
Implementation and analysis
The pseudocode for Prim’s is given by:
Prim-MST(G, w, r):
insert every vertex in Q with infinity
while (Q != \empty)
u = Extract-Min(Q)
foreach v adjacent to u by edge (u, v)
if w(u, v) < key(v)
Decrease-Key(v, w(u, v))
π(i) = u
Step-by-step, Prim’s algorithm:
- Sets the key of each vertex to , except for the root which is set to 0 to indicate that it’s been processed.
- Set the parent of each vertex to NIL, and insert each vertex into a min-priority queue .
- Then, the algorithm begins a loop.
- It identifies the lowest weight edge (i.e., a light edge) that crosses the cut , then removes it from the priority queue and add it to the set of vertices in the tree.
- The
for
loop updates the key and parent attributes of every vertex adjacent to but not in the tree, which maintains the algorithm’s loop invariant, - Then, if the edge weight is less than the key of , it is overwritten with the edge weight, and
Decrease-Key
updates the key value in the priority queue.
The time complexity is primarily dominated by the while
loop and its contents. The outer loop runs in time, Extract-Min
takes (assuming a binary heap), the for
loop that updates the key/parent attributes, and Decrease-Key
also takes . So the total time complexity is , which is asymptotically the same as Kruskal’s algorithm.
Tutorial
ATaC MST such that .
gives us a cycle
cycle, , , which is spanning
contradiction somewhere
let be max edge weight and path connecting where
ATaC MST such that
let be an edge on path that is not in
i.e., u → v via e
and u ← v via p
consider which must have a cycle, and cycle includes by how is defined
so contradiction
looks pretty similar to greedy proofs