# Network Algorithms Planar Graphs by ewghwehws

VIEWS: 1 PAGES: 44

• pg 1
```									       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
– 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
• 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
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