# Planar separator theorem

In graph theory, the **planar separator theorem** is a form of isoperimetric inequality for planar graphs, that states that any planar graph can be split into smaller pieces by removing a small number of vertices. Specifically, the removal of O(√*n*) vertices from an *n*-vertex graph (where the *O* invokes big O notation) can partition the graph into disjoint subgraphs each of which has at most 2*n*/3 vertices.

A weaker form of the separator theorem with O(√*n* log *n*) vertices in the separator instead of O(√*n*) was originally proven by Template:Harvtxt, and the form with the tight asymptotic bound on the separator size was first proven by Template:Harvtxt. Since their work, the separator theorem has been reproven in several different ways, the constant in the O(√*n*) term of the theorem has been improved, and it has been extended to certain classes of nonplanar graphs.

Repeated application of the separator theorem produces a separator hierarchy which may take the form of either a tree decomposition or a branch-decomposition of the graph. Separator hierarchies may be used to devise efficient divide and conquer algorithms for planar graphs, and dynamic programming on these hierarchies can be used to devise exponential time and fixed-parameter tractable algorithms for solving NP-hard optimization problems on these graphs. Separator hierarchies may also be used in nested dissection, an efficient variant of Gaussian elimination for solving sparse systems of linear equations arising from finite element methods.

## Statement of the theorem

As it is usually stated, the separator theorem states that, in any *n*-vertex planar graph *G* = (*V*,*E*), there exists a partition of the vertices of *G* into three sets *A*, *S*, and *B*, such that each of *A* and *B* has at most 2*n*/3 vertices, *S* has O(√*n*) vertices, and there are no edges with one endpoint in *A* and one endpoint in *B*. It is not required that *A* or *B* form connected subgraphs of *G*. *S* is called the **separator** for this partition.

An equivalent formulation is that the edges of any *n*-vertex planar graph *G* may be subdivided into two edge-disjoint subgraphs *G*_{1} and *G*_{2} in such a way that both subgraphs have at least *n*/3 vertices and such that the intersection of the vertex sets of the two subgraphs has O(√*n*) vertices in it. Such a partition is known as a **separation**.^{[1]} If a separation is given, then the intersection of the vertex sets forms a separator, and the vertices that belong to one subgraph but not the other form the separated subsets of at most 2*n*/3 vertices. In the other direction, if one is given a partition into three sets *A*, *S*, and *B* that meet the conditions of the planar separator theorem, then one may form a separation in which the edges with an endpoint in *A* belong to *G*_{1}, the edges with an endpoint in *B* belong to *G*_{2}, and the remaining edges (with both endpoints in *S*) are partitioned arbitrarily.

The constant 2/3 in the statement of the separator theorem is arbitrary and may be replaced by any other number in the open interval (1/2,1) without changing the form of the theorem: a partition into more equal subsets may be obtained from a less-even partition by repeatedly splitting the larger sets in the uneven partition and regrouping the resulting connected components.^{[2]}

## Example

Consider a grid graph with *r* rows and *c* columns; the number *n* of vertices equals *rc*. For instance, in the illustration, *r* = 5, *c* = 8, and *n* = 40. If *r* is odd, there is a single central row, and otherwise there are two rows equally close to the center; similarly, if *c* is odd, there is a single central column, and otherwise there are two columns equally close to the center. Choosing *S* to be any of these central rows or columns, and removing *S* from the graph, partitions the graph into two smaller connected subgraphs *A* and *B*, each of which has at most *n*/2 vertices. If *r* ≤ *c* (as in the illustration), then choosing a central column will give a separator *S* with *r* ≤ √*n* vertices, and similarly if *c* ≤ *r* then choosing a central row will give a separator with at most √*n* vertices. Thus, every grid graph has a separator *S* of size at most √*n*, the removal of which partitions it into two connected components, each of size at most *n*/2.^{[3]}

The planar separator theorem states that a similar partition can be constructed in any planar graph. The case of arbitrary planar graphs differs from the case of grid graphs in that the separator has size O(√*n*) but may be larger than √*n*, the bound on the size of the two subsets *A* and *B* (in the most common versions of the theorem) is 2*n*/3 rather than *n*/2, and the two subsets *A* and *B* need not themselves form connected subgraphs.

## Constructions

### Breadth-first layering

Template:Harvtxt augment the given planar graph by additional edges, if necessary, so that it becomes maximal planar (every face in a planar embedding is a triangle). They then perform a breadth-first search, rooted at an arbitrary vertex *v*, and partition the vertices into levels by their distance from *v*. If *l*_{1} is the median level (the level such that the numbers of vertices at higher and lower levels are both at most *n*/2) then there must be levels *l*_{0} and *l*_{2} that are O(√*n*) steps above and below *l*_{1} respectively and that contain O(√*n*) vertices, respectively, for otherwise there would be more than *n* vertices in the levels near *l*_{1}. They show that there must be a separator *S* formed by the union of *l*_{0} and *l*_{2}, the endpoints *e* of an edge of *G* that does not belong to the breadth-first search tree and that lies between the two levels, and the vertices on the two breadth-first search tree paths from *e* back up to level *l*_{0}. The size of the separator *S* constructed in this way is at most √8√*n*, or approximately 2.83√*n*. The vertices of the separator and the two disjoint subgraphs can be found in linear time.

This proof of the separator theorem applies as well to weighted planar graphs, in which each vertex has a non-negative cost. The graph may be partitioned into three sets *A*, *S*, and *B* such that *A* and *B* each have at most 2/3 of the total cost and *S* has O(√*n*) vertices, with no edges from *A* to *B*.^{[4]} By analysing a similar separator construction more carefully, Template:Harvtxt shows that the bound on the size of *S* can be reduced to √6√*n*, or approximately 2.45√*n*.

Template:Harvtxt suggest a simplified version of this approach: they augment the graph to be maximal planar and construct a breadth first search tree as before. Then, for each edge *e* that is not part of the tree, they form a cycle by combining *e* with the tree path that connects its endpoints. They then use as a separator the vertices of one of these cycles. Although this approach cannot be guaranteed to find a small separator for planar graphs of high diameter, their experiments indicate that it outperforms the Lipton–Tarjan and Djidjev breadth-first layering methods on many types of planar graph.

### Simple cycle separators

For a graph that is already maximal planar it is possible to show a stronger construction of a **simple cycle separator**, a cycle of small length such that the inside and the outside of the cycle (in the unique planar embedding of the graph) each have at most 2*n*/3 vertices. Template:Harvtxt proves this (with a separator size of √8√*n*) by using the Lipton–Tarjan technique for a modified version of breadth first search in which the levels of the search form simple cycles.

Template:Harvtxt prove the existence of simple cycle separators more directly: they let *C* be a cycle of at most √8√*n* vertices, with at most 2*n*/3 vertices outside *C*, that forms as even a partition of inside and outside as possible, and they show that these assumptions force *C* to be a separator. For otherwise, the distances within *C* must equal the distances in the disk enclosed by *C* (a shorter path through the interior of the disk would form part of the boundary of a better cycle). Additionally, *C* must have length exactly √8√*n*, as otherwise it could be improved by replacing one of its edges by the other two sides of a triangle. If the vertices in *C* are numbered (in clockwise order) from 1 to √8√*n*, and vertex *i* is matched up with vertex √8√*n* − *i* + 1, then these matched pairs can be connected by vertex-disjoint paths within the disk, by a form of Menger's theorem for planar graphs. However, the total length of these paths would necessarily exceed *n*, a contradiction. With some additional work they show by a similar method that there exists a simple cycle separator of size at most (3/√2)√*n*, approximately 2.12√*n*.

Template:Harvtxt further improved the constant factor in the simple cycle separator theorem to 1.97√*n*. Their method can also find simple cycle separators for graphs with non-negative vertex weights, with separator size at most 2√*n*, and can generate separators with smaller size at the expense of a more uneven partition of the graph. In 2-connected planar graphs that are not maximal, there exist simple cycle separators with size proportional to the Euclidean norm of the vector of face lengths that can be found in near-linear time.^{[5]}

### Circle separators

According to the Koebe–Andreev–Thurston circle-packing theorem, any planar graph may be represented by a packing of circular disks in the plane with disjoint interiors, such that two vertices in the graph are adjacent if and only if the corresponding pair of disks are mutually tangent. As Template:Harvtxt show, for such a packing, there exists a circle that has at most 3*n*/4 disks touching or inside it, at most 3*n*/4 disks touching or outside it, and that crosses O(√*n* disks).

To prove this, Miller et al. use stereographic projection to map the packing onto the surface of a unit sphere in three dimensions. By choosing the projection carefully, the center of the sphere can be made into a centerpoint of the disk centers on its surface, so that any plane through the center of the sphere partitions it into two halfspaces that each contain or cross at most 3*n*/4 of the disks. If a plane through the center is chosen uniformly at random, a disk will be crossed with probability proportional to its radius. Therefore, the expected number of disks that are crossed is proportional to the sum of the radii of the disks. However, the sum of the squares of the radii is proportional to the total area of the disks, which is at most the total surface area of the unit sphere, a constant. An argument involving Jensen's inequality shows that, when the sum of squares of *n* non-negative real numbers is bounded by a constant, the sum of the numbers themselves is O(√*n*). Therefore, the expected number of disks crossed by a random plane is O(√*n*) and there exists a plane that crosses at most that many disks. This plane intersects the sphere in a great circle, which projects back down to a circle in the plane with the desired properties. The O(√*n*) disks crossed by this circle correspond to the vertices of a planar graph separator that separates the vertices whose disks are inside the circle from the vertices whose disks are outside the circle, with at most 3*n*/4 vertices in each of these two subsets.^{[6]}^{[7]}

This method leads to a randomized algorithm that finds such a separator in linear time,^{[6]} and a less-practical deterministic algorithm with the same linear time bound.^{[8]} By analyzing this algorithm carefully using known bounds on the packing density of circle packings, it can be shown to find separators of size at most

Although this improved separator size bound comes at the expense of a more-uneven partition of the graph, Template:Harvtxt argue that it provides an improved constant factor in the time bounds for nested dissection compared to the separators of Template:Harvtxt. The size of the separators it produces can be further improved, in practice, by using a nonuniform distribution for the random cutting planes.^{[10]}

The stereographic projection in the Miller et al. argument can be avoided by considering the smallest circle containing a constant fraction of the centers of the disks and then expanding it by a constant picked uniformly in the range [1,2]. It is easy to argue, as in Miller et al., that the disks intersecting the expanded circle form a valid separator, and that, in expectation, the separator is of the right size. The resulting constants are somewhat worse.^{[11]}

### Spectral partitioning

Spectral clustering methods, in which the vertices of a graph are grouped by the coordinates of the eigenvectors of matrices derived from the graph, have long been used as a heuristic for graph partitioning problems for nonplanar graphs.^{[12]} As Template:Harvtxt show, spectral clustering can also be used to derive an alternative proof for a weakened form of the planar separator theorem that applies to planar graphs with bounded degree. In their method, the vertices of a given planar graph are sorted by the second coordinates of the eigenvectors of the Laplacian matrix of the graph, and this sorted order is partitioned at the point that minimizes the ratio of the number of edges cut by the partition to the number of vertices on the smaller side of the partition. As they show, every planar graph of bounded degree has a partition of this type in which the ratio is O(1/√*n*). Although this partition may not be balanced, repeating the partition within the larger of the two sides and taking the union of the cuts formed at each repetition will eventually lead to a balanced partition with O(√*n*) edges. The endpoints of these edges form a separator of size O(√*n*).

### Edge separators

A variation of the planar separator theorem involves **edge separators**, small sets of edges forming a cut between two subsets *A* and *B* of the vertices of the graph. The two sets *A* and *B* must each have size at most a constant fraction of the number *n* of vertices of the graph (conventionally, both sets have size at most 2*n*/3), and each vertex of the graph belongs to exactly one of *A* and *B*. The separator consists of the edges that have one endpoint in *A* and one endpoint in *B*. Bounds on the size of an edge separator involve the degree of the vertices as well as the number of vertices in the graph: the planar graphs in which one vertex has degree *n* − 1, including the wheel graphs and star graphs, have no edge separator with a sublinear number of edges, because any edge separator would have to include all the edges connecting the high degree vertex to the vertices on the other side of the cut. However, every planar graph with maximum degree Δ has an edge separator of size O(√(Δ*n*)).^{[13]}

A simple cycle separator in the dual graph of a planar graph forms an edge separator in the original graph.^{[14]}
Applying the simple cycle separator theorem of Template:Harvtxt to the dual graph of a given planar graph strengthens the O(√(Δ*n*)) bound for the size of an edge separator by showing that every planar graph has an edge separator whose size is proportional to the Euclidean norm of its vector of vertex degrees.

Template:Harvtxt describe a polynomial time algorithm for finding the smallest edge separator that partitions a graph *G* into two subgraphs of equal size, when *G* is an induced subgraph of a grid graph with no holes or with a constant number of holes. However, they conjecture that the problem is NP-complete for arbitrary planar graphs, and they show that the complexity of the problem is the same for grid graphs with arbitrarily many holes as it is for arbitrary planar graphs.

## Lower bounds

In a √*n* × √*n* grid graph, a set *S* of *s* < √*n* points can enclose a subset of at most *s*(*s* − 1)/2 grid points, where the maximum is achieved by arranging *S* in a diagonal line near a corner of the grid. Therefore, in order to form a separator that separates at least *n*/3 of the points from the remaining grid, *s* needs to be at least √(2*n*/3), approximately 0.82√*n*.

There exist *n*-vertex planar graphs (for arbitrarily large values of *n*) such that, for every separator *S* that partitions the remaining graph into subgraphs of at most 2*n*/3 vertices, *S* has at least √(4π√3)√*n* vertices, approximately 1.56√*n*.^{[2]} The construction involves approximating a sphere by a convex polyhedron, replacing each of the faces of the polyhedron by a triangular mesh, and applying isoperimetric theorems for the surface of the sphere.

## Separator hierarchies

Separators may be combined into a **separator hierarchy** of a planar graph, a recursive decomposition into smaller graphs. A separator hierarchy may be represented by a binary tree in which the root node represents the given graph itself, and the two children of the root are the roots of recursively constructed separator hierarchies for the induced subgraphs formed from the two subsets *A* and *B* of a separator.

A separator hierarchy of this type forms the basis for a tree decomposition of the given graph, in which the set of vertices associated with each tree node is the union of the separators on the path from that node to the root of the tree. Since the sizes of the graphs go down by a constant factor at each level of the tree, the upper bounds on the sizes of the separators also go down by a constant factor at each level, so the sizes of the separators on these paths add in a geometric series to O(√*n*). That is, a separator formed in this way has width O(√*n*), and can be used to show that every planar graph has treewidth O(√*n*).

Constructing a separator hierarchy directly, by traversing the binary tree top down and applying a linear-time planar separator algorithm to each of the induced subgraphs associated with each node of the binary tree, would take a total of O(*n* log *n*) time. However, it is possible to construct an entire separator hierarchy in linear time, by using the Lipton–Tarjan breadth-first layering approach and by using appropriate data structures to perform each partition step in sublinear time.^{[15]}

If one forms a related type of hierarchy based on separations instead of separators, in which the two children of the root node are roots of recursively constructed hierarchies for the two subgraphs *G*_{1} and *G*_{2} of a separation of the given graph, then the overall structure forms a branch-decomposition instead of a tree decomposition. The width of any separation in this decomposition is, again, bounded by the sum of the sizes of the separators on a path from any node to the root of the hierarchy, so any branch-decomposition formed in this way has width O(√*n*) and any planar graph has branchwidth O(√*n*). Although many other related graph partitioning problems are NP-complete, even for planar graphs, it is possible to find a minimum-width branch-decomposition of a planar graph in polynomial time.^{[16]}

By applying methods of Template:Harvtxt more directly in the construction of branch-decompositions, Template:Harvtxt show that every planar graph has branchwidth at most 2.12√*n*, with the same constant as the one in the simple cycle separator theorem of Alon et al. Since the treewidth of any graph is at most 3/2 its branchwidth, this also shows that planar graphs have treewidth at most 3.18√*n*.

## Other classes of graphs

Some sparse graphs do not have separators of sublinear size: in an expander graph, deleting up to a constant fraction of the vertices still leaves only one connected component.^{[17]}

Possibly the earliest known separator theorem is a result of Template:Harvtxt that any tree can be partitioned into subtrees of at most 2*n*/3 vertices each by the removal of a single vertex.^{[6]} In particular, the vertex that minimizes the maximum component size has this property, for if it did not then its neighbor in the unique large subtree would form an even better partition. By applying the same technique to a tree decomposition of an arbitrary graph, it is possible to show that any graph has a separator of size at most equal to its treewidth.

If a graph *G* is not planar, but can be embedded on a surface of genus *g*, then it has a separator with O((*gn*)^{1/2}) vertices. Template:Harvtxt prove this by using a similar approach to that of Template:Harvtxt. They group the vertices of the graph into breadth-first levels and find two levels the removal of which leaves at most one large component consisting of a small number of levels. This remaining component can be made planar by removing a number of breadth-first paths proportional to the genus, after which the Lipton–Tarjan method can be applied to the remaining planar graph. The result follows from a careful balancing of the size of the removed two levels against the number of levels between them. If the graph embedding is given as part of the input, its separator can be found in linear time. Graphs of genus *g* also have edge separators of size O((*g*Δ*n*)^{1/2}).^{[18]}

Graphs of bounded genus form an example of a family of graphs closed under the operation of taking minors, and separator theorems also apply to arbitrary minor-closed graph families. In particular, if a graph family has a forbidden minor with *h* vertices, then it has a separator with O(*h*√*n*) vertices, and such a separator can be found in time O(*n*^{1 + ε}) for any ε > 0.^{[19]}

The circle separator method of Template:Harvtxt generalizes to the intersection graphs of any system of *d*-dimensional balls with the property that any point in space is covered by at most some constant number *k* of balls, to *k*-nearest-neighbor graphs in *d* dimensions,^{[6]} and to the graphs arising from finite element meshes.^{[20]} The sphere separators constructed in this way partition the input graph into subgraphs of at most *n*(*d* + 1)/(*d* + 2) vertices. The size of the separators for *k*-ply ball intersection graphs and for *k*-nearest-neighbor graphs is O(*k*^{1/d}*n*^{1 − 1/d}).^{[6]}

## Applications

### Divide and conquer algorithms

Separator decompositions can be of use in designing efficient divide and conquer algorithms for solving problems on planar graphs. As an example, one problem that can be solved in this way is to find the shortest cycle in a weighted planar digraph. This may be solved by the following steps:

- Partition the given graph
*G*into three subsets*S*,*A*,*B*according to the planar separator theorem - Recursively search for the shortest cycles in
*A*and*B* - Use Dijkstra's algorithm to find, for each
*s*in*S*, the shortest cycle through*s*in*G*. - Return the shortest of the cycles found by the above steps.

The time for the two recursive calls to *A* and *B* in this algorithm is dominated by the time to perform the O(√*n*) calls to Dijkstra's algorithm, so this algorithm finds the shortest cycle in O(*n*^{3/2} log *n*) time.

A faster algorithm for the same shortest cycle problem, running in time O(*n* log^{3}*n*), was given by Template:Harvtxt. His algorithm uses the same separator-based divide and conquer structure, but uses simple cycle separators rather than arbitrary separators, so that the vertices of *S* belong to a single face of the graphs inside and outside the cycle separator. He then replaces the O(√*n*) separate calls to Dijkstra's algorithm with more sophisticated algorithms to find shortest paths from all vertices on a single face of a planar graph and to combine the distances from the two subgraphs. For weighted but undirected planar graphs, the shortest cycle is equivalent to the minimum cut in the dual graph and can be found in O(*n* log log *n*) time,^{[21]} and the shortest cycle in an unweighted undirected planar graph (its girth) may be found in time O(*n*).^{[22]} (However, the faster algorithm for unweighted graphs is not based on the separator theorem.)

Frederickson proposed another faster algorithm for single source shortest paths by implementing separator theorem in planar graphs in 1986.^{[23]} This is an improvement of Dijkstra's algorithm with iterative search on a carefully selected subset of the vertices. This version takes O(*n* √(log *n*)) time in an *n*-vertex graph. Separators are used to find a division of a graph, that is, a partition of the edge-set into two or more subsets, called regions. A node is said to be contained in a region if some edge of the region is incident to the node. A node contained in more that one region is called a boundary node of the regions containing it. The method uses the notion of a *r*-division of an *n*-node graph that is a graph division into O(*n*/*r*) regions, each containing O(*r*) nodes including O(√*r*) boundary nodes. Frederickson showed that an *r*-division can be found in O(*n* log *n*) time by recursive application of separator theorem.

The sketch of his algorithm to solve the problem is as follows.

1. Preprocessing Phase: Partition the graph into carefully selected subsets of vertices and determine the shortest paths between all pairs of vertices in these subsets, where intermediate vertices on this path are not in the subset. This phase requires a planar graph *G*_{0} to be transformed into *G* with no vertex having degree greater than 3. From a corollary of Euler's formula, the number of vertices in the resulting graph will be *n* ≤ 6*n*_{0} -12, where *n*_{0} is the number of vertices in *G*_{0} . This phase also ensures the following properties of a suitable *r*-division. A suitable *r*-division of a planar graph is an *r*-division such that,

- each boundary vertex is contained in at most three regions, and
- any region that is not connected consists of connected components, all of which share boundary vertices with exactly the same set of either one or two connected regions.

2. Search Phase:

- Main Thrust: Find Shortest distances from the source to each vertex in the subset. When a vertex
*v*in the subset is closed,*d*(*w*) must be updated for all vertices*w*in the subset such that a path exists from*v*to*w*. - Mop-up: Determine shortest distances to every remaining vertex.

Henzinger et. al. extended Frederickson's *r*-division technique for the single source shortest path algorithm in planar graphs for nonnegative edge-lengths and proposed a linear time algorithm.^{[24]} Their method generalizes Frederickson's notion of graph-divisions such that now an (*r*,*s*)-division of an *n*-node graph be a division into O(*n*/*r*) regions, each containing *r*^{{O(1)}} nodes, each having at most *s* boundary nodes. If an (*r*, *s*)-division is repeatedly divided into smaller regions, that is called get a recursive division. This algorithm uses approximately log**n* levels of divisions. The recursive division is represented by a rooted tree whose leaves are labeled by distinct edge of *G*. The root of the tree represents the region consisting of full-*G*, the children of the root represent the subregions into which that region is divided and so on. Each leaf (atomic region) represents a region containing exactly one edge.

Nested dissection is a separator based divide and conquer variation of Gaussian elimination for solving sparse symmetric systems of linear equations with a planar graph structure, such as the ones arising from the finite element method. It involves finding a separator for the graph describing the system of equations, recursively eliminating the variables in the two subproblems separated from each other by the separator, and then eliminating the variables in the separator.^{[3]} The fill-in of this method (the number of nonzero coefficients of the resulting Cholesky decomposition of the matrix) is O(*n* log *n*),^{[25]} allowing this method to be competitive with iterative methods for the same problems.^{[3]}

Klein, Mozes and Weimann ^{[26]} gave an O(*n* log^{2} *n*)-time, linear-space algorithm to find the shortest path distances from *s* to all nodes for a directed planar graph with positive and negative arc-lengths containing no negative cycles. Their algorithm uses planar graph separators to find a Jordan curve *C* that passes through O(√*n*) nodes (and no arcs) such that between *n*/3 and 2*n*/3 nodes are enclosed by *C*. Nodes through which *C* passes are boundary nodes. The original graph *G* is separated into two subgraphs *G*_{0} and *G*_{1} by cutting the planar embedding along *C* and duplicating the boundary nodes. For *i* = 0 and 1, in *G*_{i} the boundary nodes lie on the boundary of a single face *F*_{i} .

The overview of their approach is given below.

- Recursive call: The first stage recursively computes the distances from
*r*within*G*_{i}for*i*= 0, 1. - Intra-part boundary-distances: For each graph
*G*_{i}compute all distances in G_{i}between boundary nodes. This takes O(*n*log*n*) time. - Single-source inter-part boundary distances: A shortest path in
*G*passes back and forth between G_{0}and G_{1}to compute the distances in*G*from*r*to all the boundary nodes. Alternating iterations use the all-boundary-distances in $G_{0}and $G_{1}. The number of iterations is O(√*n*), so the overall time for this stage is O(*n*α(*n*)) where α(n) is the inverse Ackermann function. - Single-source inter-part distances: The distances computed in the previous stages are used, together with a Dijkstra computation within a modified version of each G
_{i}, to compute the distances in*G*from*r*to all the nodes. This stage takes O(*n*log*n*) time. - Rerooting single-source distances: The distances from
*r*in*G*are transformed into nonnegative lengths, and again Dijkstra’s algorithm is used to compute distances from*s*. This stage requires O(*n*log*n*) time.

An important part of this algorithm is the use of Price Functions and Reduced Lengths. For a directed graph *G* with arc-lengths ι(·), a price function is a function φ from the nodes of *G* to the real numbers. For an arc *uv*, the reduced length with respect to φ is ιφ(*uv*) = ι(*uv*) + φ(*u*) − φ(*v*). A feasible price function is a price function that induces nonnegative reduced lengths on all arcs of *G*. It is useful in transforming a shortest-path problem involving positive and negative lengths into one involving only nonnegative lengths, which can then be solved using Dijkstra’s algorithm.

The separator based divide and conquer paradigm has also been used to design data structures for dynamic graph algorithms^{[27]} and point location,^{[28]} algorithms for polygon triangulation,^{[15]} shortest paths,^{[29]} and the construction of nearest neighbor graphs,^{[30]} and approximation algorithms for the maximum independent set of a planar graph.^{[28]}

### Exact solution of NP-hard optimization problems

By using dynamic programming on a tree decomposition or branch-decomposition of a planar graph, many NP-hard optimization problems may be solved in time exponential in √*n* or √*n* log *n*. For instance, bounds of this form are known for finding maximum independent sets, Steiner trees, and Hamiltonian cycles, and for solving the travelling salesman problem on planar graphs.^{[31]} Similar methods involving separator theorems for geometric graphs may be used to solve Euclidean travelling salesman problem and Steiner tree construction problems in time bounds of the same form.^{[32]}

For parameterized problems that admit a kernelization that preserves planarity and reduces the input graph to a kernel of size linear in the input parameter, this approach can be used to design fixed-parameter tractable algorithms the running time of which depends polynomially on the size of the input graph and exponentially on √*k*, where *k* is the parameter of the algorithm. For instance, time bounds of this form are known for finding vertex covers and dominating sets of size *k*.^{[33]}

### Approximation algorithms

Template:Harvtxt observed that the separator theorem may be used to obtain polynomial time approximation schemes for NP-hard optimization problems on planar graphs such as finding the maximum independent set. Specifically, by truncating a separator hierarchy at an appropriate level, one may find a separator of size O(*n*/√log *n*) the removal of which partitions the graph into subgraphs of size *c* log *n*, for any constant *c*. By the four-color theorem, there exists an independent set of size at least *n*/4, so the removed nodes form a negligible fraction of the maximum independent set, and the maximum independent sets in the remaining subgraphs can be found independently in time exponential in their size. By combining this approach with later linear-time methods for separator hierarchy construction^{[15]} and with table lookup to share the computation of independent sets between isomorphic subgraphs, it can be made to construct independent sets of size within a factor of 1 − O(1/√log *n*) of optimal, in linear time. However, for approximation ratios even closer to 1 than this factor, a later approach of Template:Harvtxt (based on tree-decomposition but not on planar separators) provides better tradeoffs of time versus approximation quality.

Similar separator-based approximation schemes have also been used to approximate other hard problems such as vertex cover.^{[34]} Template:Harvtxt use separators in a different way to approximate the travelling salesman problem for the shortest path metric on weighted planar graphs; their algorithm uses dynamic programming to find the shortest tour that, at each level of a separator hierarchy, crosses the separator a bounded number of times, and they show that as the crossing bound increases the tours constructed in this way have lengths that approximate the optimal tour.

### Graph compression

Separators have been used as part of data compression algorithms for representing planar graphs and other separable graphs using a small number of bits. The basic principle of these algorithms is to choose a number *k* and repeatedly subdivide the given planar graph using separators into O(*n*/*k*) subgraphs of size at most *k*, with O(*n*/√*k*) vertices in the separators. With an appropriate choice of *k* (at most proportional to the logarithm of *n*) the number of non-isomorphic *k*-vertex planar subgraphs is significantly less than the number of subgraphs in the decomposition, so the graph can be compressed by constructing a table of all the possible non-isomorphic subgraphs and representing each subgraph in the separator decomposition by its index into the table. The remainder of the graph, formed by the separator vertices, may be represented explicitly or by using a recursive version of the same data structure. Using this method, planar graphs and many more restricted families of planar graphs may be encoded using a number of bits that is information-theoretically optimal: if there are *P _{n}*

*n*-vertex graphs in the family of graphs to be represented, then an individual graph in the family can be represented using only (1 + o(

*n*))log

_{2}

*P*bits.

_{n}^{[35]}It is also possible to construct representations of this type in which one may test adjacency between vertices, determine the degree of a vertex, and list neighbors of vertices in constant time per query, by augmenting the table of subgraphs with additional tabular information representing the answers to the queries.

^{[36]}

^{[37]}

### Universal graphs

A universal graph for a family *F* of graphs is a graph that contains every member of *F* as a subgraphs. Separators can be used to show that the *n*-vertex planar graphs have universal graphs with *n* vertices and O(*n*^{3/2}) edges.^{[38]}

The construction involves a strengthened form of the separator theorem in which the size of the three subsets of vertices in the separator does not depend on the graph structure: there exists a number *c*, the magnitude of which at most a constant times √*n*, such that the vertices of every *n*-vertex planar graph can be separated into subsets *A*, *S*, and *B*, with no edges from *A* to *B*, with |*S*| = *c*, and with |*A*| = |*B*| = (*n* − *c*)/2. This may be shown by using the usual form of the separator theorem repeatedly to partition the graph until all the components of the partition can be arranged into two subsets of fewer than *n*/2 vertices, and then moving vertices from these subsets into the separator as necessary until it has the given size.

Once a separator theorem of this type is shown, it can be used to produce a separator hierarchy for *n*-vertex planar graphs that again does not depend on the graph structure: the tree-decomposition formed from this hierarchy has width O(√*n*) and can be used for any planar graph. The set of all pairs of vertices in this tree-decomposition that both belong to a common node of the tree-decomposition forms a trivially perfect graph with O(*n*^{3/2}) vertices that contains every *n*-vertex planar graph as a subgraph. A similar construction shows that bounded-degree planar graphs have universal graphs with O(*n* log *n*) edges, where the constant hidden in the O notation depends on the degree bound. Any universal graph for planar graphs (or even for trees of unbounded degree) must have Ω(*n* log *n*) edges, but it remains unknown whether this lower bound or the O(*n*^{3/2}) upper bound is tight for universal graphs for arbitrary planar graphs.^{[38]}

## See also

## Notes

- ↑ Template:Harvtxt.
- ↑
^{2.0}^{2.1}Template:Harvtxt. - ↑
^{3.0}^{3.1}^{3.2}Template:Harvtxt. Instead of using a row or column of a grid graph, George partitions the graph into four pieces by using the union of a row and a column as a separator. - ↑ Template:Harvtxt.
- ↑ Template:Harvtxt.
- ↑
^{6.0}^{6.1}^{6.2}^{6.3}^{6.4}Template:Harvtxt. - ↑ Template:Harvtxt.
- ↑ Template:Harvtxt.
- ↑ Template:Harvtxt.
- ↑ Template:Harvtxt.
- ↑ Template:Harvtxt.
- ↑ Template:Harvtxt; Template:Harvtxt.
- ↑ Template:Harvtxt proved this result for 2-connected planar graphs, and Template:Harvtxt extended it to all planar graphs.
- ↑ Template:Harvtxt; Template:Harvtxt.
- ↑
^{15.0}^{15.1}^{15.2}Template:Harvtxt. - ↑ Template:Harvtxt.
- ↑ Template:Harvtxt; Template:Harvtxt.
- ↑ Template:Harvtxt.
- ↑ Template:Harvtxt. For earlier work on separators in minor-closed families see Template:Harvtxt, Template:Harvtxt, and Template:Harvtxt.
- ↑ Template:Harvtxt.
- ↑ Template:Harvtxt.
- ↑ Template:Harvtxt.
- ↑ Greg n. Frederickson, Fast algorithms for shortest paths in planar graphs, with applications, SIAM J. Computing, pp. 1004-1022, 1987.
- ↑ Monika R. Henzinger , Philip Klein , Satish Rao , Sairam Subramanian, \textit{Faster shortest-path algorithms for planar graphs}, Journal of Computer and System Science, Vol. 55, Issue 1, August 1997.
- ↑ Template:Harvtxt; Template:Harvtxt.
- ↑ Philip N. Klein, Shay Mozes and Oren Weimann, Shortest Paths in Directed Planar Graphs with Negative Lengths: a Linear-Space O(n log
^{2}n)-Time Algorithm}, Proceedings of the Twentieth Annual ACM-SIAM Symposium on Discrete Algorithms, 2009. - ↑ Template:Harvtxt; Template:Harvtxt.
- ↑
^{28.0}^{28.1}Template:Harvtxt. - ↑ Template:Harvtxt; Template:Harvtxt.
- ↑ Template:Harvtxt.
- ↑ Template:Harvtxt; Template:Harvtxt; Template:Harvtxt; Template:Harvtxt.
- ↑ Template:Harvtxt.
- ↑ Template:Harvtxt; Template:Harvtxt.
- ↑ Template:Harvtxt; Template:Harvtxt.
- ↑ Template:Harvtxt.
- ↑ Template:Harvtxt.
- ↑ Template:Harvtxt.
- ↑
^{38.0}^{38.1}Template:Harvtxt; Template:Harvtxt; Template:Harvtxt.

## References

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}. As cited by Template:Harvtxt.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}. As cited by Template:Harvtxt.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}.

- {{#invoke:citation/CS1|citation

|CitationClass=citation }}. Template:Refend