Separating Two Points with Obstacles in the Plane: Improved Upper and Lower Bounds
Abstract
Given two points in the plane, and a set of “obstacles” given as curves through the plane with assigned weights, we consider the point-separation problem, which asks for a minimum-weight subset of the obstacles separating the two points. A few computational models for this problem have been previously studied. We give a unified approach to this problem in all models via a reduction to a particular shortest-path problem, and obtain improved running times in essentially all cases. In addition, we also give fine-grained lower bounds for many cases.
Keywords and phrases:
obstacle separation, point separation, geometric intersection graph, -homology, fine-grained lower boundsCopyright and License:
2012 ACM Subject Classification:
Theory of computation Computational geometryAcknowledgements:
This work originated from a problem discussion group in the Fall of 2021, whose members collectively contributed to the discussion and development of some of this work’s preliminary results in the “arrangement model”, as well as a better understanding of the problem as a whole. In addition to the authors, this group included (in alphabetical order) Sam Barr, Therese Biedl, Reza Bigdeli, Anna Lubiw, Jayson Lynch, Karthik Murali, and Graeme Stroud.In addition, we want to thank Jeff Erickson, Elizabeth Xiao, and Da Wei Zheng for helpful discussions about homology.
Editors:
Anne Benoit, Haim Kaplan, Sebastian Wild, and Grzegorz HermanSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Given points and in the plane, and a weighted set of obstacles defined by simple closed curves (possibly also including their interiors), the point-separation problem asks for a minimum-weight subset of such that any path from to intersects some obstacle in . Equivalently, and are in different connected components of . We say such a subset separates and . An example of this problem can be found in Figure 1.
This is a natural problem that arises in various scenarios. As a toy application of this problem: Suppose every night your dog runs from his doghouse to your backpack to eat your homework, taking an unpredictable route (making use of windows and doors). You have noticed that your dog will forget about your homework if it smells a treat. You have a number of candidate locations to place treats, and you’d like to ensure your dog is distracted from your homework every day using the fewest treats possible. See Figure 2 for this example. Similar applications also arise when considering security (e.g., replacing the batteries in the fewest number of your dead security cameras to cover all possible paths from the entrance to your bank vault). Additionally, point-separation has found an application as a tool for constant-factor approximation of the well-studied APX-hard problem “barrier-resilience” [13].
For brevity, we will henceforth say “curve” to mean a simple closed curve in . The algorithmic complexity of the point-separation problem depends on the chosen computational model of the obstacles. Previous works use a few different models. We categorize and name the different classes of models used as follows:
-
Specific Obstacle-Type Models: Assume the set of curves takes on a special form with a standard representation, such as a set of disks, circles, or line segments.
-
The Oracle-based Intersection Graph Model: Assume the existence of several -time oracles that would allow the computation of the intersection graph of (the graph whose vertices are exactly the curves and whose edges correspond to pairwise intersections of these curves), as well as some additional information for each edge related to and (detailed in Section 2).
-
The Arrangement Model: Assume the arrangement of is provided as input, in the form of a plane (multi-)graph, with the faces corresponding to and labelled. This is a more graph-theoretic formulation. See Figure 3 for an example of such an arrangement.
Prior works discussing this problem each focused on only one of these paradigms, and the names for each paradigm are our own. We will not assume general position, so no paradigm is strictly more general than the others, since there are arrangements of obstacles with pairwise intersections, but only unique intersection points.
In our work, our key method is to frame all models of this problem in terms of a “homology cover”. Homology is a very broad topic in algebraic topology, which we will not attempt to summarize in this paper. We aim our paper at a typical computational geometry audience, and we will not assume prior knowledge of homology. We will present the necessary aspects in Section 2.
1.1 Prior Work (Brief)
In this subsection, we very briefly outline some key aspects of prior work. A significantly extended form of this section is in the appendix of the full version.
Most importantly for our methods, Kumar, Lokshtanov, Saurabh and Suri [13, Section 6] describe an algorithm that runs in polynomial time in the arrangement model. Their algorithm implicitly makes use of the homology cover (perhaps unintentionally), in the same sense that we will use it. In fact, their algorithm is in some ways analogous to an algorithm of Chambers, Erickson, Fox, and Nayyeri [5] for minimum-cuts (and maximum-flow) in surface graphs. These two algorithms are the main inspiration for our approach to the point-separation at a high-level, in all models.
1.2 Results and Organization
We obtain improved algorithms for the -point separation problem in several cases, which we outline in Table 1. As mentioned earlier, all of our positive results make use of a reduction to a shortest-path problem in the so-called “homology cover”. We discuss this formulation in Section 2, and then again more rigorously in the appendix of the full version. Using this reduction, the upper bounds are then given in Section 3.
| Model | Weights | Old | New | Cond. L.B. | |||
|---|---|---|---|---|---|---|---|
| Oracle | Yes | [3] | (Thm. 4) | ||||
| Oracle | No | [3] | (Thm. 5) | ||||
| Arrangement | Yes | [13] | (Thm. 6) | ||||
| Segments | No | [3] | (Cor. 9) | ||||
|
No | [3] | (Cor. 9) | None | |||
| Unit Disks | No | [4] | (Cor. 9) | None | |||
| Disks | No | [3] | (Cor. 9) | None | |||
|
No | [3] | (Cor. 9) | ||||
|
No | [3] | (Cor. 9) | ||||
| Segments | Yes | [3] | (Cor. 12) | ||||
|
Yes | [3] | (Cor. 12) | None | |||
|
Yes | [3] | (Cor. 12) | ||||
|
Yes | [3] | (Cor. 12) |
We also obtain several fine-grained lower bounds in Section 4. Our lower bounds also all have a shared foundation, which will be stated in Theorem 13. The resulting lower bounds are based on a few different hypotheses, and we give their details in the appendix of the full version.
2 Homology and Obstacles [Informal]
In this section, we will explain the main topological tools we will use to approach the point-separation problem. However, this will be an information section, not requiring prior knowledge of any aspect of topology. Rather, we will give an equivalent formulation of the important pieces using simpler tools from computational geometry. We give a more formal treatment in the appendix of the full version. Throughout this section, we will make (implicit) assumptions of general position and such, but the deferred formal treatment does not need these.
At a high-level, there are two main steps to the constructions of our approach. First, we will discuss what it means for a simple curve to separate and , and what tools exist to classify such curves. Second, we will discuss what it means for a set of obstacles to separate and . That is, when does the union of the obstacles contain a simple curve separating and ?
The simplest possible case of asking whether a simple curve separates and is characterized by the point-in-polygon problem, which asks: Given a point and a (simple) polygon , is inside ? In fact, this is equivalent to asking if separates and the point at infinity. There is a folklore algorithm for this problem that takes any ray starting at , and counts the number of intersections between and . Then, contains if and only if the number of intersections is odd. In fact, essentially the same algorithm can be used to test whether or not separates two points and . Rather than using a ray, take the segment . Count the number of intersections between and . The count is odd if and only if separates and . Moreover, there is in fact nothing special about rays or line segments in this problem. Any (closed) path between and would cross the same number of times, modulo . See Figure 4 for examples for these algorithms.
All three of these algorithms are equivalent in a sense. In fact, there is a further generalization: Given two points and on the sphere, a simple and closed curve (not covering or ), and any path , separates and if and only if crosses an odd number of times (regardless of the choice of ). Since the extended plane is homeomorphic to the sphere, a ray in the plane corresponds to a (simple) path in the sphere. See Figure 5 for an example.
The problems we have discussed so far are all completely static, and the methods do not provide much structure for solving more difficult problems. One of the most common ways to extend the point-in-polygon problem is to fix the polygon (or curve) , and aim to support fast queries of points. This problem is known as “point-location”, and it is well-studied in computational geometry [12]. However, we want a different sort of structure: We have a fixed pair of points and , and we wish to classify the curves that separate them. Since we have fixed and , we can also fix the path between them – in most cases, we will use the line segment . Then, the problem of classifying curves that separate and becomes the problem of classifying curves that cross an odd number of times.
It will be helpful for demonstration to make some transformations to the space we work in. That is, we will perform a sequence of homeomorphisms. We start with the extended plane with the two marked points and , and the line segment (see Figure 6(a)). No curves we will be classifying cross or , so we may assume there are punctures at and . We can enlarge these punctures into holes with a homeomorphism. Next, since we have the extended plane, we can make one of the punctures the outer face, obtaining an annulus (see Figure 6(b) and Figure 6(c)). In performing these steps, the line segment becomes a path between the inner and outer boundaries of the annulus.
We now present a method for constructing an important space called the homology cover111We use the term “homology cover” to refer to the one-dimensional -homology cover of the annulus. . Take the specified path between the two boundaries (see Figure 7(a)) and slice it open (see Figure 7(b)). Then, create a second copy of the sliced annulus, and glue them together in a way that matches up the orientations of the sliced ends (see Figure 7(c)).
Alternatively, an equivalent construction is to create two copies of the original space (whether that be the extended plane or the annulus), and use each side of the path from to as a (separate) “portal” between the two copies. A more general form of this “portal” idea has been studied in the form of “portalgons” [14, 15], of which the homology cover is essentially a special case. See Figure 8 for an example of this construction.
One important aspect of this construction is that it involves the connection of two identical copies of the annulus (i.e., the extended plane with punctures and ). In Figure 7, we also show how this construction transforms two curves – one separating the two boundaries, and one not separating them. The structure we will make use of to study curves separating and in the plane ultimately stems from an important set of facts:
Fact 1.
For a simple curve in the annulus (or the plane) that gets mapped to the set in the homology cover, and a point along that gets mapped to corresponding points and in the homology cover, the following are all equivalent:
-
separates and .
-
separates the two boundaries in the homology cover.
-
has one connected component (i.e., it is one closed curve instead of two).
-
The points and are connected by a path through .
It is this last characterization that will be the most critical for obstacles. In particular, a consequence of this characterization is that if two corresponding points and in the homology cover (corresponding in the sense that they are identical points in different copies of the annulus/plane) have a simple path between them, then that path can be mapped to a closed curve separating and .
2.1 Obstacles and the Homology Cover
We now have tools for characterizing closed curves that separate and . We’d now like to characterize sets of obstacles that separate and . In other words, we’d like to characterize unions of closed curves (obstacles) that contain a closed curve separating and . We’ll give two different tools for this, first for the arrangement model, then for the oracle model. For simplicity, we will work exclusively with obstacles that do not individually separate and (that is, obstacles that get mapped to two separate closed curves in the homology cover). We will reduce to this case algorithmically at the start of Section 3.
In the arrangement model of the point-separation problem, we are given a plane graph (the arrangement) with specified faces and (can be obtained from points via point-location), and a set of obstacles , each given as a connected subgraph. The homology cover has a simple graph-theoretic interpretation in this framework: Take any (simple) dual-path of faces from to – this is will serve as the “portal”. Next, create two copies of , each with the faces and removed. We will create a combined graph starting from the union of and . For each edge used in the dual-path , delete from both and (inside ). Denote the corresponding vertices of and in each of and as and , respectively. Then create new edges and in . This form of the homology cover is visualized in Figure 9.
With this particular arrangement structure Kumar, Lokshtanov, Saurabh and Suri [13, Section 6] built a graph using one vertex per obstacle-vertex incidence (in each copy of the plane graph). We will build a smaller graph of similar form to theirs. First, for each obstacle (which induces a subgraph of ), pick some arbitrary canonical point . Since this choice is arbitrary, it will sometimes be useful to assume it is a specific point – this will primarily be useful for specific obstacle types. Assume that is also a vertex in the subgraph of induced by (and if it is not, modify so that it is, with either a subdivision or a new degree- vertex). Note that since is connected in , every other vertex is connected to by only edges in . Given a plane graph with faces and , a dual-path , obstacles , and canonical points for each obstacle, the auxiliary graph is a bipartite graph constructed as follows:
-
The first set of vertices are the copies of arrangement vertices in the homology cover. For a vertex , we denote these two copies and .
-
The second set of vertices are the copies of the obstacles/canonical points in the homology cover. For an obstacle , we denote these two copies as and .
-
The values and in each of the above are indicator bits, and can be stored as and , respectively.
-
A vertex copy has an edge connecting it to a canonical point copy when:
-
–
(that is, the point belongs to the obstacle in the arrangement), and…
-
–
The canonical point of has a path through the edges of to whose intersection with the edges of has size modulo (i.e., if , the size must be even, and if , the size must be odd). Equivalently, the projected connected component of containing the canonical point copy also contains .
-
–
We visualize an example of the auxiliary graph in Figure 10.
The auxiliary graph is useful because the shortest path between any two corresponding vertex copies or (separately) any two corresponding canonical point copies both correspond exactly to the solution to the point-separation problem. The high-level construction to prove this fact is as follows:
-
Suppose there is a set of obstacles . We’d like to determine when separates and .
-
Denote the set of copies of the obstacles in in the homology cover as , so that every element of is a closed curve representing one of the two connected components of an element of projected into the homology cover.
-
By Fact 1, we deduce that separates and if and only if there is a path from to along the union of obstacle copies in , for some arrangement vertex among pairs of elements in only.
-
Moreover, since each obstacle is connected, we may further assume that any such path visits each obstacle copy at most once, and moreover that it only visits each obstacle at most once.
-
We may further assume that any such path visits the canonical point copy of each such obstacle copy, by inserting a path to and then from the canonical point copy while the obstacle copy is visited. Note that the resulting path may not be simple in the plane.
-
Such paths also directly correspond to paths in the auxiliary graph, using only “obstacle vertices” corresponding to elements of and the “arrangement vertices” incident to pairs of elements in .
-
With appropriate weights, the problem of finding the minimum-weight set with this property then reduces to the problem of finding the pair with the shortest distance in the auxiliary graph, so this is a shortest-path problem!
-
A similar argument can show that an alternative algorithmic formulation is to find the pair with the shortest-distance in the auxiliary graph.
This essentially completes the set of tools necessary for the arrangement model. These arguments are given in more detail in the appendix of the full version.
For the oracle model, the purpose of the oracles will be to construct the geometric intersection graph of the obstacle copies in the homology cover (which we will denote as ). We will call the intersection graph in the homology cover. See Figure 11 for an example. We will present two different constructions of this graph. They are equivalent, and each of them is quite simple, but they will serve two different purposes: The first will clarify which types of oracle queries are necessary, and provide an algorithmic construction. The second will instead build on the tools we have for the arrangement model, proving the correctness of another shortest-paths approach.
Let denote the set of obstacles in the plane. We assume the canonical points for each obstacle are given (or implied) – they will be used by the oracle. We also assume some simple path is fixed – this will also be used by the oracle. In most cases, will be . The first construction of the graph is as follows:
-
For each obstacle , create two vertices and .
-
For each pair of obstacles with canonical points , and values , we connect vertices and by an edge if there is a path from to in crossing exactly times, for some where .
Testing for this condition is actually the only type of oracle query needed (although we will also require support for the case when later). Cabello and Giannopoulos [3] used a larger set of query types, but together they can be used to perform this type by carefully choosing the canonical points and fixing to , so our variant of the oracle model is slightly more general (although practically equivalent).
We’d like a similar algorithmic property for the intersection graph in the homology cover that we have for the auxiliary graph . The second construction will be what gives us that property, by constructing from :
-
For each arrangement vertex in , let its adjacent vertices be denoted . Delete and create a clique over .
-
After performing this for every arrangement vertex , the result is exactly the intersection graph in the homology cover .
-
Therefore, the set of vertices visited by the shortest path from some to (over all possible , breaking ties arbitrarily) corresponds to a minimum-weight set of obstacles separating and .
For specific obstacle types, we will usually work with , although we will do it implicitly. Hence, with the tools from this section, we can now discuss algorithms in all three model types as solutions to a certain form of shortest-path problem.
3 Algorithmic Results
In this section, we will devise algorithms for the point-separation problem based on our homology cover structures. We will devise algorithms for all three model types: Some that work with the arrangements of curves, some that work with the “oracle model” (the intersection graph in the homology cover), and some that work with specific types of obstacles. Most of our algorithms are fairly simple reductions to various known shortest-path algorithms, greatly simplifying some of the previous approaches to the point-separation problem. However, some of them are more involved.
In the previous section, we assumed no obstacle individually separated and . Before moving on, we quickly show this is enough:
Observation 2.
Let be a set of obstacles, and let and be points. Suppose an oracle exists that, for an obstacle , determines whether itself separates and , all in time. Let be the set of all obstacles that do. Then an instance of the weighted (unweighted) point-separation problem over can be reduced to an instance of the weighted (unweighted) point-separation problem over in time. In particular, such a reduction returns the best solution out of the solved subproblem (if any), and each of the individual obstacles forming solutions (if any).
3.1 General Weighted Obstacles in Oracle Model
With no significant further work, we already obtain some naïve algorithms by using a result in the appendix of the full version (or the constructions in Section 2):
Theorem 3.
For points and , and a weighted set of obstacles that have pairwise intersections, the point-separation problem can be solved in time.
Proof.
Compute the intersection graph in the homology cover of . For each , compute the shortest path from to in . The smallest such path induces the solution by a result in the appendix of the full version. Each shortest path can be computed in time by Dijkstra’s algorithm with a Fibonacci heap [11], and there are total such paths. Note that Theorem 3 matches the result of [3], although the algorithm is much simpler. When (i.e., dense intersection graphs), this algorithm runs in time, which could also be obtained by running Floyd-Warshall for APSP instead of Dijkstra. It is not known if the general form of weighted APSP can be solved in “truly” subcubic time (see the appendix of the full version). However, since the weights are applied to vertices, not edges, there is a known faster algorithm (also discussed in the appendix of the full version):
Theorem 4.
For points and , and a weighted set of obstacles , the point-separation problem can be solved in time in the oracle model, where is the matrix multiplication exponent.
Proof.
Apply the same reduction to APSP as before, but use the algorithm of Abboud, Fischer, Jin, Williams, and Xi [1] for APSP with real vertex weights.
3.2 General Unweighted Obstacles in Oracle Model
We are also interested in the point-separation problem for unit weights, which corresponds to shortest paths for unit weights. In this case, we can obtain faster algorithms:
Theorem 5.
For points and , and an unweighted set of obstacles , the point-separation problem can be solved in time, where is the matrix multiplication exponent.
Proof.
Compute the intersection graph in some homology cover of , and then run unweighted undirected APSP [16] on , for total time.
3.3 General Weighted Obstacles in Arrangement Model
We can also obtain results using the arrangement instead of the intersection graph. The simplest of these is a slight modification of Theorem 3:
Theorem 6.
For points and , a weighted set of obstacles , and an arrangement of , where is given as lists of vertices, let be the total number of obstacle-vertex incidences. Then, the point-separation problem can be solved in time.
Proof.
Let be the auxiliary graph in the homology cover, which has vertices and edges. By a result in the appendix of the full version, it suffices to do one of the following:
-
Compute the single-source shortest-path (SSSP) tree from each obstacle in .
-
Compute the SSSP tree from each arrangement vertex in .
Let . Each SSSP computation can be performed in time, and such computations suffice to solve the problem. This theorem in particular is of note because as we will see later, it is essentially optimal assuming the APSP conjecture, at least in the case when and , as we will see in Section 4.
3.4 Restricted Obstacle Classes without Weights
As we will discuss in the appendix of the full version, Chan and Skrepetos [6, 7] studied APSP for several forms of unweighted/undirected geometric intersection graphs. Their intersection graphs are in the plane, but with some extra work it is possible to study intersection graphs in the homology cover, and consequently the unweighted point-separation problem.
Theorem 7.
For points and , and an unweighted set of obstacles . Let be the set of “mapped” obstacles in the homology cover. Let (“static intersection”) be the time complexity for checking if each of different objects in intersects any object in some subset of size . Assume is super-additive, so that . Then point-separation over can be solved in time.
Proof.
Run APSP for the intersection graph in the homology cover via the algorithm of Chan [10, Theorem 2] (see further discussion in the appendix of the full version).
To use this result, we need efficient algorithms for static intersection in the homology cover:
Lemma 8.
For points and , the following values of hold for restricted obstacle types in the homology cover:
| Obstacle Class | |
|---|---|
| General Disks | |
| Axis-Aligned Line Segments | |
| Arbitrary Line Segments |
The proof of the lemma is left to the appendix of the full version. At a high-level, all cases are first reduced to the planar static intersection problem. In the case of line segments, this becomes the standard planar static intersection problem for line segments. For disks, this is not the case, and the algorithm is more involved.
The combination of these two results give an important corollary:
Corollary 9.
For points and , the unweighted point-separation problem can be solved in time for axis-aligned line segments (or -length rectilinear polylines), time for line segments (or -length polylines), and time for general disks or circles that do not contain both and .
3.5 Restricted Obstacle Classes with Weights
We will now present a method for solving the weighted point-separation problem using a tool called “biclique covers”, which are essentially a tool for a type of graph sparsification.
For a graph , a biclique in is a complete bipartite subgraph (, where are disjoint). The size of a biclique is the number of vertices it contains (). A biclique cover is a collection of bicliques in covering the edges , and its size is the the sum of all sizes in its bicliques. Biclique covers of geometric intersection graphs in two-dimensions are well-studied. We summarize known results in Table 2.
| Graph Type | Cover Size | Construction Time |
|---|---|---|
| line segment intersection | ||
| Axis-aligned line seg. intersection | ||
| -clique-free line seg. intersection |
Biclique covers are useful in our case because they can be used for faster vertex-weighted shortest paths. In particular:
Lemma 10.
Let be an -vertex (undirected) graph with vertex-weights admitting a biclique cover of size that can be constructed in time. Then APSP over can be solved in time.
We leave the proof to the appendix of the full version.
These results aren’t quite enough for the point-separation problem, since what we need is actually a biclique cover in the homology cover. Fortunately, we can construct this:
Lemma 11.
Let and be designated points in the plane, and let be a set of line segments with . Let be the intersection graph in the homology cover, and let be the intersection graph in the plane. Then has a homology cover of size that can be found in time. Moreover, if contains no -clique (including if is a set of rectilinear segments, in which case contains no -clique), then has a homology cover of size that can be found in time.
We leave the proof of this to the appendix of the full version as well. The proof is similar to that of Theorem 7.
The combination of these results gives the following theorem:
Theorem 12.
For a weighted set of obstacles , and points , the point-separation can be solved in time if is a set of line segments, time if is a set of axis-aligned line segments, and time if is a set of line segments whose intersection graph has no -clique. The same bounds hold if each obstacle is an -length polyline among lines of the same properties.
Note that a biclique cover for -length polylines can be recovered from biclique covers over the individual line segments (adjusted slightly so that the line segments in the same polyline do not overlap).
4 Lower Bounds
In this section, we present several related fine-grained lower bounds for specific cases of the point-separation problem. The main intermediate tool is the problem of finding a minimum-weight walk of length in a directed graph, for a given (or detecting if any walk of length exists). All of our lower bounds are based on the following unified theorem:
Theorem 13.
For a positively edge-weighted directed graph with vertices and edges with maximum edge-weight , and an integer , there exists three sets of obstacles, each with a weight equal to that of some edge in , so that each of the following properties holds for one set:
-
All obstacles are line segments.
-
All obstacles are length- polylines, and the total number of unique intersection points of the obstacles is .
-
All obstacles are length- rectilinear polylines.
Moreover, there are points and in the plane so that has a walk of length with weight at most if and only if there is some subset of (for any ) that separates and and has weight at most , so long as . Furthermore, each of can be constructed in time proportional to their sizes.
Proof.
For each property, we will construct a reduction from min-weight -walk (for fixed ) in a directed edge-weighted graph to point separation, with the stated guarantees. The constructions for each property are essentially the same. We will focus on the line segment case, and explain the modifications afterwards.
The construction is visualized in Figure 12. For each vertex (), assign the column . For each value , assign the row . For each directed edge , with weight create line segments, each also with weight . Each should go from the th column to the th column, and the th row to the th row (for each ). We call these the edge segments. Pick to be some point to the left of the columns, and to be some point to the right. For the th column, create a set of rectilinear line segments connecting the top point of the th column to the bottom, so that the path formed by these line segments lies to the left of at its coordinate, ensuring that these line segments do not intersect the corresponding line segments generated for other columns, nor do they cross the minimal orthogonal rectangle containing the previous set of line segments. We call these the vertex segments. These two segment types form the entirety of the obstacles, so the stated time complexity follows. We need only prove correctness of the reduction.
A -walk through starting and ending at a vertex corresponds exactly to a connected set of edge segments from the point to , and both also have the same weight. The forward direction of the reduction follows: Given such a set of edge segments, a set of vertex segments of weight exactly exists (those for the th column) so that the union of the two separates and , and has the specified weight. For the backwards direction of the reduction: For a set with weight at most , if , then it is only possible to have one maximal connected set of vertex segments in . Each of the sets of (potential) obstacles crossed by paths in Figure 13 must have at least one obstacle chosen from them for the whole set to separate and , so at least one such maximal connected set of vertex segments must be in . Hence, the total weight of the remaining obstacles in is , and some subset of these obstacles must themselves be a connected set of edge segments (one per row) corresponding exactly to a -walk in .
The two modified constructions with polylines are obtained by replacing the edge segments with polylines that have the desired properties. These cases are visualized in Figure 14.
There are a number of fine-grained lower bounds for min-weight -walk and -walk detection. In particular, all such bounds hold for fixed and graphs where -walks and -cycles coincide (which is itself always true for in graphs with no self-loops, and is otherwise implied by a property called “-circle-layered”). In the appendix of the full version, we discuss the following results that follow from known fine-grained bounds and Theorem 13:
|
|
|
||||||
|---|---|---|---|---|---|---|---|---|
| weighted line segments | edge-weighted APSP | |||||||
| weighted line segments | minimum-weight -clique | |||||||
| weighted length- rectilinear polylines | minimum-weight -clique | |||||||
| unweighted line segments | max--SAT | |||||||
| unweighted length- rectilinear polylines | max--SAT | |||||||
|
edge-weighted APSP |
5 Conclusion
We have discussed several upper and lower bounds for the point-separation problem in various cases, and we conclude by briefly listing some of the most interesting open problems:
-
Is there a near-quadratic algorithm for general weighted obstacles? Can a conditional lower bound (based on any popular hypotheses) excluding this possibility be formulated?
-
Can a (truly) sub-quadratic algorithm be devised for disks, unit disks, or axis-aligned segments? Is there a non-trivial fine-grained lower bound in any of these cases?
-
Are there faster algorithms or stronger lower bounds for the unweighted versions of the problem?
We note that it seems very likely that unit disks would admit a slightly sub-quadratic algorithm, since APSP is known to be solvable for unit disk graphs in (essentially) slightly sub-quadratic time [9], and the methods seem as though this method could plausibly be extended to the homology cover.
References
- [1] Amir Abboud, Nick Fischer, Ce Jin, Virginia Vassilevska Williams, and Zoe Xi. All-pairs shortest paths with few weights per node. In Proceedings of the 57th Annual ACM Symposium on Theory of Computing, pages 1956–1964, 2025. doi:10.1145/3717823.3718240.
- [2] Josh Alman, Ran Duan, Virginia Vassilevska Williams, Yinzhan Xu, Zixuan Xu, and Renfei Zhou. More asymmetry yields faster matrix multiplication. In Yossi Azar and Debmalya Panigrahi, editors, Proceedings of the 2025 Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2025, New Orleans, LA, USA, January 12-15, 2025, pages 2005–2039. SIAM, 2025. doi:10.1137/1.9781611978322.63.
- [3] Sergio Cabello and Panos Giannopoulos. The complexity of separating points in the plane. Algorithmica, 74(2):643–663, 2016. doi:10.1007/s00453-014-9965-6.
- [4] Sergio Cabello and Lazar Milinković. Two optimization problems for unit disks. Comput. Geom., 70-71:1–12, 2018. doi:10.1016/j.comgeo.2017.12.001.
- [5] Erin W. Chambers, Jeff Erickson, Kyle Fox, and Amir Nayyeri. Minimum cuts in surface graphs. SIAM J. Comput., 52(1):156–195, 2023. doi:10.1137/19M1291820.
- [6] Timothy M. Chan. More algorithms for all-pairs shortest paths in weighted graphs. In David S. Johnson and Uriel Feige, editors, Proceedings of the 39th Annual ACM Symposium on Theory of Computing, San Diego, California, USA, June 11-13, 2007, pages 590–598. ACM, 2007. doi:10.1145/1250790.1250877.
- [7] Timothy M. Chan. More algorithms for all-pairs shortest paths in weighted graphs. SIAM J. Comput., 39(5):2075–2089, 2010. doi:10.1137/08071990X.
- [8] Timothy M Chan. Finding triangles and other small subgraphs in geometric intersection graphs. In Proceedings of the 2023 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 1777–1805. SIAM, 2023. doi:10.1137/1.9781611977554.CH68.
- [9] Timothy M Chan and Dimitrios Skrepetos. All-pairs shortest paths in unit-disk graphs in slightly subquadratic time. In 27th International Symposium on Algorithms and Computation (ISAAC 2016), pages 24–1. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2016. doi:10.4230/LIPIcs.ISAAC.2016.24.
- [10] Timothy M. Chan and Dimitrios Skrepetos. All-pairs shortest paths in geometric intersection graphs. J. Comput. Geom., 10(1):27–41, 2019. doi:10.20382/JOCG.V10I1A2.
- [11] Thomas H Cormen, Charles E Leiserson, Ronald L Rivest, and Clifford Stein. Introduction to algorithms. MIT press, 2022.
- [12] Mark de Berg, Otfried Cheong, Marc J. van Kreveld, and Mark H. Overmars. Computational geometry: algorithms and applications, 3rd Edition. Springer, 2008. doi:10.1007/978-3-540-77974-2.
- [13] Neeraj Kumar, Daniel Lokshtanov, Saket Saurabh, and Subhash Suri. A constant factor approximation for navigating through connected obstacles in the plane. In Dániel Marx, editor, Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms, SODA 2021, Virtual Conference, January 10 - 13, 2021, pages 822–839. SIAM, 2021. doi:10.1137/1.9781611976465.52.
- [14] Maarten Löffler, Tim Ophelders, Rodrigo I. Silveira, and Frank Staals. Shortest Paths in Portalgons. In Erin W. Chambers and Joachim Gudmundsson, editors, 39th International Symposium on Computational Geometry (SoCG 2023), volume 258 of Leibniz International Proceedings in Informatics (LIPIcs), pages 48:1–48:16, Dagstuhl, Germany, 2023. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.SoCG.2023.48.
- [15] Tim Ophelders, Maarten Löffler, Rodrigo I Silveira, and Frank Staals. Shortest paths in portalgons. Journal of Computational Geometry, 15(2):174–221, 2024.
- [16] Raimund Seidel. On the all-pairs-shortest-path problem in unweighted undirected graphs. J. Comput. Syst. Sci., 51(3):400–403, 1995. doi:10.1006/JCSS.1995.1078.
- [17] Jack Spalding-Jamieson and Anurag Murty Naredla. Separating two points with obstacles in the plane: Improved upper and lower bounds, 2025. doi:10.48550/arXiv.2504.17289.
