Minimum Spanning Tree Problem

• Given a conencted undirected graph \(G = (V, E)\), every edge \(e\) of which has a real-valued length \(\ell(e)\), find a spanning tree with minimum possible total length.
• [PICTURE HERE]
• Minimum spanning trees are used in many settings, e.g., for communication, in designing other algorithms (e.g. TSP).

Prim's algorithm

• Prim's algorithm uses a greedy strategy. It's very similar to Dijkstra's algorithm.
• It grows the MST edge by edge, always adding a shortest edge incident to the tree.
• \(T\) will grow into the MST.
• For \(v \notin T\), \(d[v]\) is maintained as the length of a shortest edge joining \(v\) to a vertex of \(T\).

Prim's algorithm, continued

    choose any vertex r
    d[v] ← ∞ for all v ≠ r
    d[r] ← 0
    let tree T be an empty tree
    while T has < n vertices do {
        let v be a vertex not in T with minimum value d[v]
        add v to T
        for edges vw do {
            if w is not in T then {
                if \ell[v,w] < d[w] then {
                    d[w] ← \ell[v,w]
                    p[w] ← v
                }
            }
        }
    }
    /* The tree defined by the edges p[v] (v ∈ V) is the MST. */

Example execution

• [RUN THE ALGORIHM ON THE EXAMPLE GRAPH.]

Implementation & time

• Prim's algorithm is implemented just like Dijkstra's: maintain a priority queue \(Q\) of the vertices not in \(T\); the key of a vertex is the current value d[v].

• Each iteration does \(O(1)\) priority queue operations for each vertex or edge.

  using heaps or rb-tree gives time \(O(m \log n)\)
  using an array gives time \(O(n^2)\)
  using Fibonacci heap gives time \(O(m + n \log n)\)

Why is Prim's algorithm correct

• A cut \((S, S')\) is a partition \(V\) into 2 nonempty sets \(S\), \(S'\). An edge with a vertex in each set crosses the cut.
• Most efficient MST algorithms are based on the following Cut Theorem.
• Cut Theorem. Any smallest edge crossing a cut \((S, S')\) is in some MST.
• The extension of the theorem is more useful:
• Cut Corollary. Let \(A\) be a set of edges contained in some MST. Let \(e\) be a smallest edge crossing a cut that's not crossed by any edge of \(A\). Then \(A + e\) is contained in some MST.
• The pure greedy strategy for finidng an MST is called Kruskal's algorithm.
• It can be faster than Prim's; it's the basis of the greedy algorithm for “matroids”.

Kruskal's algorithm

    initialize T to a forest containing n vertices & no edges
    /* so T contains n different trees */

    for each edge e, in order of nondecreasing length \ell(e) do
        if e joins 2 different trees of T then add e to T

Execution

[RUN THE ALGORIHM ON THE EXAMPLE GRAPH.]

Implementating Kruskal's algorithm

• [Step 1] Sort the edges by nondecreasing length.

• [Step 2] We keep track of the trees of T using an array tree[1..n].
  tree[i] identifies the tree that currently contains vertex i.
  The last line of Kruskal's algorithm,
  “If e joins 2 different trees of T then add e to T” is implemented as follows:

  {
  let edge e = uv
  a <- tree[u];  b <- tree[v]
  if a <> b then
      for i <- 1 to n do
          if tree[i] = a then
              tree[i] <- b
  }

Running Time

• Step 1 uses time \(O(m \log n)\).
  Step 2 uses time \(O(n^2)\).
  We add n-1 edges to T
  & each edge spends time \(O(n)\) updating tree[].
• Step 2 is much longer than Step 1 for all but the densest graphs.
• Question: For what values of \(m\) is Step 2 longer than Step 1.
• We can reduce the time of Step 2 to \(O(m \log n)\). One way is to keep the vertices of each tree in a red black tree, executing JOIN to combine the trees.
• Other ways are to use a “set merging” algorithm.
• In summary, Kruskal's algorithm can be implemented in time \(O(m \log n)\).