Transcript CS 332: Algorithms Review of MST Algorithms Disjoint-Set Union Amortized Analysis David Luebke 11/6/2015 Review: MST Algorithms ● In a connected, weighted, undirected graph, will the edge.

CS 332: Algorithms
Review of MST Algorithms
Disjoint-Set Union
Amortized Analysis
David Luebke
1
11/6/2015
Review: MST Algorithms
● In a connected, weighted, undirected graph,
will the edge with the lowest weight be in the
MST? Why or why not?
● Yes:
■ If T is MST of G, and A  T is a subtree of T, and
(u,v) is the min-weight edge connecting A to V-A,
then (u,v)  T
■ The lowest-weight edge must be in the tree (A=)
David Luebke
2
11/6/2015
Review: MST Algorithms
● What do the disjoint sets in Kruskal’s
algorithm represent?
● A: Parts of the graph we have connected up
together so far
David Luebke
3
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v  V
21
13
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
4
9
1
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2
19
{
9
14
17
T = ;
8
25
5
for each v  V
21
13
1?
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
5
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v  V
21
13
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
6
9
1
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2?
19
{
14
17
T = ;
8
25
5
for each v  V
21
13
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
7
9
1
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v  V
21
13
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
8
9
1
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2
19
{
9
14
17
T = ;
8
25
5?
for each v  V
21
13
1
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
9
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v  V
21
13
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
10
9
1
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8?
25
5
for each v  V
21
13
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
11
9
1
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v  V
21
13
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
12
9
1
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2
19
{
9?
14
17
T = ;
8
25
5
for each v  V
21
13
1
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
13
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v  V
21
13
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
14
9
1
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v  V
21
13?
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
15
9
1
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v  V
21
13
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
16
9
1
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2
19
{
14?
17
T = ;
8
25
5
for each v  V
21
13
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
17
9
1
11/6/2015
Kruskal’s Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v  V
21
13
MakeSet(v);
sort E by increasing edge weight w
for each (u,v)  E (in sorted order)
if FindSet(u)  FindSet(v)
T = T U {{u,v}};
Union(FindSet(u), FindSet(v));
}
David Luebke
18
9
1
11/6/2015
Review: Shortest-Path Algorithms
● How does the Bellman-Ford algorithm work?
● How can we do better for DAGs?
● Under what conditions can we use Dijkstra’s
algorithm?
David Luebke
19
11/6/2015
Review: Running Time of
Kruskal’s Algorithm
● Expensive operations:
■ Sort edges: O(E lg E)
■ O(V) MakeSet()’s
■ O(E) FindSet()’s
■ O(V) Union()’s
● Upshot:
■ Comes down to efficiency of disjoint-set
operations, particularly Union()
David Luebke
20
11/6/2015
Disjoint Set Union
● So how do we represent disjoint sets?
■ Naïve implementation: use a linked list to
represent elements, with pointers back to set:
○ MakeSet(): O(1)
○ FindSet(): O(1)
○ Union(A,B): “Copy” elements of A into set B by
adjusting elements of A to point to B: O(A)
■ How long could n Union()s take?
David Luebke
21
11/6/2015
Disjoint Set Union: Analysis
● Worst-case analysis: O(n2) time for n Union’s
Union(S1, S2)
Union(S2, S3)
…
Union(Sn-1, Sn)
“copy”
“copy”
1 element
2 elements
“copy”
n-1 elements
O(n2)
● Improvement: always copy smaller into larger
■ How long would above sequence of Union’s take?
■ Worst case: n Union’s take O(n lg n) time
■ Proof uses amortized analysis
David Luebke
22
11/6/2015
Amortized Analysis of Disjoint Sets
● If elements are copied from the smaller set into
the larger set, an element can be copied at most
lg n times
■ Worst case: Each time copied, element in smaller set
1st time
2nd time
…
(lg n)th time
David Luebke
resulting set size
2
4
n
23
11/6/2015
Amortized Analysis of Disjoint Sets
● Since we have n elements each copied at most
lg n times, n Union()’s takes O(n lg n) time
● Therefore we say the amortized cost of a
Union() operation is O(lg n)
● This is the aggregate method of amortized
analysis:
■ n operations take time T(n)
■ Average cost of an operation = T(n)/n
David Luebke
24
11/6/2015
Amortized Analysis:
Accounting Method
● Accounting method
■ Charge each operation an amortized cost
■ Amount not used stored in “bank”
■ Later operations can used stored money
■ Balance must not go negative
● Book also discusses potential method
■ But we won’t worry about it here
David Luebke
25
11/6/2015
The End
David Luebke
26
11/6/2015