COMS 482: unofficial class blog

We have two Minimal Spanning Tree algorithms: Kruskal’s (many trees) and Prim’s (single tree). Since we covered the proof of Kruskal’s algorithm in the previous lecture, we’d like to show that Prim’s algorithm produces an MST.

Setup of proof:

T_Prim = {p₁, … , p_n-1}
T_MST = {m₁, … , m_n-1}

Basic strategy: assume that the two trees are different, and try to get a contradiction. Let p_i be an edge not in T_MST. If we add p_i to the MST, we get a cycle. If we add p_i then take out m_j from the cycle we still have a spanning tree.

Specific cases:

1. |p_i| < |m_j| => contradiction, because we have made a less cost MST
2. |p_i| = |m_j| => we’ve built a new MST that uses p_i: sloppy.
   

   The easiest way to resolve this is define p_i so that it can’t fit into any MST, so that then there is a contradiction. Just add, “Let p_i be the first Prim edge that cannot be included with {p₁, … , p_i-1} in any MST.”

3. |p_i| > |m_j| => want to say that we should have picked m_j
   

   Because p_i was picked by Prim’s algorithm, one of p_i’s endpoints is in the tree T_Prim at step i-1.

   1. Make sure m_j is connected
   2. and not already in the tree

   Walk around the edges of cycle, passing edges in {p₁, … , p_i-1}. The next edge after these is connected, too. m_j has to exist because entire cycle cannot be edges of {p₁, … , p_i}.

Implementation details:

We need to keep a priority queue (PQ) of vertices waiting to be added. We need extract_min and update_priority functions in O(log n) time, which can be done easily with a min/max heap. For each vertex, its priority is the length of the edge connecting it to the tree. Therefore, the runtime (asymptotic complexity) of Prim’s algorithm is O(m log n) with m edges and n vertices. Compare to Kruskal’s algorithm.

This entry was posted on Wednesday, February 2nd, 2005 at 12:25 pm and is tagged with pi lt, asymptotic complexity, minimal spanning tree, tmst, priority queue, implementation details, kruskal, tree algorithms, two trees, single tree, vertices, endpoints, mj, contradiction, vertex, algorithm, p1, heap, pq, proof. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback.

2 Responses to 'Lecture 5: How to prove greedy algorithms'

1. 
   The COMS 482 Blog » Blog Archive » Final Review: Chapters 1 to 4 said:

   on May 14th, 2005 at 9:42 pm

   […] ains a proof that Kruskal’s algorithm produces an MST, lecture 5 proves the same for Prim’s algorithm, and lecture 6 carefully proves […]

2. 
   Rita Everett said:

   on November 12th, 2008 at 10:20 pm

   9unxyug7hpkfm98f

Leave a Reply

Name (required)

Mail (will not be published) (required)

Website

Please take time to enjoy the archives: May 2005 (1) April 2005 (11) March 2005 (11) February 2005 (15) January 2005 (7)

Fresh, related resources: