# SPQR tree

In graph theory, a branch of mathematics, the **triconnected components** of a biconnected graph are a system of smaller graphs that describe all of the 2-vertex cuts in the graph. An **SPQR tree** is a tree data structure used in computer science, and more specifically graph algorithms, to represent the triconnected components of a graph. The SPQR tree of a graph may be constructed in linear time[1] and has several applications in dynamic graph algorithms and graph drawing.

The basic structures underlying the SPQR tree, the triconnected components of a graph, and the connection between this decomposition and the planar embeddings of a planar graph, were first investigated by Saunders Mac Lane (1937); these structures were used in efficient algorithms by several other researchers[2] prior to their formalization as the SPQR tree by Di Battista and Tamassia (1989, 1990, 1996).

## Structure

An SPQR tree takes the form of an unrooted tree in which for each node *x* there is associated an undirected graph or multigraph *G*_{x}. The node, and the graph associated with it, may have one of four types, given the initials SPQR:

- In an S node, the associated graph is a cycle graph with three or more vertices and edges. This case is analogous to series composition in series-parallel graphs; the S stands for "series".[3]
- In a P node, the associated graph is a dipole graph, a multigraph with two vertices and three or more edges, the planar dual to a cycle graph. This case is analogous to parallel composition in series-parallel graphs; the P stands for "parallel".[3]
- In a Q node, the associated graph has a single real edge. This trivial case is necessary to handle the graph that has only one edge. In some works on SPQR trees, this type of node does not appear in the SPQR trees of graphs with more than one edge; in other works, all non-virtual edges are required to be represented by Q nodes with one real and one virtual edge, and the edges in the other node types must all be virtual.
- In an R node, the associated graph is a 3-connected graph that is not a cycle or dipole. The R stands for "rigid": in the application of SPQR trees in planar graph embedding, the associated graph of an R node has a unique planar embedding.[3]

Each edge *xy* between two nodes of the SPQR tree is associated with two directed *virtual edges*, one of which is an edge in *G _{x}* and the other of which is an edge in

*G*. Each edge in a graph

_{y}*G*may be a virtual edge for at most one SPQR tree edge.

_{x}An SPQR tree *T* represents a 2-connected graph *G _{T}*, formed as follows. Whenever SPQR tree edge

*xy*associates the virtual edge

*ab*of

*G*with the virtual edge

_{x}*cd*of

*G*, form a single larger graph by merging

_{y}*a*and

*c*into a single supervertex, merging

*b*and

*d*into another single supervertex, and deleting the two virtual edges. That is, the larger graph is the 2-clique-sum of

*G*and

_{x}*G*. Performing this gluing step on each edge of the SPQR tree produces the graph

_{y}*G*; the order of performing the gluing steps does not affect the result. Each vertex in one of the graphs

_{T}*G*may be associated in this way with a unique vertex in

_{x}*G*, the supervertex into which it was merged.

_{T}Typically, it is not allowed within an SPQR tree for two S nodes to be adjacent, nor for two P nodes to be adjacent, because if such an adjacency occurred the two nodes could be merged into a single larger node. With this assumption, the SPQR tree is uniquely determined from its graph. When a graph *G* is represented by an SPQR tree with no adjacent P nodes and no adjacent S nodes, then the graphs *G*_{x} associated with the nodes of the SPQR tree are known as the triconnected components of *G*.

## Construction

The SPQR tree of a given 2-vertex-connected graph can be constructed in linear time.[1]

The problem of constructing the triconnected components of a graph was first solved in linear time by Hopcroft & Tarjan (1973). Based on this algorithm, Di Battista & Tamassia (1996) suggested that the full SPQR tree structure, and not just the list of components, should be constructible in linear time. After an implementation of a slower algorithm for SPQR trees was provided as part of the GDToolkit library, Gutwenger & Mutzel (2001) provided the first linear-time implementation. As part of this process of implementing this algorithm, they also corrected some errors in the earlier work of Hopcroft & Tarjan (1973).

The algorithm of Gutwenger & Mutzel (2001) includes the following overall steps.

- Sort the edges of the graph by the pairs of numerical indices of their endpoints, using a variant of radix sort that makes two passes of bucket sort, one for each endpoint. After this sorting step, parallel edges between the same two vertices will be adjacent to each other in the sorted list and can be split off into a P-node of the eventual SPQR tree, leaving the remaining graph simple.
- Partition the graph into split components; these are graphs that can be formed by finding a pair of separating vertices, splitting the graph at these two vertices into two smaller graphs (with a linked pair of virtual edges having the separating vertices as endpoints), and repeating this splitting process until no more separating pairs exist. The partition found in this way is not uniquely defined, because the parts of the graph that should become S-nodes of the SPQR tree will be subdivided into multiple triangles.
- Label each split component with a P (a two-vertex split component with multiple edges), an S (a split component in the form of a triangle), or an R (any other split component). While there exist two split components that share a linked pair of virtual edges, and both components have type S or both have type P, merge them into a single larger component of the same type.

To find the split components, Gutwenger & Mutzel (2001) use depth-first search to find a structure that they call a palm tree; this is a depth-first search tree with its edges oriented away from the root of the tree, for the edges belonging to the tree, and towards the root for all other edges. They then find a special preorder numbering of the nodes in the tree, and use certain patterns in this numbering to identify pairs of vertices that can separate the graph into smaller components. When a component is found in this way, a stack data structure is used to identify the edges that should be part of the new component.

## Usage

### Finding 2-vertex cuts

With the SPQR tree of a graph *G* (without Q nodes) it is straightforward to find every pair of vertices *u* and *v* in *G* such that removing *u* and *v* from *G* leaves a disconnected graph, and the connected components of the remaining graphs:

- The two vertices
*u*and*v*may be the two endpoints of a virtual edge in the graph associated with an R node, in which case the two components are represented by the two subtrees of the SPQR tree formed by removing the corresponding SPQR tree edge. - The two vertices
*u*and*v*may be the two vertices in the graph associated with a P node that has two or more virtual edges. In this case the components formed by the removal of*u*and*v*are represented by subtrees of the SPQR tree, one for each virtual edge in the node. - The two vertices
*u*and*v*may be two vertices in the graph associated with an S node such that either*u*and*v*are not adjacent, or the edge*uv*is virtual. If the edge is virtual, then the pair (*u*,*v*) also belongs to a node of type P and R and the components are as described above. If the two vertices are not adjacent then the two components are represented by two paths of the cycle graph associated with the S node and with the SPQR tree nodes attached to those two paths.

### Representing all embeddings of planar graphs

If a planar graph is 3-connected, it has a unique planar embedding up to the choice of which face is the outer face and of orientation of the embedding: the faces of the embedding are exactly the nonseparating cycles of the graph. However, for a planar graph (with labeled vertices and edges) that is 2-connected but not 3-connected, there may be greater freedom in finding a planar embedding. Specifically, whenever two nodes in the SPQR tree of the graph are connected by a pair of virtual edges, it is possible to flip the orientation of one of the nodes (replacing it by its mirror image) relative to the other one. Additionally, in a P node of the SPQR tree, the different parts of the graph connected to virtual edges of the P node may be arbitrarily permuted. All planar representations may be described in this way.[4]

## See also

- Block-cut tree, a similar tree structure for the 2-vertex-connected components
- Gomory–Hu tree, a different tree structure that characterizes the edge connectivity of a graph
- Tree decomposition, a generalization (no longer unique) to larger cuts

## Notes

- Hopcroft & Tarjan (1973); Gutwenger & Mutzel (2001).
- E.g., Hopcroft & Tarjan (1973) and Bienstock & Monma (1988), both of which are cited as precedents by Di Battista and Tamassia.
- Di Battista & Tamassia (1989).
- Mac Lane (1937).

## References

- Bienstock, Daniel; Monma, Clyde L. (1988), "On the complexity of covering vertices by faces in a planar graph",
*SIAM Journal on Computing*,**17**(1): 53–76, CiteSeerX 10.1.1.542.2314, doi:10.1137/0217004. - Di Battista, Giuseppe; Tamassia, Roberto (1989), "Incremental planarity testing",
*Proc. 30th Annual Symposium on Foundations of Computer Science*, pp. 436–441, doi:10.1109/SFCS.1989.63515. - Di Battista, Giuseppe; Tamassia, Roberto (1990), "On-line graph algorithms with SPQR-trees",
*Proc. 17th International Colloquium on Automata, Languages and Programming*, Lecture Notes in Computer Science,**443**, Springer-Verlag, pp. 598–611, doi:10.1007/BFb0032061. - Di Battista, Giuseppe; Tamassia, Roberto (1996), "On-line planarity testing" (PDF),
*SIAM Journal on Computing*,**25**(5): 956–997, doi:10.1137/S0097539794280736. - Gutwenger, Carsten; Mutzel, Petra (2001), "A linear time implementation of SPQR-trees",
*Proc. 8th International Symposium on Graph Drawing (GD 2000)*, Lecture Notes in Computer Science,**1984**, Springer-Verlag, pp. 77–90, doi:10.1007/3-540-44541-2_8. - Hopcroft, John; Tarjan, Robert (1973), "Dividing a graph into triconnected components",
*SIAM Journal on Computing*,**2**(3): 135–158, doi:10.1137/0202012, hdl:1813/6037. - Mac Lane, Saunders (1937), "A structural characterization of planar combinatorial graphs",
*Duke Mathematical Journal*,**3**(3): 460–472, doi:10.1215/S0012-7094-37-00336-3.

## External links

- SPQR tree implementation in the Open Graph Drawing Framework.
- The tree of the triconnected components Java implementation in the jBPT library (see TCTree class).