Docstoc

Spanning tree

Document Sample
Spanning tree Powered By Docstoc
					Spanning Tree
   What is A Spanning Tree?
• A spanning tree for an
  undirected graph G=(V,E)
  is a subgraph of G that is
  a tree and contains all the       a

  vertices of G
                                b       u   e


• Can a graph have more
  than one spanning tree?       c       v   f


• Can an unconnected graph          d
  have a spanning tree?
       Minimal Spanning Tree.
• The weight of a subgraph
  is the sum of the weights          4
                                               a          4
  of it edges.                                 3                        9
                                 b                              u            e

• A minimum spanning tree      14                                   2
  for a weighted graph is a                10
                                                                        15
  spanning tree with
                                 c                              v            f

  minimum weight.                    3
                                                        8
                                               d

• Can a graph have more
  then one minimum            Mst T: w( T )=      (u,v)  T   w(u,v ) is minimized
  spanning tree?
      Example of a Problem that
        Translates into a MST
The Problem
• Several pins of an electronic circuit must be
  connected using the least amount of wire.

Modeling the Problem
• The graph is a complete, undirected graph
  G = ( V, E ,W ), where V is the set of pins, E
  is the set of all possible interconnections
  between the pairs of pins and w(e) is the
  length of the wire needed to connect the
  pair of vertices.
• Find a minimum spanning tree.
           Greedy Choice
We will show two ways to build a minimum
  spanning tree.
• A MST can be grown from the current
  spanning tree by adding the nearest vertex
  and the edge connecting the nearest
  vertex to the MST. (Prim's algorithm)

• A MST can be grown from a forest of
  spanning trees by adding the smallest edge
  connecting two spanning trees. (Kruskal's
  algorithm)
                  Notation
• Tree-vertices: in the tree constructed so far
• Non-tree vertices: rest of vertices



              Prim’s Selection rule

• Select the minimum weight edge between a tree-
  node and a non-tree node and add to the tree
 The Prim algorithm Main Idea
Select a vertex to be a tree-node

while (there are non-tree vertices) {
  if there is no edge connecting a tree node
 with a non-tree node
        return “no spanning tree”

  select an edge of minimum weight between a
  tree node and a non-tree node

  add the selected edge and its new vertex to
  the tree
  }
return tree
                  5
         A                 B
    4         6       2

        2         D            3
C

    3         1       2
         E                 F
                  4


        Prim's Algorithm
     A                 B




C                D



     E                 F



    Prim's Algorithm
    A                      B



    2             D
C



    E                      F

        Prim's Algorithm
                     5
        A                          B
    4           6            2

        2                D
C

    3            1             2
        E            4             F

            Prim's Algorithm
        A                          B
                               2

        2               D              3
C

    3          1               2
        E                          F

            Prim's Algorithm
        A                          B
                               2

        2               D              3
C

    3          1               2
        E                          F

            Prim's Algorithm
        A                          B
                               2

        2               D
C

    3          1               2
        E                          F

            Prim's Algorithm
        A                          B
                               2

        2               D
C

    3          1               2
        E                          F

            Prim's Algorithm
minimum- spanning tree


                A                               B
                                            2

               2                     D
C

        3                   1               2
                E                               F

                         Prim's Algorithm
          Kruskal‘s Algorithm

1. Each vertex is in its own cluster

2. Take the edge e with the smallest weight
    - if e connects two vertices in different clusters,
      then e is added to the MST and the two clusters,
      which are connected by e, are merged into a
            single cluster
    - if e connects two vertices, which are already
            in the same cluster, ignore it

3.   Continue until n-1 edges were selected
                       Kruskal's Algorithm
                          5
        A                             B
    4            6                2

        2                 D               3
C

    3           1                 2
        E                             F
                            4
            Kruskal's Algorithm
                          5
        A                             B
    4            6                2

        2                 D               3
C

    3           1                 2
        E                             F
                            4
            Kruskal's Algorithm
                          5
        A                             B
    4            6                2

        2                 D               3
C

    3           1                 2
        E                             F
                            4
            Kruskal's Algorithm
                          5
        A                             B
    4            6                2

        2                 D               3
C

    3           1                 2
        E                             F
                            4
            Kruskal's Algorithm
                          5
        A                             B
    4            6                2

        2                 D               3
C

    3           1                 2
        E                             F
                            4
            Kruskal's Algorithm
                          5
        A                             B
    4            6                2

        2                 D               3   cycle!!
C

    3           1                 2
        E                             F
                            4
            Kruskal's Algorithm
                          5
        A                             B
    4            6                2

        2                 D               3
C

    3           1                 2
        E                             F
                            4
            Kruskal's Algorithm
                          5
        A                             B
    4            6                2

        2                 D               3
C

    3           1                 2
        E                             F
                            4
            Kruskal's Algorithm
minimum- spanning tree



               A                              B
                                          2

               2                  D
C

       3                 1                2
               E                              F

                    Kruskal's Algorithm
          Graph Traversal
Traversing a graph means visiting all the
 vertices in the graph exactly once.

Breadth First Search (BFS)
Depth First Search (DFS)
                  DFS
Similar to in-order traversal of a binary
  search tree
Starting from a given node, this traversal
  visits all the nodes up to the deepest
  level and so on.
       v1                                   v1

       v8                                   v8
 v2                    v3   DFS
                                     v2                v3
           v4                               v4
 v5                    v6                              v6
                                     v5
           v7                                v7

DFS : V1        - V2   - V5 - V7 – V4 - V8 – V6 – V3
       v1
                                               v1

       v8
                            DFS                v8
 v2                    v3
                                        v2             v3
           v4
                                               v4
 v5                    v6
                                        v5             v6
           v7
                                                v7

DFS : V1        - V2   - V5 - V7 – V4 - V8 – V3 – V6
            DFS Traversal
Visit the vertex v
Visit all the vertices along the path which
  begins at v

Visit the vertex v, then the vertex
  immediate adjacent to v, let it be vx . If vx
  has an immediate adjacent vy then visit it
  and so on till there is a dead end.

Dead end: A vertex which does not have an
 immediate adjacent or its immediate
 adjacent has been visited.
After coming to an dead end we
 backtrack to v to see if it has an
 another adjacent vertex other than vx
 and then continue the same from it else
 from the adjacent of the adjacent
 (which is not visited earlier) and so on.
Push the starting vertex into the STACK
While STACK not empty do
  POP a vertex V
     If V is not visited
          Visit the vertex V
          Store V in VISIT
          PUSH all adjacent vertex of V
          onto STACK
     End of IF
End of While
STOP
        A
                Adjacency List
F       C   B
                A: F,C,B
        E       B: G,C
            G   C: F
D
                D: C
            K   E: D,C,J
    J           F: D
                G: C,E
                J: D,K
                K: E,G
    DFS of G starting at J
[1] Initially push J onto STACK
           STACK : J
           VISIT: Ø
[2] POP J from the STACK, add it in
  VISIT and PUSH onto the STACK all
  neighbor of J
           STACK: D, K
           VISIT: J
[3] POP the top element K, add it in
  VISIT and PUSH all neighbor of K onto
  STACK
     STACK: D,E,G
     VISIT: J, K
[4] POP the top element G, add it in
  VISIT and PUSH all neighbor of G onto
  STACK
     STACK: D,E, E, C,
     VISIT: J, K, G
[5] POP the top element C, add it in
  VISIT and PUSH all neighbor of C onto
  STACK
     STACK: D,E,E, F
     VISIT: J, K, G, C
[6] POP the top element F, add it in
  VISIT and PUSH all neighbor of F onto
  STACK
     STACK: D,E, E, D
     VISIT: J, K, G, C, F
[5] POP the top element D, add it in
  VISIT and PUSH all neighbor of D onto
  STACK
     STACK: D,E,E, C
     VISIT: J, K, G, C, F,D
[6] POP the top element C, which is
  already in VISIT
     STACK: D,E, E
     VISIT: J, K, G, C, F,D
[5] POP the top element E, add it in
  VISIT which is already in VISIT and
  its neighbor onto STACK
      STACK: D,E, D, C, J
      VISIT: J, K, G, C, F,D,E
[6] POP the top element J, C, D,E, D
  which is already in VISIT
      STACK:
      VISIT: J, K, G, C, F, D, E
                          A
                                  Adjacency List
            F             C   B
                                  A: F,C,B
                          E       B: G,C
                              G   C: F
           D
                                  D: C
                              K   E: D,C,J
                      J           F: D
J, K, G, C, F, D, E
                                  G: C,E
                                  J: D,K
                                  K: E,G
            BFS Traversal


Any vertex in label i will be visited only
 after the visiting of all the vertices in
 its preceding level that is at level i – 1
            BFS Traversal
[1] Enter the starting vertex v in a queue
  Q
[2] While Q is not empty do
          Delete an item from Q, say u
          If u is not in VISIT store u in
               VISIT
          Enter all adjacent vertices of u
               into Q
[3] Stop
     v1

     v8
v2         v3

     v4
v5         v6
      v7
[1] Insert the starting vertex V1 in Q
     Q = V1
      VISIT = Ø

[2] Delete an item from Q, let it be u = V1
    u is not in VISIT. Store u in VISIT
  and its adjacent element in Q
    Q = V2 , V 3
     VISIT = V1
[3] Delete an item from Q, let it be u = V2
    u is not in VISIT. Store u in VISIT
  and its adjacent element in Q
    Q = V2 , V3 , V4 , V5
     VISIT = V1 , V2
[4] Delete an item from Q, let it be u = V3
    u is not in VISIT. Store u in VISIT
  and its adjacent element in Q
    Q = V3 , V4 , V5 , V4 , V6
     VISIT = V1 , V2 , V3
[5] Delete an item from Q, let it be u = V4
     u is not in VISIT. Store u in VISIT
  and its adjacent element in Q
     Q = V4 , V5 , V4 , V6 , V8
      VISIT = V1 , V2 , V3 , V4
 [6] Delete an item from Q, let it be u =V5
     u is not in VISIT. Store u in VISIT
  and its adjacent element in Q
     Q = V5 , V4 , V6 , V8 , V7
      VISIT = V1 , V2 , V3 , V4 , V5
[7] Delete an item from Q, let it be u =V4
    u is in VISIT.
    Q = V4 , V6 , V8 , V7
     VISIT = V1 , V2 , V3 , V4 , V5
[8] Delete an item from Q, let it be u =V6
    u is not in VISIT. Store u in VISIT
  and its adjacent element in Q
    Q = V6 , V8 , V7
     VISIT = V1 , V2 , V3 , V4 , V5 , V6
[9] Delete an item from Q, let it be u =V8
      u is not in VISIT. Store u in VISIT and
   its adjacent element in Q
      Q = V8 , V7 , V1
       VISIT = V1 , V2 , V3 , V4 , V5 , V6 ,
                   V8
 [10] Delete an item from Q, let it be u =V7
      u is not in VISIT. Store u in VISIT and
   its adjacent element in Q
      Q = V7 , V1
       VISIT = V1 , V2 , V3 , V4 , V5 , V6 ,
                    V8 , V7
[11] Delete an item from Q, let it be u =V1
     u is in VISIT.
     Q = V1
      VISIT = V1 , V2 , V3 , V4 , V5 , V6 ,
                     V8 , V 7
[12] Q is empty, Stop
     Q=
      VISIT = V1 , V2 , V3 , V4 , V5 , V6 ,
                     V8 , V 7
     v1                    v1

     v8                    v8
v2         v3   BFS   v2         v3
     v4                    v4
v5         v6                    v6
                      v5
      v7                    v7

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:0
posted:1/9/2013
language:English
pages:50