## 1 Introduction

Polygon simplification is well studied in computational geometry, with numerous applications in cartographic visualization, computer graphics and data compression [10, 11]. Techniques for simplifying polygons and polylines have appeared in the literature in various forms. Common goals of these simplification algorithms include to preserve the shape of the polygon, to reduce the number of vertices, to reduce the space requirements, and to remove noise (extraneous bends) from the polygon boundary (e.g., [2, 6, 7]). In this paper we consider a specific version of polygon simplification introduced by Aichholzer et al. [1], which keeps reflex corners intact, but minimizes the number of convex corners. Aichholzer et al. showed that such a simplification can help achieve faster solutions for many geometric problems such as answering shortest path queries (as shortest paths stay the same), computing Voronoi diagrams, and so on.

A simple polygon is a connected region without holes. Let be a polygon with reflex vertices and possibly with holes and islands. An *island* is a simple polygon that lies entirely inside a hole. A *reflex corner* of consists of three consecutive vertices on the boundary of such that the angle inside is more than . We refer the vertex as a *reflex* vertex of . The vertices of that are not reflex are called *convex* vertices. By a *component* of , we refer to a maximally connected region of . A polygon * subsumes * if , each component of subsumes a distinct component of , i.e., , and the reflex corners of coincide with the reflex corners of . A *-convex subsuming polygon* contains at most convex vertices. A *min-convex subsuming polygon* is a subsuming polygon that minimizes the number of convex vertices. Figure 1(a) illustrates a polygon , and Figures 1(b) and (c) illustrate a subsuming polygon and a min-convex subsuming polygon of , respectively. A *subsuming chain* of is a minimal path on the boundary of whose end edges coincide with a pair of edges of , as shown in Figure 1(b).

Aichholzer et al. [1] showed that for every polygon with vertices,
of which are reflex, one can compute in linear time a subsuming polygon
with at most vertices. Note that although a subsuming polygon with
vertices always exists, no polynomial-time algorithm is known for computing a
min-convex subsuming polygon. Finding an optimal subsuming polygon seems challenging since
it does not always lie on the arrangement of lines (resp., ) determined by the edges (resp.,
pairs of vertices) of the input polygon. Figure 1(c)
illustrates an optimal polygon for the polygon of Figure 1(a),
where . On the other hand, Figure 1(d) shows that
a min-convex subsuming polygon may not always lie on or .
Note that the input polygon of Figure 1(d)
is a *simple polygon*, i.e., it does not contain any hole. Hence determining min-convex
subsuming polygons seems challenging even for simple polygons. In fact,
Aichholzer et al. [1] posed an open question that asks to determine the
complexity of computing min-convex subsuming polygons, where the input is restricted to simple polygons.

### Our contributions.

In this paper we show that the problem of computing a min-convex subsuming polygon is NP-hard for polygons possibly with holes (Section 2). We noted earlier that discretizing the solution space is a potential challenge, i.e., that the optimal polygon may not always lie on the line arrangement determined by the input polygon (Figure 1(d)). Interestingly, our NP-hardness result does not seem to utilize this challenge, instead, the hardness holds even when we restrict the subsuming chains to have constant length and to lie on .

A question that naturally appears in this context is whether such restrictions on subsuming chains can make the problem easier for nontrivial classes of polygons. For example, consider an -monotone polygon^{1}^{1}1 is -monotone if every vertical line intersects at most twice. , e.g., see Figure 2(a). Then it is not difficult to see that there exists a min-convex polygon such that each subsuming chain has constant length and lies on . The argument is simple except for the subsuming chains that covers the two ends of , e.g., see Figure 2(b). A simple proof is included in Section 3.

We then show that the question can be answered affirmatively for arbitrary simple polygons, i.e., for any simple polygon , one can compute in polynomial time, a min-convex subsuming polygon under the restriction that the subsuming chains are of constant length and lie on .

### Organization.

The rest of the paper is organized as follows. Section 2 presents the NP-hardness result for polygons with holes. Section 3 presents our observations on monotone polygons. Section 4 describes the techniques for computing subsuming polygons for simple polygons. Finally, Section 5 concludes the paper discussing directions to future research.

## 2 NP-hardness of Min-Convex Subsuming Polygon

In this section we prove that it is NP-hard to find a subsuming polygon
with minimum number of convex vertices. We denote the problem by Min-Convex-Subsuming-Polygon.
We reduce the NP-complete problem monotone planar 3-SAT [5],
which is a variation of the 3-SAT problem as follows: Every clause in a monotone planar
3-SAT consists of either three negated variables (*negative clause*) or three non-negated
variables (*positive clause*). Furthermore, the bipartite graph constructed from the
variable-clause incidences, admits a planar drawing such that all the vertices corresponding
to the variables lie along a horizontal straight line , and all the vertices corresponding
to the positive (respectively, negative) clauses lie above (respectively, below) . The
problem remains NP-hard even when each variable appears in at most four clauses [4].

The idea of the reduction is as follows. Given an instance of a monotone planar 3-SAT with variable set and clause set , we create a corresponding instance of Min-Convex-Subsuming-Polygon. Let be the number of convex vertices in . The reduction ensures that if there exists a satisfying truth assignment of , then can be subsumed by a polygon with at most convex vertices, and vice versa.

Given an instance of monotone planar 3-SAT, we first construct an orthogonal polygon with holes.
We denote each clause and variable using a distinct axis-aligned rectangle, which we refer to as the
*c-rectangle* and *v-rectangle*, respectively. Each edge connecting a
clause and a variable is represented as a thin vertical strip, which we call an *edge tunnel*.
Figures 3(a) and (b) illustrate an instance of monotone planar 3-SAT and the corresponding
orthogonal polygon, respectively. While adding the edge tunnels, we ensure for each v-rectangle that the tunnels coming from top lie to the left of all the tunnels coming from the bottom. Figure 3(b) marks the top and bottom edge tunnels by upward and downward rays, respectively. The v-rectangles, c-rectangles and the edge tunnels may form one or more holes, as it is shown by diagonal line pattern in Figure 3. We now transform to an instance of Min-Convex-Subsuming-Polygon.

We first introduce a few notations.
Let be a convex quadrangle and let be an infinite line that passes through and .
Assume also that and intersect at some point , and all lie on the
same side of , as shown in Figures 3(c)–(d).
Then we call the quadrangle a *tip* on , and the triangle a *cap* of . The tip is called *top-right*, if the slope of is positive; otherwise, it is called a *top-left* tip.

### Variable gadget.

We construct variable gadgets from the v-rectangles. We add some top-right (and the same number of top-left) tips at the bottom side of the v-rectangle, as show in Figure 3(e). There are three top-right and top-left tips in the figure. For convenience we show only one top-left and one top-right tip in the schematic representation, as shown in Figure 3(f). However, we assign weight to these tips to denote how many tips there should be in the exact construction. We will ensure a few more properties: (I) The caps do not intersect the boundary of the v-rectangle, (II) no two top-left caps (or, top-right caps) intersect, and (III) every top-left (resp., top-right) cap intersects all the top-right (resp., top-left) caps.

Observe that each top-left tip contributes to two convex vertices such that covering them with a cap reduces the number of convex vertices by 1. The peak of the cap reaches very close to the top-left corner of the v-rectangle, which will later interfere with the clause gadget. Specifically, this cap will intersect any downward cap of the clause gadget coming through the top edge tunnels. Similarly, each top-right tip contributes to two convex vertices, and the corresponding cap intersects any upward cap coming through the bottom edge tunnels.

Note that the optimal subsuming polygon cannot contain the caps from both the top-left and top-right tips. We assign the tips with a weight of . In the hardness proof this will ensure that either the caps of top-right tips or the caps of top-left tips must exist in , which will correspond to the true and false configurations, respectively.

### Clause gadget.

Recall that, by definition, each clause consists of three variables and so it is incident to three edge tunnels. Figure 4(a) illustrates the transformation for a c-rectangle. Here we describe the gadget for the positive clauses, and the construction for negative clauses is symmetric. We add three downward tips incident to the top side of the c-rectangle, along its three edge tunnels. Each of these downward tip contributes to two convex vertices such that covering the tip with a cap reduces the number of convex vertices by 1. Besides, the corresponding caps reach almost to the bottom side of the v-rectangles, i.e., they would intersect the top-left caps of the -rectangles. Let these tips be from left to right, and let be the corresponding caps.

We then add a down-left and a down-right tip at the top side of the -rectangle between and , where , as shown in Figure 4(a). Let the tips be from left to right, and let the corresponding caps be . Note that the caps corresponding to and , where , intersect each other. Therefore, at most two of these four caps can exist at the same time in the solution polygon. Observe also that the caps corresponding to intersect the caps corresponding to , respectively. Consequently, any optimal solution polygon containing none of has at least 12 convex vertices along the top boundary of the c-rectangle, as shown in Figure 4(b).

We now show that any optimal solution polygon containing at least caps from have exactly 11 convex vertices along the top boundary of the c-rectangle. We consider the following three cases:

Case 1 (): If (resp., ) is in , then must contain (resp., ). Figure 4(c) illustrates the case when contains . If is in , then must contain . In all the above scenarios the number of convex vertices along the top boundary of the c-rectangle is 11.

Case 2 (): If contains , then either or must be in . Otherwise, contains either or . If that contains , as in Figure 4(d), then must lie in . In the remaining case, must lie in . Therefore, also in this case the number of convex vertices along the top boundary of the c-rectangle is 11.

Case 3 (): In this scenario cannot contain any of . Therefore, as shown in Figure 4(e), the number of convex vertices along the top boundary of the c-rectangle is 11.

As a consequence we obtain the following lemma.

###### Lemma 2.1.

If a clause is satisfied, then any optimal subsuming polygon reduces exactly three convex vertex from the corresponding c-rectangle.

### Reduction.

Although we have already described the variable and clause gadgets, the optimal subsuming polygon still may come up with some unexpected optimization that interferes with the convex corner count in our hardness proof. Figure 5(left) illustrates one such example. Therefore, we replace each convex corner that does not correspond to the tips by a small polyline with alternating convex and reflex corners, as shown Figure 5(right). By construction, it is now straightforward to observe the following fact.

###### Remark 1.

Let be a reflex vertex of , and let be the first reflex vertex after while walking clockwise on the boundary of starting at . Then the number of convex vertices that can appear between and is at most two. Furthermore, if there are two convex vertices, then either they correspond to a tip, or form an turn using only orthogonal line segments.

We now prove the NP-hardness of computing an optimal subsuming polygon.

###### Theorem 2.1.

Finding an optimal subsuming polygon is NP-hard.

###### Proof.

Let be an instance of monotone planar 3-SAT and let be the corresponding instance of Min-Convex-Subsuming-Polygon. Let be the number of convex vertices in . We now show that admits a satisfying truth assignment if and only if can be subsumed using a polygon having at most convex vertices.

First assume that admits a satisfying truth assignment. For each variable , we choose either the top-right caps or the top-left caps depending on whether is assigned true or false. Consequently, we save at least convex vertices. Consider any clause . Since is satisfied, one or more of its variables are assigned true. Therefore, for each positive (resp., negative) clause, we can have one or more downward (resp., upward) caps that enter into the v-rectangles. By Lemma 2.1, we can save at least three convex vertices from each c-rectangle. Therefore, we can find a subsuming polygon with at most convex vertices.

Assume now that some polygon with at most convex vertices can subsume . We now find a satisfying truth assignment for . By Remark 1 we can restrict our attention only to c- and v-rectangles. Note that the maximum number of convex vertices that can be reduced from the c-rectangles is at most . Therefore, must reduce at least convex vertices from each v-rectangle. Recall that in each v-rectangle, either the top-right or the top-left caps can be chosen in the solution, but not both. Therefore, the v-rectangles cannot help reducing more than convex vertices. If contains the top-right caps of the v-rectangle, then we set the corresponding variable to true, otherwise, we set it to false. Since has at most convex vertices, and each c-rectangle can help to reduce at most convex vertices (Lemma 2.1), must have at least one cap from at each c-rectangle. Therefore, each clause must be satisfied. Recall that the downward (resp., upward) caps coming from edge tunnels are designed carefully to have conflict with the top-left (resp., top-right) caps of v-variables. Since top-left and top-right caps of v-variables are conflicting, the truth assignment of each variable is consistent in all the clauses that contains it. ∎

It is straightforward from the construction of that no optimal subsuming polygon that subsumes can have a subsuming chain of length larger than 3, and there always exists an optimal solution that lies on . Hence, Theorem 2.1 holds even under the restriction that the subsuming chains must be of constant length and lie on . In Sections 3 and 4, we will show that these restrictions make the problem polynomial-time solvable for simple polygons.

## 3 Monotone Polygons

In this section, we give a straightforward algorithm to compute a min-convex subsuming polygon of -monotone polygons. In fact, we prove a stronger claim that every -monotone polygon admits a min-convex subsuming polygon such that the subsuming chains are of constant length and lie on .

Let and denote the upper and lower chains of , respectively. Moreover, let (resp., ) be the leftmost (resp., rightmost) vertex of ; notice that the vertices and are both convex (as is -monotone) and are shared between and . Let (resp., ) be the set of reflex vertices of that lie on (resp., on ); we let and . For a reflex vertex , where , let (resp., ) denote the line determined by the edge (resp., ). Similarly, define the lines and for all . For and , only and are defined. We next describe the algorithm.

First, consider . Initially, let the simplified polygon be . For each reflex vertex on , where , consider the vertical slab defined by the two vertical lines through and . If there is no convex vertex of in this slab, then the edge must be an edge of any feasible solution. So, such an edge stays in . Otherwise, and intersect each other at some point outside and above or on . Then, we remove the chain of convex vertices between and and add the two edges and to ; hence, reducing the number of convex vertices of between and to one. Next, we consider and apply the same process to every two each vertex on , where .

It remains to show how to deal with the convex vertices that appear before the leftmost reflex vertex or after the rightmost reflex vertex on each chain. We show that these convex vertices can be reduced to at most two convex vertices, depending on the slopes of the edges incident to such *reflex* vertices. In the following, as the second part of the algorithm, we discuss the details for convex vertices that appear before the leftmost reflex vertices; the convex vertices on the other end of the polygon can be handled similarly.

Consider (i.e., the leftmost vertex of ) and let and denote the leftmost reflex vertices on and , respectively. Let be the chain on the boundary of that connects to in counter-clockwise order (i.e., it contains ). To reduce the number of convex vertices on , it is sufficient to check if and intersect at some point whose -coordinate is less than that of both and . For instance, if the slope of is positive and the slope of is negative, then and intersect at such point ; see Figure 6(a). In this case, we can replace with two edges and ; hence, reducing the number of convex vertices on to one. Therefore, we can simplify as follows: if and intersect at such point , then we replace with two edges and (hence, reducing the number of convex vertices on to one). Otherwise, if no such point exists (e.g., when the slope of is negative, but the slope of is positive), then both and must intersect the line passing through at least one of the edges incident to . See Figure 6(b-c). So, we can replace with three edges and reducing the convex vertices on to two. We perform a similar reduction on the path corresponding to the rightmost convex vertex of and its “closest” reflex vertices from each chain on the other end of . Let be the resulting simplified polygon.

To see the monotonicity of , we note that in each slab considered in the first part of the algorithm, at most two new edges are introduced that lie inside the slab. Therefore, the edges from different slabs are disjoint. Moreover, the edges introduced in the second part of the algorithm (i.e., when dealing with the leftmost and rightmost convex vertices and ) do not violate the monotonicity of .

For every two consecutive reflex vertices, has exactly one convex vertex (resp., has no convex vertex) between them if had at least one (resp., had none) between them. Since there must be at least one convex vertex between every two reflex vertices that had at least one convex vertex between them, any simplified polygon must have at least as many convex vertices as between every two consecutive reflex vertices. Moreover, one can easily verify that has the minimum number of convex vertices generated in the second part of the algorithm. Therefore, is optimal and we hence have the following result.

###### Theorem 3.1.

Given a monotone polygon with vertices, a subsuming polygon of with the minimum number of convex vertices can be computed in time.

## 4 Computing Subsuming Polygons

In this section, we show that for any simple polygon , a min-convex subsuming polygon can be computed in polynomial time under the restriction that the subsuming chains are of constant length and lie on . We first present definitions and preliminary results on outerstring graphs, which will be an important tool for computing subsuming polygons.

### Independent set in outerstring graphs.

A graph is a *string graph* if it is an intersection graph of a
set of simple curves in the plane, i.e., each vertex of is a mapped to a curve (string),
and two vertices are adjacent in if and only if the corresponding curves intersect.
is an *outerstring graph* if the underlying curves lie interior to a simple
cycle , where each curve intersects at one of its endpoints.
Figure 7(a) illustrates an outerstring graph and the corresponding
arrangement of curves. Later in our algorithm, the polygon will correspond to
the cycle of an outerstring graph, and some polygonal chains attached to the
boundary of the polygon will correspond to the strings of that outerstring graph.

A set of strings is called *independent* if no two strings in the set intersect,
the corresponding vertices in are called an independent set of vertices.
Let be a weighted outerstring graph with a set of weighted strings. A *maximum weight independent set* (resp., ) is a set of independent strings (resp., vertices) that maximizes the sum of the weights of the strings in . By we denote the weight of .

Let be the arrangement of curves that corresponds to ; e.g., see Figure 7(a). Let be a geometric representation of , where is represented as a simple polygon , and each curve is represented as a simple polygonal chain inside such that one of its endpoints coincides with a distinct vertex of . Keil et al. [8] showed that given a geometric representation of , one can compute a maximum weight independent set of in time, where is the number of line segments in .

###### Theorem 4.1 (Keil et al. [8]).

Let be a weighted outerstring graph. Given a geometric representation of , there exists a dynamic programming algorithm that computes a maximum weight independent set of in time, where is the number of straight line segments in .

Figure 7(b) illustrates a geometric representation of some , where each string is represented with at most 4 segments. Keil et al. [8] observed that any maximum weight independent set of strings can be triangulated to create a triangulation of , as shown in Figure 7(c). They used this idea to design a dynamic programming algorithm, as follows. Let be the strings in . Then the problem of finding can be solved by dividing the problem into subproblems, each described using only two points of . We illustrate how the subproblems are computed very briefly using Figure 7(d). Let be the problem of finding , where consists of the strings that lie to the left of . Let be a triangle in , where is a point on some string inside ; see Figure 7(d). Since is a triangulation of the maximum weight string set, must be a string in the optimal solution. Hence can be computed from the solution to the subproblems and , as shown in Figure 7(e). Keil et al. [8] showed that there are only a few different cases depending on whether the points describing the subproblems belong to the polygon or the strings. We will use this idea of computing to compute subsuming polygons.

### Subsuming polygons via outerstring graphs.

Let be a simple polygon with vertices, of which are reflex vertices. A *convex chain* of is a path of strictly convex vertices, where the indices are considered modulo .

Let be a subsuming polygon of , where
, and the subsuming chains are of length at most . Here, by “length”, we mean the number of edges (not the Euclidean length).
Let be a subsuming chain of .
Then by definition, there is a corresponding convex chain in
such that the edges and coincide with
the edges and .
We call the vertex the *left support* of . Since , the chain must lie on .
Moreover, since is a
min-convex subsuming polygon, the number of vertices in
would be at most the number of vertices in .

We claim that the number of paths in from to is at most , where is an upper bound on the length of the subsuming chains. Thus any subsuming chain can have at most line segments. Since there are only straight lines in the arrangement , there can be at most paths of edges, where . Consequently, the number of candidate chains that can subsume is .

###### Lemma 4.1.

Given a simple polygon with vertices, every convex chain of has at most candidate subsuming chains in , each of length at most .

In the following, we construct an outerstring graph using these candidate subsuming chains. We first compute a simple polygon interior to such that for each edge in , there exists a corresponding edge in which is parallel to and the perpendicular distance between and is , as shown in dashed line in Figure 8(a). We choose sufficiently small^{2}^{2}2Choose , where is the distance between the closest visible pair of boundary points. such that for each component of , contains exactly one component inside . We now construct the strings. Let be a convex corner of . Let be the set of candidate subsuming chains such that for each chain in , the left support of the chain appears before while traversing the unbounded face of in clockwise order. For example, the subsuming chains that correspond to are ,
,
,
,
,
,
,
as shown in Figure 8(b). For each of these chains, we
create a unique endpoint on the edge of , where corresponds to the edge in ,
as shown in Figure 8(c). We then attach these chains to by adding a segment from
to its unique endpoint on .

We attach the chains for all the convex vertices of to . Later we will use these chains as the strings of an outerstring graph. We then assign each chain a weight, which is the number of convex vertices of it can reduce. For example in Figure 8(b), the weight of the chain is one.

Although the strings are outside of the simple cycle, it is straightforward to construct a representation with all the strings inside a simple cycle : Consider placing a dummy vertex at the intersection points of the arrangement, and then find a straight-line embedding of the resulting planar graph such that the boundary of corresponds to the outer face of the embedding. Consequently, and its associated strings correspond to an outerstring graph representation . Let be the underlying outerstring graph. We now claim that any corresponds to a min-convex subsuming polygon of .

###### Lemma 4.2.

Let be a simple polygon, where there exists a min-convex subsuming polygon that lies on , and let be the corresponding outerstring graph. Any maximum weight independent set of yields a min-convex subsuming polygon of .

###### Proof.

Let be a set of strings that correspond to a maximum weight independent set of . Since is an independent set, the corresponding subsuming chains do not create edge crossings. Moreover, since each subsuming chain is weighted by the number of convex corners it can remove, the subsuming chains corresponding to can remove convex corners in total.

Assume now that there exists a min-convex subsuming polygon that can remove at least convex corners. The corresponding subsuming chains would correspond to an independent set of strings in . Since each string is weighted by the number of convex corners the corresponding subsuming chain can remove, the weight of would be at least . ∎

### Time complexity.

To construct , we first placed a dummy vertex at the intersection points of the chains, and then computed a straight-line embedding of the resulting planar graph such that all the vertices of are on the outerface. Therefore, the geometric representation used at most edges to represent each string. Since each convex vertex of is associated with at most strings, there are at most strings in . Consequently, the total number of segments used in the geometric representation is . A subtle point here is that the strings in our representation may partially overlap, and more than three strings may intersect at one point. Removing such degeneracy does not increase the asymptotic size of the representation. Finally, by Theorem 4.1, one can compute the optimal subsuming polygon in time.

The complexity can be improved further as follows. Let be a rectangle that contains all the intersection points of . Then, every optimal solution can be extended to a triangulation of the closed region between and . Figure 8(d) illustrates this region in gray. We can now apply dynamic programming similar to the one described above to compute the maximum weight independent string set, where each subproblem finds a maximum weight set inside some subpolygon. Each such subpolygon can be described using two points , each lying either on or on some string, and a subset of that helps enclosing the subpolygon.

Since there are strings, each containing at most points,
the number of vertices that correspond to the strings is . We will refer these as the *string vertices*. Note that the number of total vertices in the geometric representation is also . If the subproblem is bounded by two string vertices, or one string vertex and one polygon vertex, then similar to Keil et al. [8], we can use a pair of vertices to describe a subproblem. However, sometimes we need more information to describe a subproblem, e.g., assume that the subproblem is bounded from one side by the point and some vertex (corresponding to a string), and from the other side by the point and some vertex (corresponding to a string). For these problems, we need a subset of to describe the problem boundary. Therefore, we
define our dynamic programing table to be , where and corresponds to the string or polygon vertices, and corresponds to the constant size additional description of the boundary (whenever needed). Thus the size of the dynamic programming table is . Since there are at most string vertices, there can be at most candidate triangles (e.g., Figure 7 (e)). Consequently, we can fill an entry of the table in time. Hence the dynamic program takes at most time in total.

###### Theorem 4.2.

Given a simple polygon with vertices, one can compute in polynomial time, a min-convex subsuming polygon under the restriction that the subsuming chains must be of constant length and lie on .

### Generalizations.

We can further generalize the results for any given line arrangements. However, such a generalization may increase the time complexity. For example, consider the case when the given line arrangement is , which is determined by the pairs of vertices of . Since we now have lines in the arrangement , the time complexity increases to , i.e., .

## 5 Conclusion

In this paper, we developed a polynomial-time algorithm that can compute optimal subsuming polygons for a given simple polygon in restricted settings. On the other hand, if the polygon contains holes, then we showed that the problem of computing an optimal subsuming polygon is NP-hard. Therefore, the question of whether the problem is polynomial-time solvable for simple polygons [1], remains open. Note that islands are crucial in our hardness proof. The complexity of the problem for polygons with holes (but without any island) is also open. Since the optimization in one hole is independent of the optimization in the other holes of the polygon, resolving the complexity for polygon with holes would readily give important insight about the complexity for simple polygon.

Our algorithm can find an optimal solution if the optimal subsuming polygon lies on some prescribed arrangement of lines, e.g., or . The running time of our algorithm depends on the length of the subsuming chains, i.e., the running time is polynomial if the subsuming chains are of constant length. However, there exist polygons whose optimal subsuming polygons contain subsuming chains of length . Figure 9 illustrates such an example optimal solution that is lying on . An interesting research direction would be to examine whether there exists a good approximation algorithm for the general problem.

Recently, Lubiw et al. [9] showed that the problem of drawing a graph inside a polygonal region is hard for the existential theory of the reals. The subsuming polygon problem can also be viewed as a constrained graph drawing problem whereas the subsuming chains are modeled by edges that need to be drawn outside the polygon, possibly with bends. The goal is to find a crossing-free drawing of these edges that minimizes the total number of bends. It would be interesting to examine whether the problem is -hard in such a graph drawing model.

## References

- [1] O. Aichholzer, T. Hackl, M. Korman, A. Pilz, and B. Vogtenhuber. Geodesic-preserving polygon simplification. International Journal of Computational Geometry & Applications, 24(4):307–324, 2014.
- [2] L. Arge, L. Deleuran, T. Mølhave, M. Revsbæk, and J. Truelsen. Simplifying massive contour maps. In Proc. ESA, volume 7501 of LNCS, pages 96–107. Springer, 2012.
- [3] Y. Bahoo, S. Durocher, J. M. Keil, S. Mehrabi, S. Mehrpour, and D. Mondal. Polygon simplification by minimizing convex corners. In Thang N. Dinh and My T. Thai, editors, Proceedings of the 22nd International Conference on Computing and Combinatorics (COCOON), volume 9797 of LNCS, pages 547–559. Springer, 2016.
- [4] A. Darmann, J. Döcker, and B. Dorn. On planar variants of the monotone satisfiability problem with bounded variable appearances, 2016. https://arxiv.org/abs/1604.05588.
- [5] M. de Berg and A. Khosravi. Optimal binary space partitions for segments in the plane. International Journal of Computational Geometry & Applications, 22(3):187–206, 2012.
- [6] D. H. Douglas and T. K. Peucker. Algorithm for the reduction of the number of points required to represent a line or its caricature. The Canadian Cartographer, 10(2):112–122, 1973.
- [7] L. J. Guibas, J. Hershberger, J. S. B. Mitchell, and J. Snoeyink. Approximating polygons and subdivisions with minimum link paths. International Journal of Computational Geometry & Applications, 3(4):383–415, 1993.
- [8] J. Mark Keil, Joseph S. B. Mitchell, Dinabandhu Pradhan, and Martin Vatshelle. An algorithm for the maximum weight independent set problem on outerstring graphs. Computational Geometry, 60:19–25, 2017.
- [9] A. Lubiw, T. Miltzow, and D. Mondal. The complexity of drawing a graph in a polygonal region. CoRR, abs/1802.06699, 2018.
- [10] W. A. Mackaness, A. Ruas, and L. Tiina Sarjakoski. Generalisation of Geographic Information: Cartographic Modelling and Applications. Elsevier, 2011.
- [11] H. Ratschek and J. Rokne. Geometric Computations with Interval and New Robust Methods: Applications in Computer Graphics, GIS and Computational Geometry. Horwood Publishing, 2003.