Network Algorithms Planar Graphs by ewghwehws

VIEWS: 1 PAGES: 44

									       Planar graphs

    Network Algorithms 2005




1       Netwerk Algorithms: Planar graphs
                  Planar graphs
• Can be drawn on the plane without crossings
• Plane graph: planar graph, given together with an
  embedding in the plane
• Many applications…
• Questions:
    – Testing if a graph is planar
    – Finding a nice drawing of a planar graph
    – Solving problems for planar graphs

2                   Netwerk Algorithms: Planar graphs
               Some notions
•   Faces
•   Exterior face
•   Interior faces
•   Each edge is incident to 2 faces




3                Netwerk Algorithms: Planar graphs
    The smallest graphs that are not
                planar
• K5, K3,3




4             Netwerk Algorithms: Planar graphs
        Kuratowski / Wagner
• A graph is planar if and only if it does not
  contain the K5 and the K3,3 as a
  homeomorphic subgraph / as a minor.
• Minor: H is a minor of G, if H can be
  obtained from G by a series of 0 or more
  deletions of vertices, deletions of edges, and
  contraction of edges.
• Does not yield fast recognition algorithm!

5               Netwerk Algorithms: Planar graphs
                Euler’s theorem
• Let G be a connected plane graph with n vertices,
  m edges, and f faces. Then n + f – m = 2.
• Proof. By induction.
    – True if m=0.
    – If G has a circuit, then delete an edge and …
    – If G has a vertex v of degree 1, then delete v and …
• …


6                    Netwerk Algorithms: Planar graphs
               Euler’s theorem
                 Corollaries
• If G is a connected plane graph with no
  parallel edges and no self-loops, with n > 1,
  then m  3n-6.
    – Every face `has’ at least three edges; each edge
      `is on’ two faces, or twice on the same face.
• Every plane graph with no parallel edges
  and no self-loops has a vertex of degree at
  most 5.
7                  Netwerk Algorithms: Planar graphs
                       Duality
• The dual G* of a plane graph G
    – A vertex in G* for each face of G
    – An edge in G* when faces share an edge in G




8                 Netwerk Algorithms: Planar graphs
        Drawings of planar graphs
• Different types
• Vertices are:
    – Points in 2-dimensional space
    – Rectangles, other objects
• Edges are                                       Usual model
    –   Straight lines
    –   Curves
    –   Lines with bends
    –   Adjacencies or intersections of objects

9                      Netwerk Algorithms: Planar graphs
          Drawing planar graphs
In steps:
     1. Test if G is planar, and
     2. Find for each vertex, a clockwise ordering of
        its incident edges, such that these orderings
        allow a planar embedding, and then
     3. Assign coordinates to vertices



10                 Netwerk Algorithms: Planar graphs
     Planarity testing: reduction to
          biconnected graphs
• First, suppose G is biconnected.
     – G is biconnected, if for each vertex v, G-v is connected.
     – A biconnected component of G is a maximal subgraph
       that is biconnected.
     – A graph is planar, if and only if each of its biconnected
       components is planar.
        • Each biconnected component can be drawn with any vertex on
          its exterior face.
        • Build drawing of G by putting drawings of biconnected
          components together.
        • Easier argument: G has a K5 or K3,3 minor, iff a biconnected
          component of G has such a minor. But his doesn’t help to find
          the drawing…
11                     Netwerk Algorithms: Planar graphs
               Cycles with pieces
• Take a cycle C in G.
• Divide edges not on C of G into classes:
     – e and e’ in the same class if there is a path starting with
       e, ending with e’, using no vertices on C as
       intermediate points
     – A class forms a piece.
• Pieces are
     – A single edge between two vertices on C
     – A connected graph with at least one vertex not on C
12                     Netwerk Algorithms: Planar graphs
              Separating cycles
• A cycle is separating if it has at least two
  pieces.
• Plan:
     – Find separating cycle C (how?)
     – Test for each piece + C if it is planar
       (recursion)
     – Determine for each piece if it has to be drawn
       inside or outside C (matching problem; details
       follow).
13                 Netwerk Algorithms: Planar graphs
         Finding a separating cycle
•    Find a cycle C.
•    If C separating: done.
•    Otherwise, let P be the unique piece.
•    If P is a path: G is planar: done.
•    Otherwise:
     – Take two consecutive attachments v, w of P in the circular
       ordering of C, and let Q be the part of C between the attachments
       without another attachment.
     – Take a path R between v and w in P avoiding other attachments
     – C – Q + R is a separating cycle

14                       Netwerk Algorithms: Planar graphs
         The interlacement graph
• Pieces can be `inside’ or `outside’ the cycle
• Build interlacement graph
     – Each piece is a vertex in interlacement graph
     – Pieces are adjacent, when they cannot be at the
       same side (look to attachments)




15                 Netwerk Algorithms: Planar graphs
                      Theorem
• Let C be a separating cycle in G. G is a
  planar graph, if and only if
     – For each piece P, C+P is planar.
     – The interlacement graph is bipartite.

                              Gives a polynomial
                               time algorithm!



16                  Netwerk Algorithms: Planar graphs
     Interlacement graph can be built
              in O(n2) time
• For each piece
      – Partition C into intervals wrt attachments
      – For each other piece
         • Look whether all attachments are in the same
           interval
         • If not, they conflict.




17                    Netwerk Algorithms: Planar graphs
                   Algorithm
• Find a cycle C
• Test if C is separating.
• If not, use method to build separating cycle C’.
• Find pieces of C’.
• Build interlacement graph.
• Test if interlacement graph is bipartite. If not: G is
  not planar, stop.
• Otherwise, test for each piece P, recursively, if
  P+C’ is planar.
18                 Netwerk Algorithms: Planar graphs
                       Time
• O(n3).
• Can be done faster: O(n) algorithms exist.
• Finding clockwise orderings of edges per
  vertex can also be done: several details…




19             Netwerk Algorithms: Planar graphs
         Force directed methods
• Method for arbitrary graphs
• Uses physical analogy:
     – Force system
     – Method to find equilibrium state
• Advantages:
     – Relatively easy to understand and implement
     – Often reasonably nice results

20                 Netwerk Algorithms: Planar graphs
      Springs and electrical forces
                method
• Edges are springs
• Vertices repel each other
• Force on vertex:
     – fuv is force on spring F (v)   fuv   guv
     – guv is repelling force        {u ,v}E uV




21                 Netwerk Algorithms: Planar graphs
                 Spring force
• Assume some `wanted length’ of an edge
  luv. (E.g., 1.)
• Spring wants to assume length luv; force is
  proportional to difference with luv.
• Choose some stiffness of the spring kuv.’
• Force in x-direction is (y-direction similar):
                                    xu  xv
         kuv  d (u, v)  luv * d (u, v)
       {u ,.v} E
22                Netwerk Algorithms: Planar graphs
              Repelling force
• Vertices are repelling particles
• Follow inverse square law
• k’uv is strength of repulsion (choose some
   number, e.g., experimentally)
• Repelling force of v in x-direction:
           k 'uv   xu  xv
   v d (u, v) 2 d (u, v)
 uV ,u
                             Similar in y-direction


23                Netwerk Algorithms: Planar graphs
       Search for equilibrium
• Position where all vertices have a force of 0
  towards them (sum of spring and repelling
  forces)
• Springs have lengths of edges go to desired
  length
• Repelling has vertices not too close together


24             Netwerk Algorithms: Planar graphs
        Searching for equilibrium
• Numerical techniques
• Simple algorithm:
     – Take for each vertex a random position
     – Repeat:
        • Compute for each vertex its force
        • Move all vertices to new position depending on their forces
       Until in sufficient rest
• Faster algorithms exist

25                      Netwerk Algorithms: Planar graphs
               Barycenter method
• Tutte, 1960
• Differences with force method
     –   No repelling forces
     –   luv = 0
     –   Stiffness is 1
     –   Vertices at exterior face get fixed positions


26                    Netwerk Algorithms: Planar graphs
            Force on a vertex

           F (v)           ( p
                         {u ,v}E
                                           u    pv )

     Where pu is the position of u on the plane
                If v is a free vertex




27                Netwerk Algorithms: Planar graphs
         Finding equilibrium
• System of forces can be written as set of
  linear equations
• Fast converging algorithms
• For planar graphs, system can be solved in
  O(n1.5) time



28             Netwerk Algorithms: Planar graphs
      Barycenter draw pseudocode
• Place all fixed vertices at corners of
  polygon around origin, and all free vertices
  on origin
• Repeat
     – For each free vertex v do
        • x(v) = 1/degree(v) * S((u,v) in E) x(u)
        • y(v) = 1/degree(v) * S((u,v) in E) y(u)
     until sufficient convergence
29                     Netwerk Algorithms: Planar graphs
              Theorem of Tutte
• If G is a triconnected planar graph, then this
  method yields a planar drawing of G.
     – Assuming …
     – In practice, layers become smaller in the inside
• Generalizations with more complicated
  forces sometimes also have this property
• If G is not triconnected, then we can make it
  triconnected by adding edges
30                  Netwerk Algorithms: Planar graphs
     Different representations of
            planar graph
• Tesselation representation




31             Netwerk Algorithms: Planar graphs
               Topological sorts
• Directed acyclic digraphs
• Topological sort / topological ordering
• Source, sink
• st-Graph: dag with single source s, and
  single sink t.
• Properties:
     – For each v in an st-graph, there is a path from s
       to t via v
32                  Netwerk Algorithms: Planar graphs
               Planar st-graph
• Planar st-graph: plane, and s and t are on the
  exterior face.
                              F: faces of embedding
           t
                           Exterior face is represented
      s*
                                 twice: s* and t*
                t*

           s

33               Netwerk Algorithms: Planar graphs
       Dual G* of st-graph G
• Vertices of G: faces of G, but two vertices
  for external face s* and t*
• Edges for adjacent faces, but from left to
  right
                                       Each edge has left face left(e)
                                       and right face right(e)




34              Netwerk Algorithms: Planar graphs
                   Lemma
• Each face f of G consists of two directed
  paths with common origin orig(f) and
  common destination dest(f).


                          Edges also have orig(e) and dest(e):
                                 Begin and end vertex



35             Netwerk Algorithms: Planar graphs
                    Lemma
• The incoming edges of a vertex are
  consecutive, and so are the outgoing edges



      left(v)     right(v)




36              Netwerk Algorithms: Planar graphs
           G* is an st-graph
• With source s*
• And with sink t*

                    Set orig(v) = dest(v) = v
                     Set left(f) = right(f) = f




37             Netwerk Algorithms: Planar graphs
                            Lemma
• Let A and B be objects (vertices, edges, or faces).
  Exactly one of the following holds.
     –   There is a directed path in G from dest(A) to orig(B).
     –   There is a directed path in G from dest(B) to orig(A).
     –   There is a directed path in G* from right(A) to left(B).
     –   There is a directed path in G* from right(B) to left(A).




38                      Netwerk Algorithms: Planar graphs
          Making a tesselation
            representation
• Each vertex, edge, and face gets a tile (rectangle:
  can be unbounded, segment, or point).
• Interiors of distinct tiles are disjoint
• Union of all tiles is a rectangle
• Tile of object A and object B are horizontally
  adjacent, if one is left or right of the other (in
  graph.
• Tile of A and B are vertically adjacent, if one is
  orig or dest of the other.

39                Netwerk Algorithms: Planar graphs
           Tesselation algorithm
•    Make planar st-graph G*
•    Compute a topological sort Y of G
•    Compute a topological sort X of G*
•    Give each object the rectangle with x-
     coordinates X(left(A)) and X(right(A)) and
     y-coordinated Y(orig(A)) and Y(dest(A)).


40                Netwerk Algorithms: Planar graphs
              On the algorithm
• Correctness:
     – Use lemma of types of paths; showing objects
       have nonintersecting interiors.
     – Cases show that adjacencies are correct
• O(n) time



41                 Netwerk Algorithms: Planar graphs
                Fatter tiles
• Split vertices
• Add edges orig(f) to dest(f) for faces

Final drawing at most n by n.




42              Netwerk Algorithms: Planar graphs
     From tesselation to polyline
              drawing

                                                         v
             v

             e                                           e

                                                     w
         w



43               Netwerk Algorithms: Planar graphs
             Many other results
• Straight line drawings
     – with vertices on integer coordinates
     – Technique: forces
• Embeddings with only horizontal and
  vertical lines
     – Only when maximum degree at most 4
• …

44                 Netwerk Algorithms: Planar graphs

								
To top