ECE750 Lecture 6:

Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
ECE750 Lecture 6: Binary relations and
graph algorithms
Todd Veldhuizen
[email protected]
Electrical & Computer Engineering
University of Waterloo
Canada
Oct. 19, 2007
1 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Binary Relations I

Recall that a binary relation on a set X is a set

R X
2
. (Note: X
2
= X X is the set of all pairs
(x
1
, x
2
) where x
1
, x
2
X.)

We may interpret a binary relation as a directed graph

G = (X, R), i.e., elements of X are vertices, and R is
the edge relation.

Some common axioms relations may satisfy:

1. Transitive (T):
x, y, z . (R(x, y) R(y, z) R(x, z))





If there is a path from x to z, there is an edge from x to
z.
2 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Binary Relations II
2. Reexive: x . R(x, x)

Every vertex has an edge to itself.

3 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Binary Relations III
3. Symmetric (S)
x, y . R(x, y) R(y, x)

If there is an edge from x to y, there is an edge from y

to x.
For a symmetric graph, one usually one draws the graph
without arrows:

and it is called simply a graph rather than a directed
graph.
4 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Binary Relations IV
4. Antisymmetric (A)
x, y . R(x, y) R(y, x) (x = y)
When the relation is reexive, transitive and also
antisymmetric, it is a partial order. The Hasse diagram
(see rst lecture) is the conventional way to draw a
partial order; it removes all the edges implied by
transitivity and reexivity, and removes the need for
directed arrows by making all edges implicitly point up.
5 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Binary Relations V

A rough classication of binary relations:

Binary Relation/Directed Graph
Graph (S) Preorder/Quasiorder (T,R)
Equivalence (T,R,S) Partial order/Poset (T,R,A)
Tree order
Total order

Good algorithms for managing the common classes of

binary relations are known. If you can identify the
abstract relation(s) underlying a problem, this may lead
you directly to ecient algorithms.
6 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Part I
Equivalence Relations
7 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Equivalence relations and partitions I

An equivalence relation is a binary relation that is

reexive, transitive, and symmetric. (The most familiar
example: equality, =).

Pictured as a graph, an equivalence relation is a

collection of cliques:
a
b
e
f
c
q
q
q
q
q
q
q
q
q
q
q
q
q
d
w
w
w
w
w
w
w
w
w
w
w
w
w
g
b
b
b
b
b
b
b
b

A clique is a graph with an edge between every pair of vertices. In

the picture above, we have omitted arrows because the graph is
symmetric.

There are certain symbols that generally imply an

equivalence relation. Some of these are =, , , , .
8 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Equivalence relations and partitions II

For an equivalence relation X

2
, we write

[a]

= b X : a b for the equivalence class of a,

i.e., [a]

is the set of elements of X that are

-equivalent to a;

X/ for the set of equivalence classes induced by :

X/ = [a]

: a X
X/ is a partition. (Recall that a partition of a set X
is a collection of subsets Y
1
, . . . , Y
k
of X that are
pairwise disjoint and satisfy

Y
i
= X.)

Example: In the preceding gure, the equivalence

classes are a, b, c, d, e, f , g.

Example: take N with a b (a mod 5 = b mod 5).

The equivalence classes N/ are
0, 5, 10, . . ., 1, 6, 11, . . ., . . . , 4, 9, 14, . . ..
9 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Equivalence relations and partitions III

Common algorithmic problems we encounter with

equivalence classes:

Answering queries of the form Is a b?

Maintaining an equivalence relation as we progressively

decide objects are equivalent. (This results from an
inductively dened equivalence relation.) Example: the
Nelson-Oppen method for equational reasoning [7].

Maintaining an equivalence relation as we progressively

decide objects are not equivalent. (This results from a
co-inductive denition of equivalence [6].) Example:
minimizing states of a DFA [4], maintaining
bisimulations, congruence closure [3].

A system of representatives is the primary means for

ecient manipulation of equivalence relations.
10 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Equivalence relations and partitions IV

A system of representatives for is a function

s : (X/ ) X choosing a single element from each
block of the partition, such that
a b if and only if s([a]) = s([b])

Example: to reason about equivalence of integers

modulo 5, we could choose the representatives 0, 1, 2, 3,
and 4. The integer 1 represents the equivalence class
[1]

= 1, 6, 11, 16, . . ..

With a means to quickly compute representatives, we

can test whether a b by computing the
representatives of the equivalence classes [a]

and [b]

,
then using equality.

If the equivalence relation is static, one can precompute

a system of representatives as e.g., a table. If the
equivalence relation is discovered dynamically, more
sophisticated methods are needed.
11 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Disjoint Set Union I

Disjoint Set Union is algorithms-speak for maintaining

an inductively-dened equivalence relation:

Initially we have a set of objects, none of which are

known to be equivalent.

We gradually discover that objects are equivalent, and

we wish to maintain a representation of the equivalence
relation that lets us quickly answer queries of the form
Is a b?

Interface:

union(a, b): include a b in the equivalence relation

nd(a): returns an equivalence class representative

(ECR) for a.

There is wonderfully elegant data structure due to

Tarjan [8] that performs these operations in O(n(n))
time, where (n) 3 for n less than (cosmologists best
estimate of) the number of particles in the universe.
12 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Disjoint Set Union II

Tarjans data structure maintains the equivalence

relation on the set X as a forest a collection of trees.
Each node in a tree is an element of the set X, each
tree is an equivalence class, and each root is an
equivalence class representative.
b

e

a

d
b
b
b
b
b
f

A forest representation of the equivalence classes

{{a, b, c, d}, {e, f , g}}.

Each element has a pointer to its parent; to determine

the equivalence class representative, we follow the
parent pointers to the root of the tree.
13 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Disjoint Set Union III

The eciency of the representation depends on how

deep the trees are. To keep the trees shallow, two
techniques are employed: (i) path compression; and (ii)
union by rank.

Record representation: for each element x X, we

track

parent(x): a pointer to the parent of x, or a pointer to

itself if it is the root (alternately, a null pointer can be
used.)

rank(x): indicates how deep trees are (but, not depth

per se).

Pseudocode for nd(a):

nd(a)
if parent(a) ,= a then
parent(a) nd(parent(a))
return parent(a)
14 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Disjoint Set Union IV
This recursively follows the parent pointers up to the
root, then rewrites all the parent pointers so they point
directly at the root, called path compression:
f

e
a
a
a
a
a
d

e
a
a
a
a
a
c

Left: tree. Right: after calling nd(c).

A simple way to implement union(a,b): just make the root of as

tree have b as a parent.
union(a,b)
parent( nd(a)) nd(b)
15 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Disjoint Set Union V
However, this can lead to poorly balanced trees. For better
asymptotic eciency, one can track how deep the trees are and
always make the deeper tree the parent of the shallower tree:
called union by rank.
union(a,b)
pa nd(a)
pb nd(b)
if pa=pb then return
if rank(pa) > rank(pb) then
parent(pb) pa
else
parent(pa) pb
if (rank(pa) = rank(pb))
rank(pb) rank(pa) + 1
16 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Disjoint Set Union VI

The rank is an upper bound on the height of the tree. It is not

exactly the height of the tree, however, because nd operations
can modify the tree height but do not adjust the rank values.

Tarjan proved that using both path compression and union by

rank, a sequence of n calls to union and nd requires O(n(n))
time, where (n) 3 for
n 2
2
2
.
.
.
2
9
>
>
=
>
>
;
65536
i.e., a tower of 65536 powers-of-two. The function (n) is the
inverse of the Ackermann function; see CLR [2] or [8] for details.

For any practical purpose, the time required by Tarjans algorithm

is indistinguishable from O(n) for a sequence of n operations; or
O(1) per operation amortized time (to come.)
17 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Part II
Graphs
18 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Representation of Graphs I

Here are four common methods of representing graphs.

If the graph is large (e.g., innite), the structure is not

known beforehand, etc., we may choose an implicit
representation for the graph, where vertices and edges
are computed on-the-y as needed. For example, the
graph G = (N, E) where (x, y) E if and only if y
divides x, is an innite graph where the edges can be
computed on the y by factorization.

An explicit representation is one where we directly

encode the structure of the graph in a data structure.
Some common methods for this:
19 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Representation of Graphs II

Adjacency matrix: an n n matrix A of 0s and 1s,

with A
ij
= 1 if and only if v
i
, v
j
E. Row i indicates
the out edges for vertex i , and column i indicates the in
edges.
A =

0 1 1 0
0 0 0 1
0 0 0 1
0 0 0 0

b

d
a

20 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Representation of Graphs III
Note that we can read some properties of the graph
from this matrix:

If A = A
T
, the graph is symmetric.

If A has all 1s on the diagonal (i.e., tr A = [V[), then

the graph is reexive.

If A = AA, the graph is transitive and reexive. (A

gives paths of length 1; A
2
gives paths of length 2, etc.)

Adjacency lists: each vertex maintains a set of vertices

to/from which there is an edge e.g.
out(a) = b, c
out(b) = d
out(c) = d
out(d) =
21 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Representation of Graphs IV

If the graph structure is static (i.e., not changing as the

algorithm runs), it is common to represent lists of in-
and out- edges as vectors, for eciency.

For more elaborate algorithms on e.g. weighted graphs,

a representation of this sort is commonly used:
public class Edge
Vertex x, y;
double weight;

public class Vertex

Set<Edge> out;
Set<Edge> in;

22 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Depth-First Search I

One of the commonest operations on a graph is to visit

the vertices of the graph one by one in some desired
order, possibly stopping when some desired vertex is
reached. This is called a search.

In a depth-rst search, we explore along a single path

into the graph as far as we can until no new vertices
can be reached; then we return to some earlier point
where new vertices are still reachable and continue.
(Think of exploring a maze.)

Example of a depth-rst search (yellow) starting at the

center vertex of this graph:
23 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Depth-First Search II

As we visit each new vertex, we perform some action

there. The choice of action depends on what we hope
to accomplish; for now we will just call it visiting the
vertex, but later we will see examples of specic useful
actions. We might choose to visit the vertex the rst
time we see it (preorder), or the last time we see it
(postorder)

Here is a recursive implementation of depth-rst search.

It uses a set Seen to track which vertices have been
visited. One can also include a ag eld as part of the
vertex data structure that can be marked to indicate
the vertex has been seen.
24 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Depth-First Search III
dfs(x)
dfs(x, )
dfs(x, Seen)
if x , Seen
Seen Seen x
preorderVisit (x) // Do something
For each edge (x, y),
dfs(y,Seen)
postorderVisit (x) // Do something

This search is easily implemented in a nonrecursive

version, using a stack data structure to keep track of
the current path into the graph:
25 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Depth-First Search IV
dfs(x)
Seen =
Stack S
push(S,x)
while S is not empty,
y pop(S)
if y , Seen then
Seen Seen y
preorderVisit (y)
for each edge (y, z),
push(S,z)
26 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Topological Sort I

A Directed Acyclic Graph (DAG) is a graph in which

there are no cycles (i.e., paths from a vertex to itself.)

The reexive, transitive closure of a DAG is a partial

order. (If you add to a DAG an edge (x, y) whenever
there is a path from x to y, plus self-loops (x, x), the
resulting edge relation is a partial order: reexive,
transitive, and anti-symmetric.)

Every nite partial order can be extended to a total

order: i.e., if _ is a partial order on a nite set, there is
a total order such that (x _ y) (x y); or, more
obtusely, _.

Axiom of choice implies this for innite sets also.

27 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Topological Sort II

Example: let V = N
2
(pairs of natural numbers), and
for all i , j , put edges (i , j ) (i + 1, j ) and
(i , j ) (i , j + 1):
.
.
.
.
.
.
.
.
.

Then the transitive reexive closure of this graph is a
partial order _ where (i , j ) _ (i

, j

) if and only if i i

and j j

:
(2, 0) (1, 1) (0, 2)
(1, 0)
s
s
s
s
s
u
u
u
u
u
(0, 1)
u
u
u
u
u
s
s
s
s
s
(0, 0)
s
s
s
s
s
u
u
u
u
u
28 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Topological Sort III
One way to extend _ to a total order is:
.
.
.

f
f
f
f

f
f
f
f

c
c
c

c
c
c

f
f
f
f

c
c
c
(This is one method for what computer scientists call
dovetailing.)

Topological sort is a method for obtaining a total-order

extension of a partial order.
29 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Topological Sort IV

Example: Suppose we want to evaluate a digital circuit:

e
a
d
c
b
Build a graph where signals are vertices, and an edge
indicates that one signal depends upon another (a
dependence graph):
d
a b
e
c
30 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Topological Sort V
The transitive, reexive closure of this graph yields an
order _, where e.g., e _ d means signal e can be
evaluated only after signal d.
Extending _ to a total order gives us a valid order in
which to evaluate the signals, e.g.,
e d c b a
If we evaluate signals in the order a, b, c, d, e we respect
the dependencies.

Other examples:

Ordering the presentation of topics in a course or paper.

Solving equations

Makeles

Planning (keeping track of task dependencies)

Spreadsheets and dataow languages [5]

Ordering static initializers in programming languages

31 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Topological Sort VI

Dynamization of static algorithms e.g. [1]

Here is an algorithm for topological sort based on

depth-rst search. Note that there are many ways in
which a partial order can be extended to a total order;
this is just one method.
TopologicalSort (V,E)
Set<Node> visited;
List <Node> order;
for x V
dfs(x, visited , order)
dfs(x, visited , order)
if x , visited
visited . add(x)
for each out edge (x,y)
dfs(y, visited , order)
32 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Topological Sort VII
order . insertBack(x)

We search the dependence graph depth-rst, visiting

vertices postorder at which time we insert them at the
back of the list.

Example: for the circuit example, a depth-rst search

might visit the vertices in the order a, b, d, c, e.

To obtain the reverse order, we can replace insertBack

with insertFront.
33 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Connected components of undirected graph I

Defn: A set of vertices Y V is connected if for every

a, b Y there is a path from a to b. Y is a maximal
connected component if it cannot be enlarged, i.e., for
any connected set of vertices Y

with Y Y

, Y = Y

Note that the connected components of a graph form a

partition of the vertices:
g
d
a
a
a
a
b

e
q
The connected components are {{a, b, g, q}, {c, d, e}}.
34 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Connected components of undirected graph II

Using Tarjans disjoint set union, there is a very simple

algorithm for connected components:
1. Have a parent pointer and rank associated with each
vertex (e.g., by creating a separate record for each
vertex, or by storing these elds directly in the vertex
data structure.)
2. For each edge (a, b), call union(a, b).
No searching is necessary! The complexity is
O([E + V[([E + V[)), practically linear in the
number of vertices and edges.
35 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Weighted Graphs

A weighted graph is a triple G = (V, E, w) where w is

a weight function: often
w : E R +
w : E Q
+

Often w(x, y) > 0 and represents a distance or

score.

Example: vertices are cities, and edges represent driving

times between adjacent cities.
36 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Distance metric on graphs I

If edge weights are positive, we can dene a distance

metric (or quasimetric) on the graph. You are familiar
with Euclidean distance, for example, in R
2
:
d(x, z) =

(x
1
z
1
)
2
+ (x
2
z
2
)
2
We can dene distances in graphs in such a way that
they share many of the useful properties of Euclidean
distance.

A distance metric d : V
2
R satises:
1. d(x, y) 0
2. d(x, y) = 0 if and only if x = y
3. d(x, y) = d(y, x) (symmetry)
4. d(x, y) + d(y, z) d(x, z) (triangle inequality)
37 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Distance metric on graphs II
If the symmetry axiom (3) is omitted, d is called a
quasimetric. (For weighted directed graphs, a
quasimetric may be appropriate.)

A set V together with a distance metric d : V

2
R is
called a metric space.

A connected graph with nonnegative edge weights can

be turned into a metric space:
1. Dene the length of a path to be the sum of edge
weights along the path;
2. Dene d(x, x) = 0 and d(x, y) to be the minimum path
length from x to y.

In R
2
we can dene open and closed discs:
(x, y) :

x
2
+ y
2
< r
(x, y) :

x
2
+ y
2
r
38 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Distance metric on graphs III

In a metric space (V, d) we can dene open and closed

balls:
B
r
(x) = y V : d(x, y) < r
E.g. if we construct a graph of settlements in Ontario
where edges indicate roads and weights are driving
times, then a ball is e.g., settlements that are within
two hours of Waterloo.
39 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Breadth-rst search I

Breadth-rst search is another method to visit all the

vertices of a graph. Conceptually, we put weights of 1
on each edge. Then from some starting vertex x, we
consider balls of radius r around x and take r ; we
visit vertices in the order they are added to the ball.
40 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Breadth-rst search II

Basic scheme: we maintain a queue of vertices that are

just outside the current ball.
BFS(V,E,x)
Seen =
Queue Q
Enqueue(Q,x)
While Q is not empty,
Get y = next element in queue.
if y , Seen,
Seen Seen y
Visit y
For each edge y, z E,
Enqueue(Q,z)
This algorithm is linear in the number of edges.
41 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Single-source shortest paths I

The BFS algorithm is easily modied to solve the

following problem: given a connected graph with
nonnegative edge weights and a specied vertex x,
compute d(x, y) for all y V. That is, nd the length
of the shortest path from x to every other vertex in the
graph.

Intuition: again, consider balls centered around x, but

use edge weights. We want to visit vertices in order of
their distance from x, so we modify the BFS algorithm
to use a priority queue. We put pairs (z, d) into the
priority queue, where z is a vertex, and d is the length
of some path from x to z. The priority queue orders
(z, d) pairs by d, using e.g., a min heap, so that at
each step we can eciently retrieve the next closest
vertex to x.
42 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Single-source shortest paths II
SSSP(V,E,x,w)
Seen
PriorityQueue PQ.
Put (x, 0) in PQ.
While PQ is not empty,
Get (y,d) from PQ (least element).
if y , Seen then
Seen Seen y
Visit (y,d)
For each edge (y, z), put (z, d+w(y,z)) in PQ.

Time complexity: if we use a min-heap, this achieves

O([E[ log [E[) time. It is possible to get this down to
O([V[ log [V[ +[E[) by the use of somewhat exotic data
structures such as Fibonacci heaps.
43 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Bibliography I
[1] Umut A. Acar, Guy E. Blelloch, Robert Harper, Jorge L.
Vittes, and Shan Leung Maverick Woo.
Dynamizing static algorithms, with applications to
dynamic trees and history independence.
In SODA 04: Proceedings of the fteenth annual
ACM-SIAM symposium on Discrete algorithms, pages
531540, Philadelphia, PA, USA, 2004. Society for
Industrial and Applied Mathematics. bib pdf
[2] Thomas H. Cormen, Charles E. Leiserson, and Ronald R.
Rivest.
Intoduction to algorithms.
McGraw Hill, 1991. bib
44 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Bibliography II
[3] Peter J. Downey, Ravi Sethi, and Robert Endre Tarjan.
Variations on the common subexpression problem.
Journal of the ACM (JACM), 27(4):758771, 1980. bib
pdf
[4] J. E. Hopcroft.
An n log n algorithm for minimizing the states in a
nite-automaton.
In Z. Kohavi, editor, Theory of Machines and
Computations, pages 189196. Academic Press, 1971.
bib
[5] Wesley M. Johnston, J. R. Paul Hanna, and Richard J.
Millar.
Advances in dataow programming languages.
ACM Comput. Surv., 36(1):134, 2004. bib pdf
45 / 1
ECE750 Lecture 6:
Binary relations
and graph
algorithms
Todd Veldhuizen
[email protected]
Bibliography III
[6] Y. N. Moschovakis.
Elementary Induction on Abstract Structures.
North-Holland, Amsterdam, 1974. bib
[7] Greg Nelson and Derek C. Oppen.
Fast decision procedures based on congruence closure.
Journal of the ACM (JACM), 27(2):356364, 1980. bib
pdf
[8] R. E. Tarjan.
Eciency of a good but not linear disjoint set union
algorithm.
Journal of the ACM (JACM), 22:215225, 1975. bib
pdf
46 / 1