Union By Rank Ackermann’s Function Graph Algorithms by hmh17149

VIEWS: 0 PAGES: 32

									Union By Rank
Ackermann’s Function
Graph Algorithms

    Rajee S Ramanikanthan
       Kavya 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


                         x
                                         y

                     d       b
                                     c       s

                 l       m
                                 h

             a
   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




                          x
                                               y

                      d       b
                                           c       s

                  l       m
                                       h

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

                    x
                                            y

                d
                                        c       s

            l
                                    h



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

                                x

                            d       y

                        l       c       s


                            h
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.
Path Compression
   Find the root(x) by
    traversing parent pointers.
                                              a
   Set each node traversed to
    the resulting root(x)                 b       c


                                      d       e       f

                                  x
Path Compression
   For union by rank,


      Best Case           1




    Worst Case
                         Log n
Analysis
   Union by rank only
     Q (m lgn) where m = # of operations
    n = # MakeSet operations in m
   Path compression only
    Q(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 * a (n))
    a (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)




          log*n is a slow growing function

          n             log n        log * n
          22           2             1
          2^2^2        4             2
          2^2^2^2      2^2^2         3
          2^2^2^2^2    2^2^2^2       4
Ladder Function
   This is a very fast growing function,even faster than exponential
                        .2
                    2..
   Ladder (n)   =22
                          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)
                    j+1 times



  Ai (j) = j+1 if i=0
         = 2j+1 if i=1
         =(j+1) 2j+1 -1
B(j)=Aj(j)
a(n)=Inverse of B
Comparisons of functions


                    F(n)=n




                      Log n



                        Log*n
      4
                      (n)
Graph Algorithms
  KONIGSBERG BRIDGES

                      A



                                     B
             C




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.
GRAPH TERMINOLOGIES

                                 M
D            A
                        N
      E

                             O
                 B
      C
                        P            Q


                       DIRECTED GRAPH
    UNDIRECTED GRAPH
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

								
To top