CS 332: Algorithms: Review of MST Algorithms Disjoint-Set Union Amortized Analysis

CS 332: Algorithms
Review of MST Algorithms

Disjoint-Set Union
Amortized Analysis
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=)
Review: MST Algorithms

What do the disjoint sets in Kruskals
algorithm represent?
A: Parts of the graph we have connected up
together so far
Kruskals Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v V
MakeSet(v);
21
13
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));
}
Kruskals Algorithm
Run the algorithm:
Kruskal()
2
19
{
9
14
17
T = ;
8
25
5
for each v V
MakeSet(v);
21
13
1?
T = T U {{u,v}};
}
Kruskals Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v V
MakeSet(v);
21
13
T = T U {{u,v}};
}
Kruskals Algorithm
Run the algorithm:
Kruskal()
2?
19
{
14
17
T = ;
8
25
5
for each v V
MakeSet(v);
21
13
T = T U {{u,v}};
}
Kruskals Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v V
MakeSet(v);
21
13
T = T U {{u,v}};
}
Kruskals Algorithm
Run the algorithm:
Kruskal()
2
19
{
9
14
17
T = ;
8
25
5?
for each v V
MakeSet(v);
21
13
1
T = T U {{u,v}};
}
Kruskals Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v V
MakeSet(v);
21
13
T = T U {{u,v}};
}
Kruskals Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8?
25
5
for each v V
MakeSet(v);
21
13
T = T U {{u,v}};
}
Kruskals Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v V
MakeSet(v);
21
13
T = T U {{u,v}};
}
Kruskals Algorithm
Run the algorithm:
Kruskal()
2
19
{
9?
14
17
T = ;
8
25
5
for each v V
MakeSet(v);
21
13
1
T = T U {{u,v}};
}
Kruskals Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v V
MakeSet(v);
21
13
T = T U {{u,v}};
}
Kruskals Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v V
MakeSet(v);
21
13?
T = T U {{u,v}};
}
Kruskals Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v V
MakeSet(v);
21
13
T = T U {{u,v}};
}
Kruskals Algorithm
Run the algorithm:
Kruskal()
2
19
{
14?
17
T = ;
8
25
5
for each v V
MakeSet(v);
21
13
T = T U {{u,v}};
}
Kruskals Algorithm
Run the algorithm:
Kruskal()
2
19
{
14
17
T = ;
8
25
5
for each v V
MakeSet(v);
21
13
T = T U {{u,v}};
}
Review: Shortest-Path Algorithms

How does the Bellman-Ford algorithm work?
How can we do better for DAGs?
Under what conditions can we use Dijkstras
algorithm?
Review: Running Time of

Kruskals 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()
Disjoint Set Union

So how do we represent disjoint sets?
Nave 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?
Disjoint Set Union: Analysis

Worst-case analysis: O(n2) time for n Unions
Union(S1, S2) copy
1 element
Union(S2, S3) copy 2 elements
Union(Sn-1, Sn) copy n-1 elements

O(n2)
Improvement: always copy smaller into larger

How long would above sequence of Unions take?
Worst case: n Unions take O(n lg n) time
Proof uses amortized analysis
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
resulting set size
2
2nd time
4
(lg n)th time

n
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
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 wont worry about it here
The End

CS 332: Algorithms: Review of MST Algorithms Disjoint-Set Union Amortized Analysis

Uploaded by

Copyright:

Available Formats

CS 332: Algorithms: Review of MST Algorithms Disjoint-Set Union Amortized Analysis

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CS 332: Algorithms: Review of MST Algorithms Disjoint-Set Union Amortized Analysis

Uploaded by

Copyright:

Available Formats

CS 332: Algorithms

Review of MST Algorithms

Review: MST Algorithms

will the edge with the lowest weight be in the

(u,v) is the min-weight edge connecting A to V-A,

Review: MST Algorithms

Review: Shortest-Path Algorithms

Review: Running Time of

operations, particularly Union()

Disjoint Set Union

elements, with pointers back to set:

elements of A to point to B: O(A)

Disjoint Set Union: Analysis

Union(S2, S3) copy 2 elements

Union(Sn-1, Sn) copy n-1 elements

Improvement: always copy smaller into larger

Amortized Analysis of Disjoint Sets

the larger set, an element can be copied at most

(lg n)th time

Amortized Analysis of Disjoint Sets

lg n times, n Union()s takes O(n lg n) time

Book also discusses potential method

You might also like

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.