Data Structures and Algorithm Analysis Disjoint Set ADT - PowerPoint PPT Presentation

Loading...

PPT – Data Structures and Algorithm Analysis Disjoint Set ADT PowerPoint presentation | free to download - id: 7554d1-ZTQyY



Loading


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation
Title:

Data Structures and Algorithm Analysis Disjoint Set ADT

Description:

Title: PowerPoint Presentation Last modified by: hp Created Date: 1/1/1601 12:00:00 AM Document presentation format: Other titles – PowerPoint PPT presentation

Number of Views:25
Avg rating:3.0/5.0
Slides: 20
Provided by: educ5460
Learn more at: http://see.xidian.edu.cn
Category:

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: Data Structures and Algorithm Analysis Disjoint Set ADT


1
Data Structures and Algorithm Analysis Disjoint
Set ADT
  • Lecturer Jing Liu
  • Email neouma_at_mail.xidian.edu.cn
  • Homepage http//see.xidian.edu.cn/faculty/liujing

2
The Disjoint Set ADT
  • In this part, we describe an efficient data
    structure to solve the equivalence problem.
  • Relations A relation R is defined on a set S if
    for every pair of elements (a, b), a, b?S, a R b
    is either true or false. If a R b is true, then
    we say that a is related to b.

3
The Disjoint Set ADT
  • Equivalence Relations An equivalence relation is
    a relation R that satisfies three properties
  • Reflexive a R a, for all a?S
  • Symmetric a R b if and only if b R a
  • Transitive a R b and b R c implies that a R c
  • The ? relationship is not an equivalence
    relationship.
  • Two cities are related if they are in the same
    country. This relation is an equivalence relation
    if all the roads are two-way.

4
The Disjoint Set ADT
  • Given an equivalence relation , the natural
    problem is to decide, for any a and b, if ab.
  • The equivalence class of an element a?S is the
    subset of S that contains all the elements that
    are related to a.
  • Notice that the equivalence classes from a
    partition of S Every member of S appears in
    exactly one equivalence class.

5
The Disjoint Set ADT
  • To decide if ab, we need only to check whether a
    and b are in the same equivalence class. This
    provides our strategy to solve the equivalence
    problem.
  • The input is initially a collection of N sets,
    each with one element. Each set has a different
    element.
  • There are two permissible operations.

6
The Disjoint Set ADT
  • The first is Find, which returns the name of the
    set (that is, the equivalence class) containing a
    given element.
  • The second operation adds relations. If we want
    to add the relation ab, then
  • we first see if a and b are already related. This
    is done by performing Finds on both a and b and
    checking whether they are in the same equivalence
    class.
  • If they are not, then we apply Union. This
    operation merges the two equivalence classes
    containing a and b into a new equivalence class.

7
The Disjoint Set ADT
  • Notice that we do not perform any operations
    comparing the relative values of elements, but
    merely require knowledge of their location.
  • For this reason, we can assume that all the
    elements have been numbered sequentially from 1
    to N. Thus, initially we have Sii for i1
    through N.

8
The Disjoint Set ADT
  • Our second observation is that the name of the
    set returned by Find is actually fairly
    arbitrary. All that really matters is that
    Find(a)Find(b) if and only if a and b are in the
    same set.
  • Thus, one idea might be to use a tree to
    represent each set, since each element in a tree
    has the same root. Therefore, the root can be
    used to name the set.

9
The Disjoint Set ADT
  • We will represent each set by a tree. Initially,
    each set contains one element.
  • The representation of the trees is easy, because
    the only information we will need is a parent
    pointer.
  • Since only the name of the parent is required, we
    can assume that this tree is stored implicitly in
    an array each entry Pi in the array represents
    the parent of element i. If i is a root, then
    Pi0.

10
The Disjoint Set ADT
1
2
3
4
5
6
7
8
Eight elements, initially in different sets
0
0
0
0
0
0
0
0
1
2
3
4
5
6
7
8
11
The Disjoint Set ADT
  • To perform a Union of two sets, we merge the two
    trees by making the root pointer of one node
    point to the root node of the other tree. We have
    adopted the convention that the new root after
    the Union(X, Y) is X.

After Union(5,6)
0
0
0
5
0
0
0
0
1
2
3
4
5
7
8
1
2
3
4
5
6
7
8
6
12
The Disjoint Set ADT
After Union(7,8)
5
0
7
0
0
0
0
0
1
2
3
4
5
7
1
2
3
4
5
6
7
8
6
8
After Union(5,7)
0
0
0
5
0
7
5
0
1
2
3
4
5
1
2
3
4
5
6
7
8
6
7
8
13
The Disjoint Set ADT
typedef int DisjSetNumSets1
  • A Find(X) on element X is performed by returning
    the root of the tree containing X. The
    implementation of the basic algorithm is as
    follows

void Initialize(DisjSet S) int i
for(iNumSets igt0 i--) Si0
void SetUnion(DisjSet S, int Root1, int Root2)
SRoot2Root1
int Find(int X, DisjSet S) if (SXlt0)
return X else return Find(SX,
S)
14
The Disjoint Set ADT
  • Smart Union Algorithms The unions above were
    performed rather arbitrarily, by making the
    second tree a subtree of the first.
  • A simple improvement is always to make the
    smaller tree a subtree of the larger, breaking
    ties by any method we call this approach
    union-by-size. Had the size heuristic not been
    used, a deeper tree would have been formed.

15
The Disjoint Set ADT
1
2
3
4
5
6
7
8
Original Trees
1
2
3
4
1
2
3
5
4
5
6
7
7
6
8
Union(4,5) Union-by-size
Union(4,5) Arbitrary Union
8
16
The Disjoint Set ADT
  • An alternative implementation is union-by-height.
    We keep track of the height, instead of the size,
    of each tree and perform Unions by making the
    shallow tree a subtree of the deeper tree.
  • This is an easy algorithm, since the height of a
    tree increases only when two equally deep trees
    are joined (and then the height goes up by one).
    Thus, union-by-height is a trivial modification
    of union of union-by-size.

17
The Disjoint Set ADT
  • An application We have a network of computers
    and a list of bidirectional connections each of
    these connections allows a file transfer from one
    computer to another. Is it possible to send a
    file from any computer on the network to any
    other?
  • An extra restriction is that the problem must be
    solved on-line. Thus, the list of connections is
    presented one at a time, and the algorithm must
    be prepared to given an answer at any point.

18
The Disjoint Set ADT
  • An algorithm to solve this problem can initially
    put every computer in its own set. Our invariant
    is that two computers can transfer files if and
    only if they are in the same set.
  • We can see that the ability to transfer files
    forms an equivalence relation. We then read
    connections one at a time. When we read some
    connection, say (u, v), we test to see whether u
    and v are in the same set and do nothing if they
    are. If they are in different sets, we merge
    their sets.
  • At the end of the algorithm, the graph is
    connected if and only if there is exactly one set.

19
Homework
  • 8.1
About PowerShow.com