Minimal Spanning Trees

• The problem
  • We are dealing with connected undirected graphs.
  • A spanning tree is a tree that connects all nodes in a graph
  • For unweighted graphs, we can use either BFS or DFS and the tree created there
  • for weighted graphs we have more of a problem.
  • let w(u,v) be the cost associated with the edge (u,v)
  • let T be a spanning tree of G=(V,E)
  • 
  • Our goal is to find the tree T such that w(T) is minimized.
  • 
  • Find the BFS tree from any node
  • Find the DFS tree from any node.
• Kruskals
  • Idea - repeatedly find the least cost edge not yet used and see if we need it in the tree.

  • Put each vertex into a set by it's self
    count = 0
    sort the edges in increasing order
    while count < |V|
       let e =(u,v) be the minimum edge not yet tested 
       if u and v are in different sets, add e to T
       merge the sets of u and v
         

  • This assumes
    • We can sort the edges quickly O(|E| lg |E|)
    • We can do set unions quickly, this can be shown to be O(lg|E|)

  • MST_KRUSKAL(G,w) 
    (1)  T = {}
    (2)  for each vertex v in V[G]
    (3)      MakeSet(v)
    (4)  sort the edges of E by nondecreasing weight w
    (5)  foreach edge (u,v) in E in order
    (6)     if FindSet(u) != FindSet(v) 
    (7)         T = T union {(u,v)}
    (8)         Union(u,v)
    (9)  return T
         

  • Lines 2-3 are O(|V|)
  • Line 4 is O(|E| lg |E|)
  • The loop 5-8 is O(|E|)
  • The Union (line 8) is O(lg|E|)
  • The entire thing is O(|V| + |E| lg|E|)
  • which since it is connected, is O(|E| lg|E|)
  • This is a greedy algorithm
  • And proof that is correct, while beyond our scope would be to argue that the greedy choice is correct
  • Which would essentually involve
    • Assume that T' is a tree where the greedy choice was not used, but that T' was minimum
    • Show that for T, which uses the greed choice w(T) < w(T')
• Prims
  • Idea-

    start at a node, add it to the tree
    while there are not nodes in the tree,
        select the minimum edge from a node on the tree to a node not on the tree
        add this (edge, node) to the tree
         

  • We will use a heap for this
  • This may not produce the same tree as Kruskal
  • But in any case, they will both be minimal

  • MST-PRIM(G,w,r)
    (1)    Q = V[G]
    (2)    foreach u in Q
    (3)      key[u] = inf
    (4)    key[r] = 0
    (5)    r.parent= NULL
    (6)    while !Q.isEmpty()
    (7)       u = Q.ExtractMin()
    (8)       foreach v adjacient to u
    (9)          if v in Q and w(u,v) < key[v]
    (10)            v.parent = u
    (11)            key[v] = w(u,v)
         

  • What it does
    • All verticies not in the tree are kept in the heap
    • When a vertex is added to the tree, all adjacient verticies are possibly given a new key, which may change their priority
  • Timing
    • Line 9, if v in Q, keep a bit in the vertex to say if it is in the heap or not.
    • We really don't want to search the heap every time.
    • Line 1 is O(|V|)
    • Lines 2-3 are O(|V|)
    • The loop in line 6 is O(|V|)
    • Line 7 is O(lg|V|)
    • The loop at line 8 is O(|E|) but, not associated with the loop in line 6
    • Line 11 is a call to rebuild heap for the new weight, so O(lg|V|)
    • So the algorithm is O(|E| lg |V| + |E| lg |V|)
    • But this is really O(|E| lg |V|), since |E| > |V|
    • CLRS notes that a different implementation of a heap will even speed this up to O( |E| + |V|lg|V|)