Professional Documents
Culture Documents
Minimun Spaning Trees-1
Minimun Spaning Trees-1
CS 477/677
Chapter 23
Minimum Spanning Trees
• Spanning Tree
– A tree (i.e., connected, acyclic graph) which contains
all the vertices of the graph
• Minimum Spanning Tree
– Spanning tree with the minimum sum of weights
8 7
b c d
4 9
2
a 11 i 4 14 e
7 6
8 10
g g f
• Spanning forest 1 2
3
Example
8
Problem b c
7
d
4 9
• A town has a set of houses 2
and a set of roads a 11 i 4 14 e
7 6
• A road connects 2 and only 8 10
h g f
2 houses 1 2
4
Minimum Spanning Trees
• A connected, undirected graph:
– Vertices = houses, Edges = roads
• A weight w(u, v) on each edge (u, v) E
5
Properties of Minimum Spanning Trees
• # of edges in a MST:
– |V| - 1
6
Growing a MST – Generic Approach
7
Generic MST algorithm
1. A ←
2. while A is not a spanning tree
3. do find an edge (u, v) that is safe for A
4. A ← A {(u, v)} b
8
c
7
d
4 9
2
5. return A a 11 i 4 14 e
7 6
8 10
h g 2
f
1
• How do we find safe edges?
8
Finding Safe Edges
8 7 V-S
b c d
• Let’s look at edge (h, g) 4
2
9
a 11 i 14 e
– Is it safe for A initially? 4
7 6
8 10
S
• Later on: h
1
g 2
f
9
Definitions
8 7
b c d
4 9
2
• A cut (S, V - S) S a 11 i 4 14 e S
7 6
is a partition of vertices V- S 8 10
V- S
h g 2
f
1
into disjoint sets S and V - S
• An edge crosses the cut
(S, V - S) if one endpoint is in S
and the other in V – S
10
Definitions (cont’d)
8 7
• A cut respects a set A 4
b c d
9
2
of edges no edge S a 11 i 4 14 e S
7 6
in A crosses the cut V- S 8
h g f
10
V- S
1 2
• An edge is a light edge
crossing a cut its weight is minimum over all
edges crossing the cut
– Note that for a given cut, there can be > 1 light
edges crossing it
11
Theorem
• Let A be a subset of some MST (i.e., T), (S, V - S) be a
cut that respects A, and (u, v) be a light edge crossing
(S, V-S). Then (u, v) is safe for A .
Proof:
• Let T be an MST that includes A
S
– edges in A are shaded
• Case1: If T includes (u,v), then
it would be safe for A
u
• Case2: Suppose T does not include
the edge (u, v)
• Idea: construct another MST T’ v
V-S
that includes A {(u, v)}
12
Theorem - Proof
• T contains a unique path p between u and v
• Path p must cross the S
(x, y) A A T’ x
• A {(u, v)} T’ u y
p
• Since T’ is an MST
v
V-S
(u, v) is safe for A
15
Prim’s Algorithm
• The edges in set A always form a single tree
• Starts from an arbitrary “root”: VA = {a}
• At each step: 8 7
b c d
– Find a light edge crossing (VA, V - VA) 4 9
2
– Add this edge to A a 11 i 4 14 e
7 6
– Repeat until the tree spans all vertices 8 10
h g 2
f
1
16
How to Find Light Edges Quickly?
Use a priority queue Q: 8 7
b c d
• Contains vertices not yet 4 9
2
11
included in the tree, i.e., (V – VA) a i 4 14 e
7 6
– VA = {a}, Q = {b, c, d, e, f, g, h, i} 8 10
h g 2
f
1
• We associate a key with each vertex v:
key[v] = minimum weight of any edge (u, v)
connecting v to VA
Key[a]=min(w1,w2) w1
w2
a
17
How to Find Light Edges Quickly?
(cont.)
• After adding a new node to VA we update the weights of all
the nodes adjacent to it
e.g., after adding a to the tree, k[b]=4 and k[h]=8
• Key of v is if v is not adjacent to any vertices in VA
8 7
b c d
4 9
2
a 11 i 4 14 e
7 6
8 10
h g 2
f
1
18
Example
b
8
c
7
d 0
4 9
2 Q = {a, b, c, d, e, f, g, h, i}
11
a i 4 14 e VA =
7 6
8 10 Extract-MIN(Q) a
h g 2
f
1
4
8 7 key [b] = 4 [b] = a
b c d
4 9 key [h] = 8 [h] = a
2
a 11 i 4 14 e
4 8
7 6
8 10 Q = {b, c, d, e, f, g, h, i} VA = {a}
h g f
1 2 Extract-MIN(Q) b
8
19
Example
4 8
key [c] = 8 [c] = b
8 7
b c d key [h] = 8 [h] = a - unchanged
4 9
2
8 8
a 11 i 4 14 e
7 6 Q = {c, d, e, f, g, h, i} VA = {a, b}
8 10
h g f Extract-MIN(Q) c
1 2
8
key [d] = 7 [d] = c
4 8
7
8 7 key [f] = 4 [f] = c
b c d
4 9 key [i] = 2 [i] = c
2 2
a 11 i 4 14 e
7 6 7 4 8 2
8 10
h g f
Q = {d, e, f, g, h, i} VA = {a, b, c}
1 2
8 Extract-MIN(Q) i
4
20
Example
4 8 7 key [h] = 7 [h] = i
8 7
b c d key [g] = 6 [g] = i
4 9
2 2 7 46 8
a 11 i 4 14 e
6
Q = {d, e, f, g, h} VA = {a, b, c, i}
7
8 10
h g f
Extract-MIN(Q) f
1 2
87
6 4
4 8 7 key [g] = 2 [g] = f
b
8
c
7
d key [d] = 7 [d] = c unchanged
4 9
2 2 10 key [e] = 10 [e] = f
a 11 i 14 e
4 7 10 2 8
7 6
8 10 Q = {d, e, g, h} VA = {a, b, c, i, f}
h g 2
f
1
7 6 4 Extract-MIN(Q) g
2 21
Example
4 8 7 key [h] = 1 [h] = g
8 7
b c d 7 10 1
4 9
2 2 10 Q = {d, e, h} VA = {a, b, c, i, f, g}
a 11 i 4 14 e
7 6 Extract-MIN(Q) h
8 10
h g 2
f
1
7
1 2 4 7 10
4 8 7
8 7
Q = {d, e} VA = {a, b, c, i, f, g, h}
b c d
4 9 Extract-MIN(Q) d
2 2 10
a 11 i 4 14 e
7 6
8 10
h g 2
f
1
1 2 4
22
Example
4 8 7
8 7
b c d
9 9
key [e] = 9 [e] = f
4
2 2 10
9
a 11 i 4 14 e
7 6 Q = {e} VA = {a, b, c, i, f, g, h, d}
8 10
h g f Extract-MIN(Q) e
1 2
1 2 4 Q = VA = {a, b, c, i, f, g, h, d, e}
23
PRIM(V, E, w, r)
1. Q←
Total time: O(VlgV + ElgV) = O(ElgV)
2. for each u V
3. do key[u] ← ∞ O(V) if Q is implemented
as a min-heap
4. π[u] ← NIL
5. INSERT(Q, u)
6. DECREASE-KEY(Q, r, 0) ► key[r] ← 0 O(lgV)
Min-heap
7. while Q Executed |V| times
operations:
8. do u ← EXTRACT-MIN(Q) Takes O(lgV) O(VlgV)
25
Prim’s Algorithm
• Prim’s algorithm is a “greedy” algorithm
– Greedy algorithms find solutions based on a sequence
of choices which are “locally” optimal at each step.
26
A different instance of the
generic approach
S
(instance 1)
(instance 2)
u
tree1
v
V-S
29
Example
1. Add (h, g) {g, h}, {a}, {b}, {c}, {d}, {e}, {f}, {i}
8 7
b c d 2. Add (c, i) {g, h}, {c, i}, {a}, {b}, {d}, {e}, {f}
4 9
2 3. Add (g, f) {g, h, f}, {c, i}, {a}, {b}, {d}, {e}
a 11 i 4 14 e 4. Add (a, b) {g, h, f}, {c, i}, {a, b}, {d}, {e}
7 6
8 10 5. Add (c, f) {g, h, f, c, i}, {a, b}, {d}, {e}
h g 2
f 6. Ignore (i, g) {g, h, f, c, i}, {a, b}, {d}, {e}
1
7. Add (c, d) {g, h, f, c, i, d}, {a, b}, {e}
1: (h, g) 8: (a, h), (b, c) 8. Ignore (i, h) {g, h, f, c, i, d}, {a, b}, {e}
2: (c, i), (g, f) 9: (d, e) 9. Add (a, h) {g, h, f, c, i, d, a, b}, {e}
4: (a, b), (c, f) 10: (e, f) 10. Ignore (b, c) {g, h, f, c, i, d, a, b}, {e}
6: (i, g) 11: (b, h) 11. Add (d, e) {g, h, f, c, i, d, a, b, e}
7: (c, d), (i, h) 14: (d, f) 12. Ignore (e, f) {g, h, f, c, i, d, a, b, e}
{a}, {b}, {c}, {d}, {e}, {f}, {g}, {h}, {i} 13. Ignore (b, h) {g, h, f, c, i, d, a, b, e}
14. Ignore (d, f) {g, h, f, c, i, d, a, b, e}
30
Implementation of Kruskal’s Algorithm
8 7
• Uses a disjoint-set data 4
b c d
9
2
structure (see Chapter a 11 i 4 14 e
7 6
21) to determine whether 8 10
h g 2
f
1
an edge connects
We would add
vertices in different edge (c, f)
components
31
Operations on Disjoint Data Sets
• MAKE-SET(u) – creates a new set whose only
member is u
• FIND-SET(u) – returns a representative element
from the set that contains u
– Any of the elements of the set that has a particular
property
– E.g.: Su = {r, s, t, u}, the property is that the element be
the first one alphabetically
FIND-SET(u) = r FIND-SET(s) = r
– FIND-SET has to return the same value for a given set
32
Operations on Disjoint Data Sets
• UNION(u, v) – unites the dynamic sets that
contain u and v, say Su and Sv
– E.g.: Su = {r, s, t, u}, Sv = {v, x, y}
applies to Kruskal’s
u y
algorithm too
v
V-S
36
Problem 1
• (Exercise 23.2-3, page 573) Compare Prim’s algorithm
with and Kruskal’s algorithm assuming:
Kruskal:
O(ElgE)=O(VlgV)
Prim:
- binary heap: O(ElgV)=O(VlgV)
- Fibonacci heap: O(VlgV+E)=O(VlgV)
37
Problem 1 (cont.)
Kruskal:
O(ElgE)=O(V2lgV2)=O(2V2lgV)=O(V2lgV)
Prim:
- binary heap: O(ElgV)=O(V2lgV)
- Fibonacci heap: O(VlgV+E)=O(VlgV+V2)=O(V2)
38
Problem 2
39
Problem 2 (cont.)
1. A←
2. for each vertex v V
O(V)
3. do MAKE-SET(v)
4. sort E into non-decreasing order by w O(ElgE)
5. for each (u, v) taken from the sorted list O(E)
6. do if FIND-SET(u) FIND-SET(v)
7. then A ← A {(u, v)} O(lgV)
8. UNION(u, v)
9. return A
- Sorting can be done in O(E) time (e.g., using counting sort)
- However, overall running time will not change, i.e, O(ElgV) 40
Problem 3
• Suppose that some of the weights in a connected
graph G are negative. Will Prim’s algorithm still
work? What about Kruskal’s algorithm? Justify
your answers.
– Yes, both algorithms will work with negative weights.
Review the proof of the generic approach; there is no
assumption in the proof about the weights being
positive.
41
Problem 4
• (Exercise 23.2-2, page 573) Analyze Prim’s
algorithm assuming:
42
PRIM(V, E, w, r)
1. Q←
Total time: O(VlgV + ElgV) = O(ElgV)
2. for each u V
3. do key[u] ← ∞ O(V) if Q is implemented
as a min-heap
4. π[u] ← NIL
5. INSERT(Q, u)
6. DECREASE-KEY(Q, r, 0) ► key[r] ← 0 O(lgV)
Min-heap
7. while Q Executed |V| times
operations:
8. do u ← EXTRACT-MIN(Q) Takes O(lgV) O(VlgV)
45
Problem 6
• (Exercise 23.1-8, page 567) Let T be a MST of
a graph G, and let L be the sorted list of the
edge weights of T. Show that for any other MST
T’ of G, the list L is also the sorted list of the
edge weights of T’
46