Union By RankAckermann’s FunctionGraph Algorithms

Rajee S RamanikanthanKavya Reddy Musani

Union by Rank

In Union, have parent of shallower tree point to other tree. Maintain rank(x) as an upper bound on the depth of the tree rooted at x.

Consider the following example

mh

sc

y

b

a

l

d

x

Rank of x is 3, and rank of y is 2 Union (x,y) results in with the rank of the resultant tree = greater

rank

mh

sc

y

b

a

l

d

x

If the two trees are of same rank then the rank of the resultant tree increases by one

h

sc

y

l

d

x

•The resultant rank of the union is rank of x + 1.

h

sc

y

l

d

x

Algorithm for Path Compression 1st walk: Find the name of the set . Take a walk until we reach

the root.

2nd walk: Retrace the path and join all the elements along the path to the root using another pointer.

This enables future finds to take shorter paths.

a

b c

d e f

x

Path Compression Find the root(x) by

traversing parent pointers.

Set each node traversed to the resulting root(x)

Path Compression For union by rank,

Best Case

Worst Case

1

Log n

Analysis Union by rank only (m lgn) where m = # of operations n = # MakeSet operations in m Path compression only (n+ f lgn) f<n f = # FindSet operations n = # MakeSet operations There are always <= n-1 Unions Union by Rank and Path Compression For n-1 union and m finds the running time is (n + m *   (n)) (n) is inverse of Ackermann's function

Amortised analysis for Path Compression and Union by Rank Time for n-1 unions and n

finds O(n log*n)

n log n log * n22 2 12^2^2 4 22^2^2^2 2^2^2 32^2^2^2^2 2^2^2^2 4

log*n is a slow growing function

Ladder Function This is a very fast growing function,even faster than exponential

Ladder (n) =222...2

n times

n 2n Ladder(n)

1 2 4

2 4 16

3 8 256

4 16 65536

5 32 4294967296

Ackermann's Function

Ai (j) is Ackermann’s function, it mimics a ladder function for higher values of i

Ai(j) = A i-1 A i-1 A i-1............ A i-1(j)

Ai (j) = j+1 if i=0

= 2j+1 if i=1 =(j+1) 2j+1 -1B(j)=Aj(j)

(n)=Inverse of B

j+1 times

Comparisons of functions

4

F(n)=n

Log n

Log*n(n)

Graph Algorithms

KONIGSBERG BRIDGES

C B

A

The town of Konigsberg( now kalliningrad) lay on the banks and on two islands of the Predal river. The city was connected by 7 bridges. The puzzle: whether it was possible to start walking from anywhere in town and return to the starting point by crossing all bridges exactly once.

GRAPHS

A Graph G=(V,E) is a finite nonempty set V of objects called vertices together with a set E of unordered pairs of distinct vertices of G called edges.

A directed graph(digraph) G=(V,E) is a finite nonempty set V of vertices together with a set E of ordered pairs of vertices of G called arcs. A directed graph is not a symmetric matrix.

Weighted Graph: A graph having a weight, or number, associated with each edge.A weighted graph is usually implemented using adjacency matrix.

CONNECTIVITY PROBLEMS

BICONNECTIVITY PROBLEMS: In a biconnected graph if a path fails , then we have another path. A biconnected graph is a graph from which at least two nodes have to be deleted to break it up into disconnected pieces.

REACHABILITY/COVERING PROBLEMS: Given a graph, then we need to find the whether we can cover the required path.

REPRESENTATION PROBLEM: Representing graphs in computer.

A

B

E

C

D

M

N

O

P Q

UNDIRECTED GRAPHDIRECTED GRAPH

GRAPH TERMINOLOGIES

PATHS AND CYCLES

A path from vertex v1 to vk is a sequence of vertices v1,v2, …, vk that are connected by edges (v1,v2), (v2,v3), …, (vk-1,vk).

A path is simple if each vertex in it appears only once. Vertex u is said to be reachable from v if there is a path

from v to u. A circuit is a path whose first and last vertices are the same. A simple circuit is a cycle if except for the first (and last)

vertex, no other vertex appears more than once. A Hamiltonian cycle of a graph G is a cycle that contains all

the vertices of G

GRAPH REPRESENTATIONS ADJACENCY MATRIX

The adjacency matrix for a finite graph G on ‘n’ vertices is an n*n matrix where the nondiagonal entry a(i,j) is the number of edges joining vertex i and vertex j, and the diagonal entry a(i,i) is either twice the number of loops at vertex i or just the number of loops. There exists a unique adjacency matrix for each graph. If the graph is undirected, the adjacency matrix is symmetric. For dense graphs, that is graph with more edges, an adjacency matrix is often preferred.

ADJACENCY LIST An adjacency list is the representation of all edges or arcs in a graph as a list. If a graph is undirected, every entry is a set of two nodes containing the two ends of the

corresponding edge; if it is directed, every entry is a tuple of two nodes, one denoting the source node and the other denoting the destination node of the corresponding arc. Adjacency lists are unordered. For a graph with a sparse adjacency matrix an adjacency list representation of the graph occupies less space, because it does not use any space to represent edges which are not present.

GRAPH REPRESENTATIONS

DEPTH FIRST SEARCH

DFS is an uninformed search that progresses by expanding the first child node of the search tree that appears and thus going deeper and deeper until a goal state is found, or until it hits a node that has no children.

Then the search backtracks and starts off on the next node.

In a non-recursive implementation, all freshly expanded nodes are added to a stack for expansion.

Time complexity is equal to the number of vertices plus the number of edges in the graphs they traverse.

When searching large graphs that can not be fully contained in memory, DFS suffers from non-termination when the length of a path in the search tree is infinite. This can be solved by maintaining an increasing limit on the depth of the tree, which is called iterative deepening depth first search.

BREADTH FIRST SEARCH BFS is an uninformed search method that aims to expand and

examine all nodes of a tree systematically in search of a search of a solution. In other words, it exhaustively searches the entire tree without considering the goal until it finds it. It does not use a heuristic.

All child nodes obtained by expanding a node are added to a FIFO queue. In typical implementations, nodes that have not yet been examined for their neighbors are placed in some container called “open” and then once examined are placed in the container “closed”.

Time complexity is equal to the number of vertices plus the number of edges in the graphs they traverse.

BFS has space complexity linear in size of the tree/graph searched as it needs to store all expanded nodes in memory.

C B

REFERENCES

Dr.Kumar’s notes Dr.Cook’s notes Fall 2004 notes www.mathworld.com en.wikipedia.org