Schematic Representation of Large Biconnected Graphs

Suppose that a biconnected graph is given, consisting of a large component plus several other smaller components, each separated from the main component by a separation pair. We investigate the existence and the computation time of schematic representations of the structure of such a graph where the main component is drawn as a disk, the vertices that take part in separation pairs are points on the boundary of the disk, and the small components are placed outside the disk and are represented as non-intersecting lunes connecting their separation~pairs. We consider several drawing conventions for such schematic representations, according to different ways to account for the size of the small components. We map the problem of testing for the existence of such representations to the one of testing for the existence of suitably constrained $1$-page book-embeddings and propose several polynomial-time and pseudo-polynomial-time algorithms.


Introduction
Many of today's applications are based on large-scale networks, having billions of vertices and edges. This spurred an intense research activity devoted to finding methods for the visualization of very large graphs. Several recent contributions focus on algorithms that produce drawings where either the graph is only partially represented or it is schematically visualized. Examples of the first type are proxy drawings [7,13], where a graph that is too large to be fully visualized is represented by the drawing of a much smaller proxy graph that preserves the main features of the original graph. Examples of the second type are graph thumbnails [16], where each connected component of a graph is represented by a disk and biconnected components are represented by disks contained into the disk of the connected component they belong to.
Among the characteristics that are emphasized by the above mentioned drawings, a crucial role is played by connectivity. Following this line of thought, we study schematic representations of graphs that emphasize their connectivity features. We start from the following observation: quite often, real-life very large This research was supported in part by MIUR Project "AHeAD" under PRIN 20174LF3T8, by H2020-MSCA-RISE Proj. "CONNECT" n • 734922, and by Roma Tre University Azione 4 Project "GeoView". graphs have one large connected component and several much smaller other components (see, e.g., [5,12]). This happens to biconnected and triconnected components too (see, e.g., [2] for an analysis of the graphs in [9]).
Hence, we concentrate on a single biconnected graph (that can be a biconnected component of a larger graph) consisting of a large component plus several other smaller components, each separated from the large component by a separation pair. We propose to represent the large component as a disk, to draw the vertices of such a component that take part in separation pairs as points on the boundary of the disk, and to represent the small components as non-intersecting lunes connecting their separation pairs placed outside the disk. See Fig. 1. This representation is designed to emphasize the arrangement of the components with respect to the separation pairs. For simplicity, we assume that each separation pair separates just one small component from the large one.
More formally, our input is a weighted graph G = (V, E, ω), where each vertex in V participates in at least one separation pair, each edge (u, v) of E represents a small component separated from the large one by the separation pair {u, v}, and ω assigns a positive weight to each edge. The weight of an edge represents a feature that should be emphasized in the schematic representation. As an example, it might represent the number of vertices or edges of the corresponding small component. We study one-dimensional and two-dimensional representations. In both cases, the vertices of G are linearly ordered points that are placed along the boundary of a disk. In the one-dimensional representations, we draw each edge as an arc and impose that arcs do not cross. Also, consider two edges (u, v) and (x, y) and suppose that the weight of (u, v) is larger than that of (x, y). Then we impose that (u, v) is drawn outside (x, y), so to represent the weight by means of the edge length. We call max-constrained book-embedding this type of representation (see Fig. 1(a)). In Sec. 3 we present a polynomialtime algorithm that tests whether a graph admits such a representation. We also study a more constrained type of representation. Namely, let (u, v) be an edge and consider the sequence of edges (u 1 , v 1 ), . . . , (u k , v k ) that are drawn immediately below (u, v); then, we may want that ω(u, v) > sum-constrained book-embedding this type of representation. In Sec. 4 we present a pseudo-polynomial-time algorithm that tests whether a graph admits such a representation. Both max-and sum-constrained book-embeddings are 1-page book-embeddings satisfying specific constraints. Hence, a necessary condition for G to admit these types of representations is outerplanarity [1].
Since there exist weighted outerplanar graphs that admit neither a maxconstrained nor a sum-constrained book-embedding, in Sec. 5 we study how to represent planarly a weighted outerplanar graph with edges that have, in addition to a length, also a thickness: each edge is represented with a lune with area proportional to its weight. We call these representations two-dimensional bookembeddings. See Fig. 1(b). First, we show that all weighted outerplanar graphs admit a two-dimensional book-embedding and discuss the area requirements of such representations. Second, we show that, if a finite resolution rule is imposed, then there are graphs that do not admit any two-dimensional book-embedding and we present a polynomial-time algorithm to test whether a graph admits such a representation. Conclusions are presented in Sec. 6. Because of space limitations, complete proofs are deferred to the full version of the paper [4].

Preliminaries
Block-cut-vertex tree. A cut-vertex in a connected graph G is a vertex whose removal disconnects G. A graph with no cut-vertex is biconnected. A block of G is a maximal subgraph of G which is biconnected. The block-cut-vertex tree T of G [6,8] has a B-node for each block of G and a C-node for each cut-vertex of G; a B-node b and a C-node c are adjacent if c is a vertex of the block of G represented by b. We denote by G(b) the block of G represented by a B-node b. We often identify a C-node of T and the corresponding cut-vertex of G. Suppose that T is rooted at some B-node; then, for any node x of T (either a B-node or a C-node), we denote by G + (x) the subgraph of G consisting of all the blocks G(b) such that b is a B-node in the subtree of T rooted at x.
Planar drawings. A drawing of a graph maps each vertex to a point in the plane and each edge to a Jordan arc between its end-vertices. A drawing is planar if no two edges intersect, except at common end-vertices. A planar drawing partitions the plane into connected regions, called faces. The unbounded face is the outer face, while all the other faces are internal.
Outerplanar graphs. An outerplanar drawing is a planar drawing such that all the vertices are incident to the outer face. An outerplanar graph is a graph that admits an outerplanar drawing. Two outerplanar drawings are equivalent if the clockwise order of the edges incident to each vertex is the same in both drawings. An outerplane embedding is an equivalence class of outerplanar drawings. A biconnected outerplanar graph has a unique outerplane embedding [11,14]. Given the outerplane embedding Γ of an n-vertex biconnected outerplanar graph G, the extended dual tree T of Γ is obtained from the dual graph D of Γ by splitting the vertex of D corresponding to the outer face of Γ into n degree-1 vertices. Note that T is an ordered tree and can be constructed in O(n) time. Further, each edge of T is dual to an edge of G; moreover, the edges incident to leaves of T are dual to edges incident to the outer face of Γ .
Book-embeddings. Given a graph G and a linear order L of its vertices, we write u ≺ L v to represent that u precedes v in L. Two edges (u, v) and (w, z) of G cross if u ≺ L w ≺ L v ≺ L z; then L is a 1-page book-embedding of G if no two edges cross. The flip of L is a linear order L such that, for any pair of vertices u and v, we have u ≺ L v if and only if v ≺ L u. By u L v we mean that u ≺ L v or u = v. For a pair of distinct edges e 1 = (u 1 , v 1 ) and e 2 = (u 2 , v 2 ) of G such that u 1 L u 2 ≺ L v 2 L v 1 , we say that e 2 is nested into e 1 and e 1 wraps around e 2 . Further, a subgraph G of G lies under (resp. lies strictly under ) an edge A weighted graph G = (V, E, ω) is a graph equipped with a function ω that assigns a positive weight to each edge in E.

max-Constrained Book-Embeddings
In this section, we study a first type of one-dimensional representations. We are given a weighted graph G = (V, E, ω). We draw the vertices in V as points linearly ordered on the boundary of a disk and the edges in E as non-intersecting arcs positioned outside the disk, placing edges with larger weight outside edges of smaller weight. Formally, a max-constrained book-embedding of a weighted graph G = (V, E, ω) is a 1-page book-embedding L such that, for any two distinct edges e 1 = (u, v) and e 2 = (x, y) in E with u L x ≺ L y L v, we have that ω(e 1 ) > ω(e 2 ). That is, if e 1 wraps around e 2 , then ω(e 1 ) > ω(e 2 ). We do not specify the actual drawing of the edges since, if G has a max-constrained bookembedding, then they can be easily represented with non-crossing Jordan arcs. An example is in Fig. 1(a). In this section we prove the following theorem. Theorem 1. Let G = (V, E, ω) be an n-vertex weighted outerplanar graph. There exists an O(n log n)-time algorithm that tests if G admits a max-constrained book-embedding and, in the positive case, constructs such an embedding.
We call max-be-drawer the algorithm in the statement of Theorem 1. We can assume that G is connected; otherwise, it admits a max-constrained bookembedding if and only if every connected component of it admits one.
We start by computing in O(n) time the block-cut-vertex tree T of G [6,8]. We root T at any B-node b * such that G(b * ) contains an edge with maximum weight. For each B-node b of T , we compute in overall O(n) time the value W + (b) of the maximum weight of an edge of G + (b).
We now visit T in arbitrary order. For each B-node b, we do what follows. First, we check if G(b) admits a max-constrained book-embedding. In the negative case, we conclude that G admits no max-constrained book-embedding, while in the positive case we compute such an embedding and call it L(b). This check is done in time linear in the number of vertices of G(b), as follows. First, we check whether there exists a single edge (u, v) ∈ E of maximum weight. If not, we conclude that G admits no max-constrained book-embedding, otherwise we compute in linear time [3,10,15] the unique 1-page book-embedding L(b) of G(b) such that u and v are the first and the last vertex of L(b), respectively; note that, in any max-constrained book-embedding of G(b), the edge (u, v) does not nest into any other edge of G(b), given that it has maximum weight, hence it has to wrap around every other edge of G(b). We construct in linear time the extended dual tree T of the outerplane embedding of G(b) and we root T at the leaf whose incident edge is dual to (u, v). We visit T and, for every edge (α, β) of T where α is the parent of β and β has children γ 1 , . . . , γ k , we check whether the dual edge e β of (α, β) has weight larger than that of the edge e γi that is dual to the edge (β, γ i ), for i = 1, . . . , k. If one of these checks fails, we conclude that G(b) admits no max-constrained book-embedding, since e β wraps around e γi in We check in constant time whether c is the first or the last vertex of L(b). If not, we conclude that G admits no max-constrained book-embedding, given that T is rooted at a node b * such that G(b * ) contains an edge with maximum weight, hence G(b * ) does not lie under any edge incident to c. Otherwise, we possibly flip in constant time L(b) so that c is the first vertex of L(b).
Third, for each C-node c of T that is adjacent to b, we store two values b (c) and r b (c). These are the weights of the edges (u, c) and (c, w) such that u and w are the vertices immediately preceding and following c in L(b), respectively; if a vertex preceding or following c in L(b) does not exist, then we set b (c) or r b (c) to ∞, respectively. This is done in constant time for each C-node.
We now perform a bottom-up visit of T . After visiting a B-node b, we either conclude that G admits no max-constrained book-embedding or we determine a max-constrained book-embedding . In more detail, we act as follows.
If b is a leaf of T , then we set in constant time L + (b) = L(b).
If b is an internal node of T , then we proceed as follows. We initialize Let c 1 , . . . , c k be the C-nodes that are children of b in T . For i = 1, . . . , k, let b i,1 , . . . , b i,mi be the B-nodes that are children of c i . Since we already visited each node b i,j , we have a max-constrained book-embedding L + (b i,j ) of G + (b i,j ) whose first vertex is c i . We now process each C-node c i independently.
We order (and possibly relabel) the B-nodes b i,1 , . . . , b i,mi that are children of c i in decreasing order of value W + (b i,j ); that is, . This can be done in O(m i log m i ) time. We now process the B-nodes b i,1 , . . . , b i,mi in this order. We use two variables, L(c i ) and R(c i ), and initialize them to b (c i ) and r b (c i ), respectively. When processing a node b i,j , for j = 1, . . . , m i , we insert the vertices of G + (b i,j ) into the ordering L + (b), by replacing c i either with L + (b i,j ) (that is, L + (b i,j ) is inserted to the right of c i ) or with the flip of L + (b i,j ) (that is, L + (b i,j ) is inserted to the left of c i ). This - The upper bound in Theorem 1 is essentially tight, as computing a maxconstrained book-embedding has a time complexity that is lower-bounded by that of a sorting algorithm. Indeed, given a set S of n distinct real numbers, one can construct a star T with a center c whose n edges have the weights in S. Any max-constrained book-embedding of T partitions the edges into two ordered sequences, one to the left of c and one to the right of c; a total ordering of S can be constructed by merging these sequences in O(n) time.

sum-Constrained Book-Embeddings
Even if in a max-constrained book-embedding no edge can wrap around an edge with larger weight, an edge e might still wrap around a sequence of edges e 1 , . . . , e k with ω(e) < k i=1 ω(e i ). This might cause the resulting visualization to not effectively convey the information related to the edge weights. Hence, we study a second type of one-dimensional representations that are more restrictive than max-constrained book-embeddings and that allow us to better take into account the relationships between the weights of the edges.
A sum-constrained book-embedding of a weighted outerplanar graph G = (V, E, ω) is a 1-page book-embedding L with the following constraint. Let e = (u, v) be any edge in E with u ≺ L v. Let e 1 = (u 1 , v 1 ), . . . , e k = (u k , v k ) be any sequence of edges in E such that Observe that the max-constrained book-embedding in Fig.  1(a) is not a sum-constrained book-embedding since it contains vertices 3, 4, 5, and 7 (in this order) and the sum of the weights of (3, 4) and (5, 7) is 14, while the weight of (3, 7) is 12. A sum-constrained book-embedding is in Fig. 2(a). The goal of this section is to prove the following theorem.
Theorem 2. Let G = (V, E, ω) be an n-vertex weighted outerplanar graph and let Φ be the maximum weight of any edge in E. There exists an O(Φ 2 n 3 log(Φn))time algorithm that tests whether G admits a sum-constrained book-embedding and, in the positive case, constructs such an embedding.
We call sum-be-drawer the algorithm in the statement of Theorem 2. As for max-constrained book-embeddings, we can assume that G is connected.
First, we compute in O(n) time the block-cut-vertex tree T of G [6,8]. We root T at any B-node b * containing an edge with maximum weight. Further, we equip each B-node b with the maximum weight W (b) of any edge of G(b).
Second, we visit (in arbitrary order) T . For each B-node b, the algorithm sum-be-drawer performs the following checks and computations. We introduce some definitions (refer to Fig. 3). Let L be a 1-page bookembedding of G. A vertex c is visible in L if there exists no edge e of G such that c lies strictly under e in L; for example, the vertices 1, 4, and 9 in Fig. 3(a   Now, let L and L be two 1-page book-embeddings of G and let c be a vertex of G that is visible both in L and in L . We say that L and L are left-right equivalent with respect to c if λ c L = λ c L and ρ c L = ρ c L . We also say that L leftright dominates L with respect to c if λ c L ≤ λ c L , ρ c L ≤ ρ c L , and at least one of the two inequalities is strict. Finally, let L and L be two 1-page book-embeddings of G whose first vertex is the same. We say that L is up-down equivalent to L if τ L = τ L and α L = α L . We also say that L up-down dominates L if τ L ≤ τ L , α L ≥ α L , and at least one of the two inequalities is strict.
The algorithm sum-be-drawer now performs a bottom-up visit of T .
After visiting a C-node c, sum-be-drawer either concludes that G admits no sum-constrained book-embedding or determines a sequence of sumconstrained book-embeddings L + 1 (c), . . . , L + k (c) of G + (c) such that: (C1) for any i = 1, . . . , k, we have that c is visible in L + i (c); (C2) λ c L + 1 (c) < · · · < λ c L + k (c) and ρ c L + 1 (c) > · · · > ρ c L + k (c) ; and (C3) G + (c) admits no sum-constrained book-embedding that respects (C1) and that left-right dominates L + i (c) with respect to c, for some i ∈ {1, . . . , k}. After visiting a B-node b = b * , sum-be-drawer either concludes that G admits no sum-constrained book-embedding or determines a sequence of sum- ; and (B3) G + (b) admits no sum-constrained book-embedding that respects (B1) and that up-down dominates L + i (b), for some i ∈ {1, . . . , k}. We now describe the bottom-up visit of T performed by sum-be-drawer. Processing a leaf. If b is a leaf of T , then the only sum-constrained bookembedding of G + (b) constructed by sum-be-drawer is L + 1 (b) = L(b). Processing a C-node. We process a C-node c as follows. Let b 1 , . . . , b h be the B-nodes that are children of c. For each b i with i = 1, . . . , h, we have a sequence L + 1 (b i ), . . . , L + ki (b i ) satisfying Properties (B1)-(B3). We relabel the B-nodes b 1 , . . . , b h in such a way that W (b i ) ≤ W (b i+1 ), for i = 1, . . . , h − 1; this takes O(n log n) time. We now process the B-nodes b 1 , . . . , b h in this order. While processing these nodes, we construct h sequences S 1 , . . . , S h , where S i contains O(Φn) sum-constrained book-embeddings of G + (b 1 ) ∪ · · · ∪ G + (b i ). Roughly speaking, S i is a sequence of "optimal" sum-constrained book-embeddings of G + (b 1 ) ∪ · · · ∪ G + (b i ) with respect to left-right dominance.
When processing b 1 , we let S 1 consist of L + ki (b 1 ) and its flip. Suppose that, for some i ∈ {2, . . . , h}, the B-node b i−1 has been processed. We process b i as follows. We initialize S i = ∅. We individually consider each of the O(Φn) embeddings in S i−1 ; let L be one of these embedding. We consider each embedding L + j (b i ), with j = 1, . . . , k i and try to place the vertices of L + j (b i ) different from c to the right and/or to the left of L. More precisely (1) if α L + j (bi) > ρ c L (that is, if the part of L to the right of c "fits" immediately to the right of c in L + j (b i )), then we construct a sum-constrained book-embedding L of G + (b 1 )∪· · ·∪G + (b i ) by placing the vertices of L + j (b i )\{c} to the right of L, in the same order as they appear in L + j (b i ), and we insert L into S i ; (2) if α L + j (bi) > λ c L , we construct a sum-constrained book-embedding L of G + (b 1 ) ∪ · · · ∪ G + (b i ) by placing the vertices of L + j (b i ) \ {c} to the left of L, in the opposite order as they appear in L + j (b i ), and we insert L into S i . Since k i ∈ O(Φn), after we considered each of the O(Φn) embeddings in S i−1 , we have that S i contains O(Φ 2 n 2 ) embeddings. If S i is actually empty, then we conclude that G admits no sum-constrained book-embedding. Otherwise, we order and polish S i by removing left-right dominated embeddings and by leaving only one copy of left-right equivalent embeddings (this brings the number of embeddings in S i down to O(Φn)). The complexity of this step is dominated by the ordering of the elements in S i , which takes O(Φ 2 n 2 log(Φn)) time.
After processing b h , we have that S := S h contains the required sequence of sum-constrained book-embeddings of G + (c) satisfying Properties (C1)-(C3).
Processing an internal B-node different from the root. Let c 1 , . . . , c k be the C-nodes that are children of a B-node b, labeled in the order as they appear in the sum-constrained book-embedding L(b) of G(b). For each c i with i = 1, . . . , h, we have a sequence L + 1 (c i ), . . . , L + ki (c i ) of sum-constrained bookembeddings of G + (c i ) satisfying Properties (C1)-(C3). We consider each of the O(Φn) embeddings L + 1 (c 1 ), . . . , L + k1 (c 1 ) of G + (c 1 ) and plug it into L(b), if possible. For each of these choices, we process the C-nodes c 2 , . . . , c h in this order. When processing c i , we choose a sum-constrained book-embedding L + j (c i ) for G + (c i ) so that the extension of L + j (c i ) to the right of c i is minimum, subject to the constraint that L + j (c i ) "fits" on the left. This results in the construction of at most one embedding of G + (b) for each embedding of G + (c 1 ). The set of embedding of G + (b) is then simplified by removing up-down dominated embeddings and by leaving a single copy of up-down equivalent embeddings.
Processing the root. The way we deal with the root b * of T is similar, and actually simpler, than the way we deal with a B-node b = b * . We choose for G + (c 1 ) the embedding that fits into the embedding L(b) of G(b) and whose extension to the right is minimum. Then, for every C-node c i with i = 2, . . . , k, we select a single embedding as in the case of a B-node different from the root. We produce at most one book-embedding for G + (b * ) = G.
Running time. Algorithm sum-be-drawer processes a B-node in O(Φ 2 n 2 ) time and a C-node in O(hΦ 2 n 2 log(Φn)) time, where h is the number of children of the C-node. Since the BC-tree T has O(n) nodes and edges, the running time of the algorithm sum-be-drawer is in O(Φ 2 n 3 log(Φn)).

Two-Dimensional Book-Embeddings
In order to deal with weighted outerplanar graphs that admit no max-constrained and no sum-constrained 1-page book-embedding (a cycle with three edges that all have the same weight is an example of such a graph), a possibility is to give to each edge not only a length but also a thickness, so that the area of the lune representing an edge is proportional to its weight.
Given a weighted outerplanar graph G = (V, E, ω), a two-dimensional bookembedding Γ of G consists of a 1-page book-embedding L (which is said to support Γ ) and of a representation of G with the following features: The area of Γ is the area of the smallest axis-parallel rectangle enclosing it. In Sec. 1, we proposed to represent vertices as points on the boundary of a disk and edges as lunes with area proportional to the edge weights. In the above definition instead, to simplify the geometric constructions, vertices are placed along a straight-line and edges are represented as rectangles. However, it is easy to connect the rectangle representing an edge (u, v) with the points representing u and v, without intersecting the internal points of any other rectangle, implying the topological equivalence of the two representations. See Fig. 1(b).
The following theorems state that all weighted outerplanar graphs admit a two-dimensional book-embedding. The algorithms in their proofs exploit a suitable visit of the extended dual tree of G.
Theorem 3. Let G = (V, E, ω) be an n-vertex weighted biconnected outerplanar graph and let L > 0 be a prescribed width. There exists an O(n)-time algorithm that constructs a two-dimensional book-embedding in area L × H = e∈E ω(e).
Theorem 4. For any constant ε > 0, every n-vertex weighted outerplanar graph G = (V, E, ω) admits a two-dimensional book-embedding with area less than or equal to e∈E ω(e) + ε. Such an embedding can be computed in O(n) time.
Theorems 3 and 4 do not give any guarantee in terms of minimum height and width of the rectangles in the constructed two-dimensional book-embeddings. We now study two-dimensional book-embedding with finite resolution.
A minres-constrained two-dimensional book-embedding of a weighted outerplanar graph G = (V, E, ω) is a two-dimensional book-embedding such that: (1) For each edge e in E, we have that x max (e)−x min (e) ≥ 1 and y max (e)−y min (e) ≥ 1. (2) For each pair u, v of vertices, we have that |x(v) − x(u)| ≥ 1.
Let L be a 1-page book-embedding of a graph G and let e be an edge of G. We call the number of vertices that lie strictly under e the burden of e in L, and denote it by β(e). We have the following characterization.
Theorem 5. A n-vertex weighted outerplanar graph G = (V, E, ω) admits a minres-constrained two-dimensional book-embedding if and only if it admits a 1-page book-embedding L such that ω(e) ≥ β(e) + 1, for each edge e ∈ E. Fig. 2(b) shows a minres-constrained two-dimensional book-embedding produced by the algorithm used to prove Theorem 5. We can prove the following theorem by means of a variation of Algorithm sum-be-drawer from Sec. 4. Theorem 6. Let G = (V, E, ω) be an n-vertex weighted outerplanar graph. There exists an O(n 5 log n)-time algorithm that tests whether G admits a minresconstrained two-dimensional book-embedding and, in the positive case, constructs such an embedding.

Conclusions and Open Problems
With the aim of constructing schematic representations of biconnected graphs consisting of a large component plus several smaller components, we studied several types of constrained 1-page book-embeddings and presented polynomialtime or pseudo-polynomial-time algorithms for testing if a graph admits such book-embeddings. All the algorithms presented in this paper have been implemented; Figs. 1 and 2 have been generated by means of such implementations.
Our paper opens several problems. First, our algorithms allow us to represent only an outerplanar arrangement of small components around a large component. How to generalize the approach to the non-outerplanar case? One could study the problem of minimizing the crossings between components and/or minimizing the violations to the constraints on the weights of the nesting components.
Second, we propose to linearly arrange the vertices of the separation pairs of the large component on the boundary of a disk. What happens if such an arrangement is instead circular? It is probably feasible to generalize our techniques in this direction, but extra effort is required.
Third, we concentrate on a "flat" decomposition of a graph with one large component plus many small components. What happens if the small components have their own separation pairs? In other words, how to represent the decomposition of a biconnected graph in its triconnected components?
Finally, our algorithms for constructing two-dimensional book-embeddings with finite resolution may output drawings whose area is not minimum. Can we minimize the area of such drawings in polynomial time?