Abstract 1 Introduction 2 A star-based separator for 𝒄-colored pseudo-segments 3 Extension to 𝒄-oriented polygons and string graphs 4 Concluding remarks References

Star-Based Separators for Intersection Graphs of 𝒄-Colored Pseudo-Segments

Mark de Berg ORCID Department of Mathematics and Computer Science, TU Eindhoven, The Netherlands Bart M. P. Jansen ORCID Department of Mathematics and Computer Science, TU Eindhoven, The Netherlands Jeroen S. K. Lamme ORCID Department of Mathematics and Computer Science, TU Eindhoven, The Netherlands
Abstract

The Planar Separator Theorem, which states that any planar graph 𝒢 has a separator consisting of O(n) nodes whose removal partitions 𝒢 into components of size at most 2n3, is a widely used tool to obtain fast algorithms on planar graphs. Intersection graphs of disks, which generalize planar graphs, do not admit such separators. It has recently been shown that disk graphs do admit so-called clique-based separators that consist of O(n) cliques. This result has been generalized to intersection graphs of various other types of disk-like objects. Unfortunately, segment intersection graphs do not admit small clique-based separators, because they can contain arbitrarily large bicliques. This is true even in the simple case of axis-aligned segments.

In this paper we therefore introduce biclique-based separators (and, in particular, star-based separators), which are separators consisting of a small number of bicliques (or stars). We prove that any c-oriented set of n segments in the plane, where c is a constant, admits a star-based separator consisting of O(n) stars. In fact, our result is more general, as it applies to any set of n pseudo-segments that is partitioned into c subsets such that the pseudo-segments in the same subset are pairwise disjoint. We extend our result to intersection graphs of c-oriented polygons. These results immediately lead to an almost-exact distance oracle for such intersection graphs, which has O(nn) storage and O(n) query time, and that can report the hop-distance between any two query nodes in the intersection graph with an additive error of at most 2. This is the first distance oracle for such types of intersection graphs that has subquadratic storage and sublinear query time and that only has an additive error.

Keywords and phrases:
Computational geometry, intersection graphs, biclique-based separators, distance oracles
Copyright and License:
[Uncaptioned image] © Mark de Berg, Bart M.P. Jansen, and Jeroen S.K. Lamme; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Design and analysis of algorithms
Funding:
MdB and BJ are supported by the Dutch Research Council (NWO) through Gravitation-grant NETWORKS-024.002.003.
Related Version:
Full Version: https://arxiv.org/abs/2511.05371
Editors:
Ho-Lin Chen, Wing-Kai Hon, and Meng-Tsung Tsai

1 Introduction

Background.

The celebrated Planar Separator Theorem by Lipton and Tarjan [24] states that any planar graph admits a balanced separator of size O(n). More precisely, for any planar graph G=(V,E) with n nodes there exists a set SV of size O(n) whose removal partitions G into components of at most 2n3 nodes each. This fundamental tool has been used to develop efficient algorithms for many classic problems on planar graphs.

Geometric intersection graphs – graphs whose nodes correspond to objects in the plane and that have an edge between two nodes iff the corresponding objects intersect – are a generalization of planar graphs that have received widespread attention in computational geometry, graph theory, and parametrized complexity. (For an overview of work in the latter area, we refer the reader to the survey by Xue and Zehavi [28].) Unfortunately, geometric intersection graphs do not admit balanced separators of sublinear size, because they can contain arbitrarily large cliques. This led De Berg et al. [11] to introduce so-called clique-based separators: balanced separators that consist of a small number of disjoint (but potentially large) cliques instead of a small number of nodes. They proved that any disk graph – and more generally, any intersection graph of convex fat objects in the plane – admits a clique-based separator of size O(n). Here the size of a clique-based separator is the number of cliques it consists of. They also showed how to use such clique-based separators to obtain sub-exponential algorithms for various classic graph problems, including Independent Set, Dominating Set, and Feedback Vertex Set. Recently, De Berg et al. [12] showed that intersection graphs of pseudo-disks, and intersection graphs of geodesic disks inside a simple polygon, admit balanced separators consisting of O(n2/3) cliques, and Aronov et al. [3] proved that intersection graphs of geodesic disks in any well-behaved metric in the plane admit balanced separators consisting of O(n3/4+ε) cliques.

One may wonder if all geometric intersection graphs have sublinear clique-based separators. Unfortunately the answer is no, even for intersection graphs of horizontal and vertical line segments. The problem is that such graphs can contain arbitrarily large bicliques, and Kn,n does not admit a sublinear clique-based separator. We therefore introduce biclique-based separators, which are separators consisting of bicliques, and we show that any set of horizontal and vertical segments admits a balanced separator consisting of a small number of bicliques. In fact, our result is stronger (as it uses star graphs in the separator, and not just any biclique) and it applies to a much wider class of intersection graphs, as discussed next.

Our contribution.

Let 𝒢=(V,E) be an undirected graph with n nodes. A collection S={S1,St} of (not necessarily induced) disjoint subgraphs from G is called a balanced111In the sequel we will often omit the adjective balanced and simply speak of separators. biclique-based separator for G if it has the following properties:

  • Each subgraph Si is a biclique.

  • The removal from 𝒢 of all subgraphs Si and their incident edges partitions 𝒢 into connected components with at most 2n3 nodes each.

The size of a biclique-based separator is the number of bicliques it is comprised of. If each biclique SiS is a star, then we call S a star-based separator. Note that the subgraphs Si in a biclique-based separator (or: in a star-based separator) need not be induced subgraphs of 𝒢. This is necessary to be able to handle large cliques. To avoid confusion between our new separators that are comprised of bicliques and the traditional separators that are comprised of individual nodes, we will refer to the latter as node-based separators.

We denote the intersection graph induced by a set V of n objects in the plane by 𝒢×[V]. Thus, the nodes in 𝒢×[V] are in one-to-one correspondence with the objects in V and there is an edge between two objects u,vV iff u intersects v. In Section 2 we prove that a star-based separator of size O(n) exists for the intersection graph of any set V of axis-parallel segments. (The bound on the size of the separator is tight in the worst case.) In fact, we will prove that a star-based separator of size O(n) exists for any set V of pseudo-segments222A set V of curves in the plane is a set of pseudo-segments if any two curves in V are either disjoint or intersect in a single point that is a proper crossing (and not a tangency). that is partitioned into subsets V1,,Vc such that the pseudo-segments from each Vi are disjoint from each other. In other words, each Vi is an independent set in 𝒢×[V]. We call such a set V a c-colored set of pseudo-segments, and we call V1,,Vc its color classes; see Figure 1(left). Note that a set of axis-parallel segments such that no two segments of the same orientation overlap, is a 2-colored set of pseudo-segments. More generally, a c-oriented set of line segments such that no two segments from the same orientation intersect, is a c-colored set of pseudo-segments. Intersection graphs of c-oriented segments are often referred to as c-dir graphs, and when segments of the same orientation are not allowed to intersect, they are referred to as pure c-dir graphs [20, 21]. We show that a star-based separator of size O(n) for a c-dir graph can be computed in O(nlogn) time, if the segments which induce this graph are given.

In Section 3 we extend our result to the case where V is a set of n constant-complexity c-oriented simple polygons, that is, a set of polygons without holes such that the set of edges of all polygons is a c-oriented set. Note that two polygons can intersect without having their boundaries intersect, namely when one polygon is completely contained in the other polygon – this is the main difficulty we need to handle when extending our results to polygons. Finally, in Section 3 we also present a straightforward greedy algorithm that computes a star-based separator of size O(n2/3log2/3n) for any string graph.

Application to distance oracles.

A distance oracle for a (potentially weighted) graph 𝒢=(V,E) is a data structure that can quickly report the distance between two query nodes s,tV. Such queries can trivially be answered in O(1) time if we store the distance between any two nodes in a distance table, but this requires Ω(n2) storage. The challenge is to design distance oracles that use subquadratic storage. Unfortunately, this is not possible in general: any distance oracle must use Ω(n2) bits of storage in the worst case, irrespective of the query time [27]. This is even true for distance oracles that approximate distances to within a factor strictly less than 3. Thus, work on distance oracles concentrated on special graph classes and, in particular, on planar graphs. More than two decades of research culminated in an exact distance oracle for weighted planar graphs that uses O(n1+o(1)) storage and has O(log2n) query time [9]. For the unweighted case – in other words, if we are interested in the hop-distance – there is a (1+ε)-approximate distance oracle with O(1/ε2) query time and O(n/ε2) storage [22]. See the survey by Sommer [26] and the paper by Charalampopoulos et al. [9] for overviews of the existing distance oracles for various graph classes.

For geometric intersection graphs, only few results are known. Gao and Zhang [15], and Chan and Skrepetos [6], provide (1+ε)-approximate distance oracles with O(nlogn) storage and O(1) query time for weighted unit-disk graphs. No exact distance oracles that use subquadratic storage and have sublinear query time are known, even for unweighted unit-disk graphs. Very recently, Chang, Gao, and Le [8] presented an almost exact distance-oracle for unit-disk graphs (and, more generally, for intersection graphs of similarly sized, convex, fat pseudodisks) that uses O(n21/18) storage and that can report the distance between two query nodes, up to an additive error333In the most recent arxiv version [7] the error has been reduced to 1. of 2, in O(1) time. Another recent result is by Aronov, De Berg, and Theocharous [3], who presented an almost exact distance oracle that uses clique-based separators. For intersection graphs of geodesic disks in the plane, their oracle uses O(n7/4+ε) storage, has O(n3/4+ε) query time, and can report the hop-distance between two query points up to an additive error of 1. For Euclidean disks, the storage and preprocessing would be O(nn) and O(n), respectively. As we explain later, their approach also works with biclique-based separators; the only difference is that the additive error increases from 1 to 2. Thus, we obtain an almost exact distance oracle for intersection graphs of c-colored pseudo-segments with O(nn) storage and O(n) query time. This is, to the best of our knowledge, the first almost exact distance oracle for intersection graphs of non-disk-like objects.

2 A star-based separator for 𝒄-colored pseudo-segments

Let V be a c-colored set of pseudo-segments, as defined above. To simplify the terminology, from now on we simply refer to the pseudo-segments in V as segments. We assume that the segments in V are in general position and, in particular, that no three segments meet in a common point and that no endpoint of one segment lies on another segment. This assumption is without loss of generality, as it can always be ensured by perturbing the segments slightly.

The construction.

Recall that a contact graph is the intersection graph of a set of interior-disjoint objects. Contact graphs of curves are known to be planar if no four objects meet in a common point [19, Lemma 2.1]. Our strategy to construct a star-based separator S for 𝒢×[V] consists of the following steps, illustrated in Figure 1 and explained in more detail later.

Figure 1: Left: A 3-colored set of pseudo-segments. Middle: The active fragments created by our algorithm. Right: The contact graph induced by the active fragments.
Step 1.

We partition each segment in V into fragments. Some fragments will be active, while others will be inactive. This partition will be such that active segments do not cross each other, although they may touch.

Step 2.

Let be the contact graph on the active segments. We construct a separator S on , using a suitable weighting scheme on the nodes of . Because is planar, constructing the separator can be done using the Planar Separator Theorem.

Step 3.

We use S to construct our star-based separator S for 𝒢×[V]. For a fragment f, let seg(f)V denote the segment containing f. Intuitively, we want to put a star into S for each fragment f in the separator S, namely, the star consisting of the segment seg(f) as well as all other segments intersecting seg(f). For technical reasons, however, we actually have to put a slightly larger collection of stars into S.

To make this strategy work, we need to control the size of the contact graph . More precisely, to obtain a star-based separator of size O(n), the size of needs to be O(n). Thus we cannot, for example, cut each segment into fragments at its intersection points with all other segments and make all the resulting fragments active. On the other hand, if we ignore certain parts of the segments by making them inactive, we miss certain intersections and we run the risk that our final set of stars is no longer a valid separator. Next, we describe how to overcome these problems by carefully creating the active fragments.

Step 1: Creating the active fragments.

To construct the active fragments that form the nodes in our contact graph , we will go over the subsets V1,,Vc one by one. We denote the active and inactive fragments created for a subset Vi by Fi and F¯i, respectively. For 1ic, we define Fi:=F1Fi, and we define F<i similarly.

Handling the first subset V1 is easy: we simply define F1:=V1. In other words, each segment in V1 becomes a single fragment, and all these fragments are active.

Now consider a subset Vi with i>1. Each segment vVi is partitioned into one or more fragments by cutting it at every intersection point of v with an active fragment fF<i. Let Xi be the set of fragments thus created. There are two types of fragments in Xi: fragments f that contain an endpoint of the segment vVi contributing f – there are at least one and at most two of these fragments per segment vVi – and fragments that do not contain such an endpoint. We call fragments of the former type end fragments and fragments of the latter type internal fragments. Note that an internal fragment has its endpoints on two distinct active fragments g,gF<i. We then say that f connects g and g.

Now that we have defined Xi, we need to decide which fragments in Xi become active. To avoid making too many fragments active, we will partition Xi into equivalence classes, and we will activate only one fragment from each equivalence class. To define the equivalence classes we first define, for two internal fragments f,fXi that connect the same pair of fragments g,gF<i, a region Q(f,f,g,g), as follows; see Figure 2(i) for an illustration.

First, suppose that the segments g and g do not touch each other, as in the left part of Figure 2(i). Thus, 2(gg) is a single, unbounded region with two holes, namely g and g. The fragment f connects these two holes, and so 2(ggf) is still a single unbounded region, but now with one hole. Removing f from this region splits it into two regions, one bounded and one unbounded. We define Q(f,f,g,g) to be the bounded region. Now suppose that g and g touch each other, say at an endpoint of g. We slightly shrink g at the point where it touches g, and then define Q(f,f,g,g) as above. Note that in this case Q(f,f,g,g) may consist of one or two bounded regions, if we undo the shrinking process; see the middle and right part in Figure 2(i). We can now define the equivalence classes.

Figure 2: (i) Defining the region Q(f,f,g,g). (ii) Illustration for the proof of Lemma 2.
Definition 1.

Let f and f be two fragments in Xi. We say that f and f are equivalent, denoted by ff, if f=f or the following two conditions hold.

  1. (i)

    The fragments f and f are internal and connect the same pair of fragments g,gF<i.

  2. (ii)

    The region Q(f,f,g,g) enclosed by the fragments f,f,g,g does not contain an endpoint of any segment in V.

The following lemma shows that is indeed an equivalence relation.

Lemma 2.

The relation defined in Definition 2 is an equivalence relation.

Proof.

It is clear that is reflexive and symmetric. It remains to show that if f1f2 and f2f3, then f1f3. Let g,g be the fragments connected by f1,f2,f3. We can assume that g and g do not touch; otherwise, as before, we can shrink one of the fragments so that the arguments below still apply. It is instructive to view g and g as being slightly inflated so that they become closed curves and no longer have two “sides”. We then see that, from a topological point of view, the situation is always as in Figure 2(ii): two of the fragments, fj and f, are incident to the unbounded face, while the third fragment fk is not. Thus, if we define Qjk:=Q(fj,fk,g,g) and we define Qk and Qj similarly, then Qj=QjkQk. This implies that, no matter which of the three fragments fj,fk,f is f2, we always have Q13Q12Q23. Since Q12 and Q23 do not contain endpoints of segments in V if f1f2 and f2f3, neither does Q13. Thus, f1f3.

We now partition Xi into equivalence classes according to the relation defined above. For each equivalence class, we make an arbitrary fragment fXi from that class active and put it into Fi; the other fragments from that equivalence class are made inactive and put into F¯i. Note that end fragments are always active, since they do not connect a pair of fragments from F<i and thus cannot be equivalent to any other fragment.

Step 2: Creating the contact graph 𝓗 and its separator 𝑺𝓗.

Let F:=F1Fc be the set of active fragments created in Step 1, and let F¯:=F¯1F¯c be the inactive fragments. We define =(F,E) to be the contact graph of F. More precisely, for two fragments f,fF we put the edge (f,f) in E iff f and f are in contact – that is, ff – and they do not belong444Since we do not put an edge between fragments belonging to the same segment, even if these fragments touch, is formally speaking not a contact graph, but we permit ourselves this abuse of terminology. to the same segment in V; see Figure 1. Because of our general position assumption, no three fragments from different segments meet in a point, and therefore is planar [19, Lemma 2.1]. From now on, with a slight abuse of notation, we will not make a distinction between the nodes in and the corresponding fragments in F.

We now wish to create a separator S for . In Step 3 we will use S to create a separator S for 𝒢×[V]. To ensure that S will be balanced, we will put weights on the nodes in and use a weighted version of the Planar Separator Theorem, as described next.

For each segment sV, we designate one of its end fragments – recall that end fragments are always active – as its representative fragment. We give all representative fragments a weight of 1n, and all other fragments a weight of 0. Note that the total weight of the fragments in F is 1. We apply the weighted separator theorem given below to . This gives us a separator S, and parts A,BFS such that there are no edges between A and B.

Lemma 3 (Theorem 4 in [24]).

Let G be a non-negatively weighted planar graph containing n nodes whose weights sum up to at most 1. The node set VG can be partitioned into a separator S, and sets A and B such that |S|=O(n), no edge connects A and B, and the total weight of the nodes in A, as well as the total weight of the nodes in B, is at most 23.

Step 3: Creating the star-based separator 𝑺 for 𝓖×[𝑽].

Using the separator S created in Step 2, we now create our star-based separator S for the intersection graph 𝒢×[V]. We do this by putting one or three stars into S for each fragment fS, as follows. For a segment sV, define star(s) to be the subgraph of 𝒢×[V] consisting of s and all its incident edges. Thus, the nodes in star(s) are the segment s itself plus the segments sV that intersect s.

  • If fS is an end fragment then we put star(seg(f)) into S.

  • If fS is an internal fragment then let g,gF be the pair of active fragments connected by f. We put star(seg(f)), star(seg(g)), and star(seg(g)) into S.

Note that multiple copies of the same star can be added to S. We remove these duplicates to ensure that all star graphs in S have unique centers. It can still be the case that several stars in S contain the same node. To make the stars pairwise disjoint, we therefore remove non-center nodes until every node appears in at most one star in S.

The analysis.

We now show that the construction described above yields a balanced separator of the required size. This requires proving two things: the separation property, namely that the removal of S partitions 𝒢×[V] into components of size at most 2n3, and the size property, namely that S consists of O(n) stars.

Proving the separation property.

To prove the separation property, it suffices to show that VS can be partitioned555Formally, we should have written VS instead of VS, since S is a set of stars and not a set of nodes, but we prefer the simpler (though technically incorrect) notation. into subsets A and B such that |A|2n3 and |B|2n3, and such that no segment in A intersects any segment in B.

We define the sets A and B as follows. For each segment vV not contained in a star in S we look at its representative fragment fv. Note that fv must be contained in either A or B, since fvS would imply that v is contained in a star in S. If fvA then we add v to A, else we add v to B. The value |A|n can be at most the total weight of fragments in A, and a similar statement holds for B. Hence, the next observation follows from the fact that S is a balanced separator.

Observation 4.

|A|2n3 and |B|2n3.

The more challenging part is to show that no segment in A intersects any segment in B. We will need the following lemma. Recall that the segment set V is partitioned into color classes V1,,Vc, which we handled one by one to create the set F of active fragments.

Lemma 5.

Let vViS and let f be an active fragment. Suppose one of the following conditions holds:

  1. (i)

    fF<i and v intersects f,

  2. (ii)

    seg(f)=v, or

  3. (iii)

    f is equivalent to an inactive fragment f such that seg(f)=v.

Then fA if vA, and fB if vB.

Proof.

We prove the lemma under the assumption that vA; the proof for vB is analogous. Let fv be the representative fragment of v. Because vA, we have fvA. We will define sets Z1,Z2,Z3 that contain the active fragments for which conditions (i), (ii), and (iii) hold, respectively, and then argue that the lemma holds for each of the three sets.

Let fv be the other end fragment of v, and let Z1={g1,,gk} be the ordered set of fragments from F<i that we cross as we trace v from fv to fv; see Figure 3. It is possible that fv does not exist, in this case Z1 is empty.

Figure 3: The various fragments used in the proof of Lemma 2. Note that the segments seg(f1) and seg(f3) are not drawn in their entirety. The path in from fv to fv is also shown.

Note that every pair gj,gj+1Z1 is connected by an active or inactive fragment of v, which we denote by fj. We now define Z2,Z3 as follows.

  • Z2 contains the fragments fj that are active plus the end fragments fv and (if it exists) fv. Thus, Z2 simply contains all active fragments of v.

  • Z3 contains, for each inactive fragment fj, the unique equivalent active fragment fjFi.

It is easily checked that the sets Z1,Z2,Z3 indeed contain exactly those fragments for which conditions (i), (ii), and (iii) hold, respectively. We will now prove that all fragments in Z1Z2Z3 are in A. To this end, observe that the fragments in Z1Z2Z3 correspond to nodes in that form a path π starting at fv and ending at fv, as illustrated in Figure 3. Recall that fvA. Now assume for a contradiction that there is a fragment fZ1Z2Z3 that is in BS. Because there are no edges between A and B, this means there must be a fragment f on the subpath of π from fv to f that is an element of the separator S. If fZ1Z2 then vstar(seg(f)), which contradicts that vA. Otherwise fZ3 and f connects two fragments gj,gj+1Z1. Since fS, this implies that star(seg(gj)) is a star in S. Because vstar(seg(gj)), this again contradicts that vA.

We can now prove that 𝒢×[V] does not contain edges between nodes in A and nodes in B.

Lemma 6.

No segment aA intersects any segment bB.

Proof.

Assume for a contradiction that aA and bB intersect. Let faa and fbb be the fragments containing the intersection point. We distinguish three cases.

  • Both fa and fb are active. Then fa and fb satisfy condition (ii) of Lemma 2, and so faA and fbB. Because fa and fb are active and intersect, (fa,fb) is an edge in . But then S would not be a proper separator, and we reach a contradiction.

  • Both fa and fb are inactive. Let faF¯i and fbF¯j, and assume without loss of generality that ij. Because a and b intersect and segments from the same color class are disjoint, we cannot have i=j. Hence, i<j. Because fa is inactive, it must be an internal fragment that connects some fragments g,gF<iF<j. Thus, g,g satisfy condition (i) of Lemma 2, with a playing the role of v, which implies that g,gA. Let faFi be the active fragment that is equivalent to fa. Then fa satisfies condition (iii) from Lemma 2 and so faA. The fragments fa,fa,g,g enclose some region Q. The segment b intersects fa so it is partly contained in Q; see Figure 4 for an illustration of the possibilities for fb entering Q.

    Figure 4: Left: The segment b has an endpoint in Q. Middle: The segment b intersects a twice. Right: The segment b intersects fa. All of these cases lead to a contradiction.

    It cannot have an endpoint in Q, because fa and fa are equivalent. Segment b cannot intersect fa twice, because V is a collection of pseudo-segments. It follows that b must intersect fa, g or g. Now observe that fa, g and g are all fragments in F<j. This implies that the fragment that intersects b satisfies condition (i) from Lemma 2, with b playing the role of v. But then the intersected fragment would be in B, contradicting that A and B are disjoint.

  • One of the fragments fa,fb is active and one is inactive. Assume wlog that fa is inactive and fb is active. Let faF¯i and fbFj. Because a and b intersect, we have ij. If i<j then the arguments from the previous case can be used to obtain a contradiction – indeed, these arguments did not use that fb is inactive. If i>j then fbF<i. Also note that a intersects fb. But then fb satisfies condition (i) from Lemma 2, with a playing the role of v. It follows that fbA, which contradicts that A and B are disjoint.

We have reached a contradiction in each case, thus proving the lemma.

Proving the size property.

Because we add at most three stars to S per fragment in S, it suffices to bound the size of S to prove the size property. From Lemma 2 it follows that |S|=O(|F|). The next lemma bounds |F|.

Lemma 7.

|F|=O(n4c), where c is the number of color classes in V.

Proof.

We first bound |Fi|, the number of active fragments created for the segments in Vi, in terms of the number of active fragments created for V<i.

Claim. For 1<ic we have |Fi|2|Vi|+3(|F<i|+2n+1)6.

Proof.

The set Fi contains at most 2|Vi| end fragments. The internal fragments in Fi connect two fragments from F<i. We denote the set of these internal fragments by Fiint. Now consider the multi-graph 𝒢 defined as follows.

  • For each fragment in F<i, we add a node to 𝒢.

  • For each fragment in Fiint, we add an edge to 𝒢 between the fragments from F<i that it connects.

  • For each endpoint of a segment in Vi we add a singleton node to 𝒢. (Observe that the endpoints of segments in V<i lie on an end fragment in F<i, which is already a node in 𝒢.)

Now consider the obvious drawing of 𝒢, where the nodes are drawn as fragments of F<i or as points, and the edges are drawn as fragment in Fiint. Recall that two active fragments can touch, but they never cross. By continuously shrinking the fragments in Fi and deforming the fragments of Fiint appropriately, we can therefore create a plane drawing of 𝒢. That is, we can create a drawing of 𝒢 in which the nodes are points and the edges are pairwise disjoint curves connecting their endpoints. See Figure 5 for an example of this deformation. For reasons that will become clear shortly, we augment 𝒢 with one additional singleton node u, which we place in the unbounded face of 𝒢.

The graph 𝒢 is a multi-graph because Fiint can contain multiple fragments connecting the same pair of fragments f,fF<i. Let g,gFiint be two such fragments. The reason that we added both g and g to Fiint is that g and g were not equivalent. Hence, the region Q(f,f,g,g) contains an endpoint belonging to some segment vV. The deformation process that turns each node the drawing of 𝒢 into a point can be done in such a way that this property is maintained. Thus, after the deformation we have a plane drawing of 𝒢 in which for any two edges g,g that connect the same pair of nodes, there is a node inside the deformed region Q(f,f,g,g). Because of the additional node u, we are also guaranteed to have at least one node outside this region. A plane multi-graph with this property is called a thin graph. It is known [1, Lemma 5] that the standard inequality (# edges)3(# nodes)6 that holds for planar graphs (with at least three vertices) also holds for thin graphs. Hence, |Fiint|3(|F<i|+2n+1)6.

Note that |F1|=|V1| and |Vi|n for all i. Hence, the claim above gives us the recurrence |Fi|4|F<i|+8n3 with |F1|n. This gives |Fi|(n4+8n312)4i8n33. Plugging in i=c gives |F|=|Fc|=O(n4c), which proves the lemma.

Figure 5: Left: Fragments in Vi are green, fragments in Fiint are dark gray, and endpoints of segments in Vi are blue. Right: The plane multigraph created for the example on the left.

Since c, the number of color classes, is a constant, we obtain the following corollary.

Corollary 8.

The separator S contains O(n) star graphs.

So far we have considered input sets V where the segments are unweighted. To create a separator for c-oriented polygons, which we will do in the next section, we need a separator for weighted segments. Fortunately it is straightforward to adapt the construction described above to the weighted setting – we only need to change the weighting scheme we used in Step 2 of the construction. More precisely, instead of assigning a weight 1n to the representative fragment of a segment v, we assign weight(v)/uVweight(u) to the representative.

 Remark.

It is well known that grid graphs do not admit node-based separators of size o(n). Because nodes in grid graphs have constant degree, bicliques in grid graphs have constant size. Hence, grid graphs do not admit biclique-based separators of size o(n). Grid graphs are bipartite and planar, which implies that they are pure-2-dir graphs [18]. We conclude that even pure-2-dir graphs do not admit biclique based separators of size o(n).

Computation time.

If we assume that the appropriate elementary operations on the pseudo-segments – computing the intersection point of two pseudo-segments, for instance, or determining if a point lies inside some region Q(f,f,g,g) – can be performed in O(1) time, that then a brute-force implementation of the algorithm presented above runs in polynomial time. More interestingly, for c-oriented line segments, the algorithm can be implemented to run in O(nlogn) time, as shown in the full version of this paper. We obtain the following theorem.

Theorem 9.

Let V be a c-colored set of n non-negatively weighted pseudo-segments, where c is a fixed constant, whose total weight is at most 1. Then the intersection graph 𝒢×[V] has a star-based separator S of size O(n) such that VS can be partitioned into subsets A,B of weight at most 23 with no edges between them. The bound on the size of the separator is tight, even for axis-parallel segments. In the special case where V is a set of c-oriented line segments, the separator S and parts A,B can be computed in O(nlogn) time.

Application to distance oracles.

Arikati et al. [2] presented a simple distance oracle for planar graphs, using node-based separators. Aronov, De Berg, and Theocharous [3] observed that the approach can be adapted to work with clique-based separators, as follows. Let 𝒢=(V,E) be the graph for which we want to construct a distance oracle.

  • Construct a clique-based separator S for 𝒢, and let A,BVS be the two parts of the partition given by S. For each node vV and each clique CS, store the distance d(v,C):=min{d(v,u):uC}, where d(u,v) denotes the hop-distance from s to t in 𝒢.

  • Recursively construct distance oracles for the subgraphs induced by the parts A and B.

Now suppose we want to answer a distance query with nodes s,tV. Let d:=min{d(s,C)+d(t,C):CS}. If s and t do not lie in the same part – that is, we do not have s,tA or s,tB – then we report d. Otherwise, s and t lie in the same part of the partition, say A. Then we report the minimum of d and the distance we obtain by querying the recursively constructed oracle for A.

This distance oracle uses O(ns(n)) storage, where s(n) is the size of the separator, and it has O(s(n)) query time, assuming s(n)=Ω(nβ) for some constant β>0. The reported distance is either the exact distance d(s,t), or it is d(s,t)1. The additive error of 1 is because we do not know if s and t can reach the same node of some clique C with paths of length d(s,C) and d(t,C), respectively – we may have to use an edge inside C to connect these paths. We observe that the same approach can be used in combination with star-based (or biclique-based) separators. The only difference is that we now get an additive error of at most 2, because we may need two additional edges inside a star (or biclique) in the separator. We obtain the following result.

Corollary 10.

Let V be a c-colored set of pseudo-segments, where c is a fixed constant. There is an almost-exact distance oracle for 𝒢×[V] that uses O(nn) storage and can report the hop-distance between any two nodes s,tV, up to an additive error of 2, in O(n) time.

3 Extension to 𝒄-oriented polygons and string graphs

𝒄-Oriented polygons.

Let 𝒫={P1,,Pn} be a collection of c-oriented simple polygons, each with a constant number of edges, where c is a fixed constant. The idea is to create a weighted collection V of segments to which we can apply Theorem 9, and then use the resulting separator SV to construct a separator S for 𝒢×[𝒫]. The set V is created as follows.

  • First, we add each side of every polygon Pi𝒫 to V. For each polygon Pi, we pick an arbitrary side as its representative side, which we give weight 1n; other sides of Pi are given weight 0.

  • Second, to handle the containment of polygons within other polygons, we add so-called containment segments to V. These segments will always have weight 0. Let ϕ be an orientation that is not used by any segment in V. For each polygon Pi let 𝒞i𝒫 be the set of polygons that fully contain Pi. Take a point xiPi, and let ρi be a ray emanating from xi and with orientation ϕ. For each Pj𝒞i, let yj be the point where ρi leaves Pj for the first time. Define xi to be the last such point yj. We now add xixi as a containment segment to V. Note that the containment segment xixi intersects the boundaries of all polygons in 𝒞i. Moreover, xixi is completely contained in Pj. Figure 6 shows examples of containment segments.

Figure 6: Left: The dashed line is the containment segment for the red polygon. Middle: The containment segment for the red polygon intersects a polygon which does not contain the red polygon, this is allowed. Right: The containment segment stops after intersecting the boundary of every polygon which contains the red polygon. Extending the containment segment could lead to further intersections with the green polygon. However, only the first intersection between the containment segment and a polygon are considered in the construction.

Clearly, we can partition V into color classes V1,,Vc+1 based on the orientation of the segments. We let V1 contain the segments of orientation ϕ, which will be important later. The total weight of the segments is 1, so we can apply Theorem 9. Let SV be the resulting separator for 𝒢×[V], and let AV and BV be the two parts of weight at most 23 into which SV splits VSV. We construct a separator S and parts A,B for 𝒢×[𝒫] as follows.

For each star in SV we consider its center v. If v is a side of a polygon Pi𝒫 then we add star(Pi) to S, where star(Pi) is the subgraph of 𝒢×[𝒫] consisting of Pi and its incident edges. If v is a containment segment xixi that we generated for polygon Pi𝒫, then let Pj be the polygon enclosing Pi such that xiPj. We add star(Pj) to SP. As before, we remove duplicate stars and we remove polygons from stars to ensure that each polygon is in at most one star. To create the parts A,B, we consider the representative sides of the polygons Pi𝒫 that are not in a star in S. If the representative side is in AV, then we put Pi in part A; otherwise we put Pi in part B.

The analysis.

Proving the size property, namely that |S|=O(n), is easy. Indeed, we put O(1) sides and one containment segment per polygon into V. Hence, |V|=O(n) and thus |S|=|SV|=O(n). It remains to prove the separation property.

Since the total weight of AV and of BV are both at most 23 and each representative side has weight 1n, it follows that |A|2n3 and |B|2n3. Next, we prove that there are no edges from A to B in 𝒢×[𝒫]. We need the following lemma.

Lemma 11.

Consider a polygon Pi𝒫. If PiA (resp. PiB), then all sides of Pi are in AV (resp. BV).

Proof.

First consider the case PiA. Suppose for a contradiction that not all sides of Pi are in AV. Hence, Pi has a side sSV or a side sBV. We claim that in the latter case Pi must also have a side sSV. To see this, consider the representative side si of Pi. Note that siAV since we put Pi into A. Also note that there is a path in 𝒢×[V] connecting s to si – the nodes on this path correspond to the sides of Pi that we encounter as we traverse Pi from s to si in, say, clockwise order. Since siAV and sBV, one of the nodes on this path must be in SV and be a side of Pi. This establishes our claim.

It remains to prove that if Pi has a side s in SV, then PiS. If s is the center of a star in SV, then by construction Pi is the center of a star in S. If s is a non-center node in some star(s)SV we distinguish two cases. If s is a side of some polygon Pj, then Pj intersects Pi and S contains star(Pj). Consequently, Pi is a non-center node in star(Pj), thus PiS. If s is a containment segment xjxj where xj lies on some polygon Pk, then Pk intersects Pi because xjxj is fully contained in Pk. Because star(s)SV it follows that star(Pk)S, and thus PiS. We have reached a contradiction in all cases. We conclude that all sides of Pi are in AV.

Now consider the case PiB. We can follow the proof for the case PiA if the representative side si of Pi is in BV. This must indeed be the case: we cannot have siAV because then we would have put Pi into A, and si cannot be a node in a star in SV because then Pi would have been in a star in S, as has been shown above. Hence, the lemma is also true if PiB.

We can now prove that there are no edges from A to B in 𝒢×[𝒫].

Lemma 12.

No polygon PaA intersects any polygon PbB.

Proof.

Suppose for a contradiction that Pa and Pb intersect. We distinguish two cases.

  • The boundaries of Pa and Pb intersect. Let s and s be the sides of Pa and Pb that intersect. Because PaA we have sAV by Lemma 3. Similarly, we have sBV. But this contradicts that SV is a separator for 𝒢×[V] with parts AV,BV.

  • The boundaries of Pa and Pb do not intersect. Assume wlog that PaPb. Consider the containment segment s=xaxa. By construction of the containment segments, polygon Pb has a side s that intersects s. Recall that the containment segments were put into the set V1 that was handled first by the algorithm from the previous section. Hence, there will be a fragment fF that is identical to s. Let i>1 be such that sVi. Then f satisfies condition (i) of Lemma 2, with s playing the role of v. Since s is a side of PbB, we have sBV by Lemma 3. Thus, Lemma 2 implies that s=fBV.

    Similarly there exists a side s′′ that is part of Pa that intersects s. From Lemma 3 it follows s′′AV. It must be that s′′Vj for some j>1. Then f also satisfies condition (i) of Lemma 2 with s′′ playing the role of v, so that s=fAV. But then the sets AV and BV are not disjoint, which contradicts that SV is a separator.

Putting everything together, we obtain the following theorem. The runtime guarantee for computing the separator is proven in the full version.

Theorem 13.

Let P be a set of n constant-complexity c-oriented polygons in the plane. Then the intersection graph 𝒢×[P] has a star-based separator of size O(n), which can be computed in O(nlogn) time. Moreover, there is an almost exact distance oracle for 𝒢×[V] that uses O(nn) storage and that can report the hop-distance between any two nodes s,tP, up to an additive error of 2, in O(n) time.

 Remark.

The theorem above is stated for n constant-complexity c-oriented polygons. However, it also holds in a more geneal setting, namely for a collection 𝒫 of polygons with n edges in total. We can then find a separator of size O(n) and parts A,B such that the number of polygons in A and B is at most 2|𝒫|3. Alternatively, we can guarantee that the total number of edges of the polygons in A (and similarly for B) is at most 2n3. Finally, the theorem also works in a weighted setting.

String graphs.

A string graph is the intersection graph of a set V of curves in the plane [14] – no conditions are put on the curves and, in particular, any two curves in V can intersect arbitrarily many times. (But note that there is still at most one edge between the corresponding nodes in 𝒢×[V].) It is known that for any set U of connected regions in the plane, there is a set V of strings such that 𝒢×[U] and 𝒢×[V] are isomorphic [23]. Thus, string graphs are the most general type of intersection graphs of connected regions in the plane.

Matoušek [25] proved that any string graph with n nodes and m edges has a (node-based) separator of size O(mlogm).666A paper by Lee [23] claims that a separator of size O(m) exists for string graphs, but Bonnet et al. [29] note that there is an error in this paper. It is not yet known if the proof can be repaired. Using this result we can obtain a star-based separator of sublinear size for a string graph 𝒢×[V] using the following simple two-stage process.

  • Stage 1: As long as there is a node vV of degree at least n1/3/log2/3n, remove star(v) from 𝒢×[V] and add it to the separator. This puts at most O(n2/3log2/3n) stars into the separator.

  • Stage 2: Construct a node-based separator on the remaining string graph, using Matoušeks method [25] and put these nodes as singletons into the separator. Since the maximum degree after Stage 1 is O(n1/3/log2/3n), the remaining graph has O(n4/3/log2/3n) edges. Hence, in Stage 2 we put O(n4/3log2/3nlog(n4/3log2/3n))=O(n23log23n) stars into the separator.

By using the star-based separator exactly as in Section 2, this yields the following.

Proposition 14.

Let V be a set of n strings in the plane. Then the string graph 𝒢×[V] has a star-based separator of size O(n2/3log2/3n). Moreover, there is an almost exact distance oracle for 𝒢×[V] that uses O(n5/3log2/3n) storage and that can report the hop-distance between any two nodes s,tV, up to an additive error of 2, in O(n2/3log2/3n) time.

Recall that the distance oracle of Aronov, De Berg and Theocharous [12] for geodesic disks in the plane has O(n7/4+ε) storage and O(n3/4+ε) query time. Thus the distance oracle in Proposition 3 is more general (as it can handle any string graph), has better storage, and better query time. The only downside is that the additive error in our distance oracle is at most 2, while for their oracle it is at most 1.

 Remark.

One may wonder if any graph, and not just any string graph, admits a sublinear star-based separator, but this is not the case. For example, 3-regular expanders do not admit sublinear node-based separators [13] and working with star-based separators instead of node-based separators does not help in constant-degree graphs.

4 Concluding remarks

Motivated by the fact that intersection graphs of non-fat objects may not admit sublinear node-based or clique-based separators, we introduced a biclique-based and star-based separators. We proved that the intersection graph of any c-colored set of pseudo-segments has a star-based separator of size O(n), and extended the result to c-oriented polygons. We also presented a straightforward algorithm to compute a star-based separator of size O(n2/3log2/3n) for any string graph. These results lead to almost exact distance oracles with subquadratic storage and sublinear query times. To the best of our knowledge, such distance oracles did not yet exist – not even for intersection graphs of axis-parallel line segments.

Our work raises several questions. Can we improve the size of star-based separators for string graphs from O(n2/3log2/3n) to O(n)? If not, can we perhaps do so for c-colored sets of strings, or for arbitrary sets of line segments? It is also interesting to explore other applications of biclique-based separators, besides distance oracles, and to see if the bounds we obtained for distance oracles can be improved. While clique-based separators have been used to design subexponential algorithms for problems such as q-Coloring [12] and Dominating Set [11], it is unlikely that our biclique-based separator will yield new results for these problems. This is due to existing 2Ω(n) conditional lower bound (under ETH) for q-Coloring and Dominating Set on 2-dir and segment intersection graphs, respectively [5]. Instead, problems whose main difficulty lies in finding (hop-)distances – computing the diameter in subquadratic time [8] is an example – would be interesting to consider.

Recent work on the (weighted) Independent Set problem on restricted graph classes has exploited properties that can be interpreted through the lens of star-based separators [16, §1.4]. It is known that for every constant t, the family of graphs that does not contain an induced path of length t admits balanced separators that consist of the neighborhoods of t1 vertices (cf. [17, Thm. 1.2]). Hence, such graphs have star-based separators of constant size. This property has been used to develop quasi-polynomial-time approximation schemes for weighted Independent Set on Pt-free graphs [10, 17], as well as exact subexponential-time algorithms for unweighted Independent Set on Pt-free graphs [4]. Can our star-based separators of size O(n) also be used to obtain new algorithms for restricted input families?

References

  • [1] Jochen Alber, Michael R. Fellows, and Rolf Niedermeier. Polynomial-time data reduction for dominating set. J. ACM, 51(3):363–384, 2004. doi:10.1145/990308.990309.
  • [2] Srinivasa Rao Arikati, Danny Z. Chen, L. Paul Chew, Gautam Das, Michiel H. M. Smid, and Christos D. Zaroliagis. Planar spanners and approximate shortest path queries among obstacles in the plane. In Proc. 4th Annual European Symposium on Algorithms (ESA 1996), pages 514–528, 1996. doi:10.1007/3-540-61680-2_79.
  • [3] Boris Aronov, Mark de Berg, and Leonidas Theocharous. A clique-based separator for intersection graphs of geodesic disks in 2. In Proc. 40th International Symposium on Computational Geometry (SoCG), pages 9:1–9:15, 2024. doi:10.4230/LIPIcs.SoCG.2024.9.
  • [4] Gábor Bacsó, Daniel Lokshtanov, Dániel Marx, Marcin Pilipczuk, Zsolt Tuza, and Erik Jan van Leeuwen. Subexponential-time algorithms for maximum independent set in Pt-free and broom-free graphs. Algorithmica, 81(2):421–438, 2019. doi:10.1007/S00453-018-0479-5.
  • [5] Édouard Bonnet and Pawel Rzazewski. Optimality program in segment and string graphs. Algorithmica, 81(7):3047–3073, 2019. doi:10.1007/s00453-019-00568-7.
  • [6] Timothy M. Chan and Dimitrios Skrepetos. Approximate shortest paths and distance oracles in weighted unit-disk graphs. J. Comput. Geom., 10(2):3–20, 2019. doi:10.20382/JOCG.V10I2A2.
  • [7] Hsien-Chih Chang, Jie Gao, and Hung Le. Computing diameter+1 in truly subquadratic time for unit-disk graphs. CoRR, abs/2401.12881, 2024. doi:10.48550/arXiv.2401.12881.
  • [8] Hsien-Chih Chang, Jie Gao, and Hung Le. Computing diameter+2 in truly-subquadratic time for unit-disk graphs. In Proc. 40th International Symposium on Computational Geometry (SoCG), pages 38:1–38:14, 2024. doi:10.4230/LIPICS.SoCG.2024.38.
  • [9] Panagiotis Charalampopoulos, Pawel Gawrychowski, Yaowei Long, Shay Mozes, Seth Pettie, Oren Weimann, and Christian Wulff-Nilsen. Almost optimal exact distance oracles for planar graphs. J. ACM, 70(2):12:1–12:50, 2023. doi:10.1145/3580474.
  • [10] Maria Chudnovsky, Marcin Pilipczuk, Michal Pilipczuk, and Stéphan Thomassé. Quasi-polynomial time approximation schemes for the maximum weight independent set problem in H-free graphs. In Proc. 31st ACM-SIAM Symposium on Discrete Algorithms (SODA 2020), pages 2260–2278, 2020. doi:10.1137/1.9781611975994.139.
  • [11] Mark de Berg, Hans L. Bodlaender, Sándor Kisfaludi-Bak, Dániel Marx, and Tom C. van der Zanden. A framework for Exponential-Time-Hypothesis-tight algorithms and lower bounds in geometric intersection graphs. SIAM J. Comput., 49:1291–1331, 2020. doi:10.1137/20M1320870.
  • [12] Mark de Berg, Sándor Kisfaludi-Bak, Morteza Monemizadeh, and Leonidas Theocharous. Clique-based separators for geometric intersection graphs. Algorithmica, 85(6):1652–1678, 2023. doi:10.1007/S00453-022-01041-8.
  • [13] Zdeněk Dvořák and Sergey Norin. Strongly sublinear separators and polynomial expansion. SIAM J. Discrete Math., 30(2):1095–1101, 2016. doi:10.1137/15M1017569.
  • [14] Gideon Ehrlich, Shimon Even, and Robert Endre Tarjan. Intersection graphs of curves in the plane. J. Comb. Theory B, 21(1):8–20, 1976. doi:10.1016/0095-8956(76)90022-8.
  • [15] Jie Gao and Li Zhang. Well-separated pair decomposition for the unit-disk graph metric and its applications. SIAM J. Comput., 35(1):151–169, 2005. doi:10.1137/S0097539703436357.
  • [16] Peter Gartland. Quasi-Polynomial Time Techniques for Independent Set and Beyond in Hereditary Graph Classes. PhD thesis, University of California, Santa Barbara, USA, 2023. URL: https://www.escholarship.org/uc/item/0kk6d2jv.
  • [17] Peter Gartland, Daniel Lokshtanov, Tomás Masarík, Marcin Pilipczuk, Michal Pilipczuk, and Pawel Rzazewski. Maximum weight independent set in graphs with no long claws in quasi-polynomial time. In Proc. 56th ACM Symposium on Theory of Computing (STOC 2024), pages 683–691, 2024. doi:10.1145/3618260.3649791.
  • [18] I.Ben-Arroyo Hartman, Ilan Newman, and Ran Ziv. On grid intersection graphs. Discrete Mathematics, 87(1):41–52, 1991. doi:10.1016/0012-365X(91)90069-E.
  • [19] Petr Hliněný. The maximal clique and colourability of curve contact graphs. Discrete Applied Mathematics, 81(1):59–68, 1998. doi:10.1016/S0166-218X(97)00075-9.
  • [20] Jan Kratochvíl. A special planar satisfiability problem and a consequence of its NP-completeness. Discrete Applied Mathematics, 52(3):233–252, 1994. doi:10.1016/0166-218X(94)90143-0.
  • [21] Jan Kratochvíl and Jaroslav Nešetřil. Independent set and clique problems in intersection-defined classes of graphs. Commentationes Mathematicae Universitatis Carolinae, 031(1):85–93, 1990. URL: http://eudml.org/doc/17810.
  • [22] Hung Le and Christian Wulff-Nilsen. Optimal approximate distance oracle for planar graphs. In Proc. 62nd IEEE Symposium on Foundations of Computer Science (FOCS 2021), pages 363–374. IEEE, 2021. doi:10.1109/FOCS52979.2021.00044.
  • [23] James R. Lee. Separators in region intersection graphs. In Proc. 8th Innovations in Theoretical Computer Science Conference (ITCS 2017), pages 1:1–1:8, 2017. doi:10.4230/LIPIcs.ITCS.2017.1.
  • [24] Richard J. Lipton and Robert Endre Tarjan. A separator theorem for planar graphs. SIAM Journal on Applied Mathematics, 36(2):177–189, 1979. doi:10.1137/0136016.
  • [25] Jirí Matoušek. Near-optimal separators in string graphs. Comb. Probab. Comput., 23(1):135–139, 2014. doi:10.1017/S0963548313000400.
  • [26] Christian Sommer. Shortest-path queries in static networks. ACM Comput. Surv., 46(4):45:1–45:31, 2014. doi:10.1145/2530531.
  • [27] Mikkel Thorup and Uri Zwick. Approximate distance oracles. J. ACM, 52(1):1–24, 2005. doi:10.1145/1044731.1044732.
  • [28] Jie Xue and Meirav Zehavi. Parameterized algorithms on geometric intersection graphs. Computer Science Review, 58:100796, 2025. doi:10.1016/j.cosrev.2025.100796.
  • [29] Édouard Bonnet, Jędrzej Hodor, Tuukka Korhonen, and Tomáš Masařík. Treewidth is polynomial in maximum degree on weakly sparse graphs excluding a planar induced minor. CoRR, 2024. arXiv:2312.07962.