A Constant-Factor Approximation Algorithm for Point Guarding an Art Gallery

by   Arash Vaezi, et al.
Sharif Accelerator

Given a simple polygon P, in the Art Gallery problem the goal is to find the minimum number of guards needed to cover the entire P, where a guard is a point and can see another point q when pq does not cross the edges of P. This paper studies a variant of the Art Gallery problem in which guards are restricted to lie on a dense grid inside P. In the general problem, guards can be anywhere inside or on the boundary of P. The general problem is called the point guarding problem. It was proved that the point guarding problem is APX-complete, meaning that we cannot do better than a constant-factor approximation algorithm unless P = NP. A huge amount of research is committed to the studies of combinatorial and algorithmic aspects of this problem, and as of this time, we could not find a constant factor approximation for simple polygons. The last best-known approximation factor for point guarding a simple polygon was 𝒪(log (|OPT|)) introduced by E. Bonnet and T. Miltzow in 2020, where |OPT| is the size of the optimal solution. Here, we propose an algorithm with a constant approximation factor for the point guarding problem where the location of guards is restricted to a grid. The running time of the proposed algorithm depends on the number of cells of the grid. The approximation factor is constant regardless of the grid we use, the running time could be super-polynomial if the grid size becomes exponential.



There are no comments yet.


page 1

page 2

page 3

page 4


Art Gallery Plus Single Specular-reflection

Given a simple polygon P, in the Art Gallery problem, the goal is to fin...

A PTAS for ℓ_p-Low Rank Approximation

A number of recent works have studied algorithms for entrywise ℓ_p-low r...

Directed Girth

It is known that a better than 2-approximation algorithm for the girth i...

On the Approximability of the Traveling Salesman Problem with Line Neighborhoods

We study the variant of the Euclidean Traveling Salesman problem where i...

Deterministic, Near-Linear ε-Approximation Algorithm for Geometric Bipartite Matching

Given point sets A and B in ℝ^d where A and B have equal size n for some...

Inaccessibility-Inside Theorem for Point in Polygon

The manuscript presents a theoretical proof in conglomeration with new d...

How Packed Is It, Really?

The congestion of a curve is a measure of how much it zigzags around loc...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction and Related Works

Consider a simple polygon with vertices. The maximal sub-polygon of visible to a point in is called the visibility polygon of , which is denoted by . There are linear-time algorithms to compute when the viewer is a point [34]. For the segment inside , the weak visibility polygon of , denoted as , is the maximal sub-polygon of visible to at least one point (not the endpoints) of . A polygon inside is said to be completely visible from if for every point and for any point , and are visible (denoted as short from completely visible polygon). Also, is said to be strongly visible from if there exists a point such that for every point , and are visible (). These different visibility types can be computed in linear time ([31, 36]).

In computational geometry, Art Gallery problems are motivated by the question, “How many security cameras are required to guard an art gallery?” The art gallery is modeled as a connected polygon . A camera, which we will henceforth call a guard, is modeled as a point in the polygon. The Art Gallery problem is to determine the minimum number of guards that are sufficient to see every point in the interior of an Art Gallery room. The Art Gallery can be viewed as a polygon of vertices, and the guards are stationary points in . Steve Fisk [38] proved that guards are always sufficient and sometimes necessary. Five years earlier, Victor Klee [30] has posed this question to Václav Chvátal, who soon gave a more complicated solution.

If guards are placed at vertices of , they are called vertex guards [16]. If guards are placed at any point of , they are called point guards. If guards are allowed to be placed along the boundary of , they are called boundary-guards (on the perimeter). Since guards placed at points or vertices are stationary, they are referred to as stationary guards. If guards are mobile along a segment inside , they are referred to as mobile guards. If mobile guards move along edges of , they are referred to as edge guards.

The Art Gallery problem was proved to be NP-hard first for polygons with holes by [35]. For guarding simple polygons, it was proved to be NP-complete for vertex guards by [32]. This proof was generalized to work for point guards by [33]. For guarding simple polygons, the article [24] proved that the problem is APX-complete, meaning that we cannot do better than a constant-factor approximation algorithm unless . For guarding polygons with holes, [22] proved that if there is no restriction on the number of holes, the minimization problem is as hard to approximate as Set Cover in general. It, therefore, follows from results about the inapproximability of Set Cover by [23, 25] that, for polygons with holes, it is NP-hard to find a -approximation. These hardness results hold whether we are dealing with vertex guards, perimeter guards, or point guards.

Denote an optimal set of guards by OPT. In 2006 Efrat and Har-Peled proposed an exact algorithm for the point guarding problem with running time at most , where is the size of the optimal solution [20]. Ghosh [29] provided an -approximation algorithm for guarding polygons with or without holes with vertex guards. His algorithm decomposes the input polygon into a polynomial number of cells such that each point in a given cell is seen by the same set of vertices. So, each vertex corresponds to a subset of the cells. The minimum number of vertices (subsets) that cover all of the cells cover . King and Krikpatrick obtained an approximation factor of for vertex guarding simple polygons and for vertex guarding a polygon with holes. They presented an -approximation algorithm for guarding simple polygons, using either vertex guards or perimeter guards, and the running time is polynomial in and the number of potential guard locations [10]. In 2007 article [19] proposed a pseudopolynomial time -approximation algorithm. Later, in 2011 the article [8] settles the conjecture for the polygons that are weakly visible from an edge and contain no holes by presenting a -approximation algorithm for finding the minimum number of vertex guards. However, a counterexample for this result was presented later in 2019 by [4]. Ashur, Filtzer, and Katz [4] confirmed the conjecture for the important case of weakly visible polygons, by presenting a -approximation algorithm for guarding such a polygon using vertex guards.

For the vertex guard and the point guard variants of the Art Gallery problem, [1] ruled out any algorithm, where is the number of guards, for any computable function , unless the exponential time hypothesis fails. These lower bounds almost match the algorithms that exist for both versions of the problem.

An interesting result about the Art Gallery problem [6]: The complexity status of this problem had not been resolved for many years. It has long been known that the problem is NP-hard, but no one has been able to show that it lies in NP. Recently, the computational geometry community became more aware of the complexity class , which has been studied earlier by other communities. The class consists of problems that can be reduced in polynomial time to the problem of deciding whether a system of polynomial equations with integer coefficients and any number of real variables has a solution. It can be easily seen that . The article [6] proved that the Art Gallery problem is -complete, implying that (1) any system of polynomial equations over the real numbers can be encoded as an instance of the Art Gallery problem, and (2) the Art Gallery problem is not in the complexity class NP unless .

2 Problem Definition and Our Result

The point guarding problem where guards are restrict defines as the following.

Problem 1 (The Restricted Point Guarding problem).

Given a simple polygon , the goal is to find the smallest set of points of so that each point of is seen by at least one point of , and the points of are constrained to be belong to the set of vertices of an arbitrarily dense grid.

We are going to convert the point guarding problem into a discretized version. There is a constant factor lost from the discretization to the actual point guarding problem. The discretized version itself is an instance of a particular geometric set cover problem, where we will solve it with a constant-approximation factor. Denote a decomposition of into a set of convex components by , and denote the numbers of cells of by which indicates the complexity of . Given a decomposition , the algorithm’s running time proposed here is polynomial in . Considering a very dense grid (a given decomposition) with superpolynomial complexity, we can solve the general point guarding problem with a constant approximation factor. Otherwise, the proposed algorithm works for the restricted point guarding problem where the location of the guards is restricted to lie on a pre-determined grid.

Efrat and Har-Peled [20] had also dealt with restricted point guarding problem. Bonnet and Miltzow improved their result. Assuming integer coordinates and a specific general position on the vertices of , Bonnet and Miltzow [7] presented an -approximation algorithm for the point guarding problem. Their result is one of the most recent works on the point guarding problem in 2020 [1]. They use two assumptions:

Assumption 1 (Integer Vertex Representation); vertices are given by integers, represented in binary.

Assumption 2 (General Position Assumption); no three extensions meet in a point of which is not a vertex and no three vertices are collinear.

Bonnet and Miltzow combined a randomized pseudo-polynomial time algorithm proposed by Deshpande et al. in 2007 [21] with another approach presented by Efrat and Har-Peled in 2006 [20]. The algorithm presented by Deshpande et al. is flawed and retracted by Bonnet and Miltzow. Efrat and Har-Peledattain presented a randomized polynomial-time algorithms restricting guards to a very fine grid [20], where denotes an optimal set of guards that is restricted to some grid. Efrat and Har-Peled could not prove that their grid solution approximates an optimal guard placement. By developing the ideas of Deshpande et al. in combination with the algorithm of Efrat and Har-Peled, Edouard Bonnet and Tillmann Miltzow proposed the first randomized polynomial-time approximation algorithm for simple polygons [7]. The running time of the algorithm used by Efrat and Har-Peled is polynomial in the complexity of , and the spread of the vertices of the gallery, which can be at most exponential in the input size. The spread of the vertices of the gallery defines like this: where is the longest and is the shortest pairwise distances among the vertices of the polygon. Edouard Bonnet and Tillmann Miltzow used and modified the same grid; we know that the size of that grid could be superpolynomial. The grid width is polynomial in the inverse of the diameter of the polygon, which can be exponential in the description of the polygon. Considering the same assumptions, one can use the same grid in the first decomposition step of the algorithm proposed in this article and yield a constant factor for the point guarding problem. However, the running time of this approach would be polynomial in the size of the grid.

As mentioned above after the discretization process, we have an instance of the geometric set cover problem.

The set cover problem has a privileged place in computer science. In this problem, we are given a ground set together with a family = where each is a subset of . The family covers ; that is, is contained in the union of the elements of . The goal is to find a subfamily with the minimum number of elements that also covers . The geometric set cover problem is the special case of the set cover problem in geometric settings, where is a (usually finite) subset of some fixed dimensional Euclidean space such as the two-dimensional plane; in this paper, we will assume this to be the given simple polygon . The family of subsets of is induced by some family of objects, for example, disks, triangles, or visibility polygons. For instance, in the set cover problem with disks, we are given a set of disks, and we wish to find the minimum subset of disks that cover (whose union contains) .

This NP-hard problem admits several different polynomial-time algorithms that guarantee an approximation factor of . Given the constraints imposed by geometry, it is reasonable to expect that we can obtain approximation factors better than . We intend to apply an efficient approximation algorithm proposed by Kasturi Varadarajan in 2010 [12]. Kasturi used a randomized technique called Quasi-Uniform sampling. He managed to propose a sub-logarithmic approximation factor for fairly geometric objects. The approximation factor obtained by Kasturi in [12] is related to the well-known combinatorial problem of bounding the size of an -net. Suppose that we have a collection of fairly general geometric objects (those of constant description complexity) such as disks and an integer . A -net is a subset of the objects that covers all points in the plane that are -deep, that is contained within at least of the objects. Nets of size better than are known to exist when the combinatorial complexity of the boundary of the union of the objects is near-linear [18, 14, 13]. Kasturi [12] proposed a randomized algorithm and used samples of nets for a strategy called Quasi-Uniform sampling. He used the Quasi-Uniform sampling approach to obtain an approximation factor of for objects with union complexity , where is the number of objects. The approach was modified and improved by Timothy M. Chan et al. in 2011 [9]. The improved result presented an -approximation factor for the geometric set cover problem considering the assumption that the union complexity of the geometric objects should be near-linear in the number of the objects.

Here, we have a simple polygon as the ground set, and we obtain a set of geometric objects whose union complexity is linear. The minimum number of these objects corresponds to a solution for the point guarding problem. Regardless of the structure and the complexity of initial decomposition (), we proposed an approach that provides a constant factor approximation for the point guarding problem. To solve the instance of the geometric set cover problem, we use the Quasi-Uniform sampling approach presented by Kasturi Varadarajan [12], and its modification that was improved by Timothy M. Chan et al. [9]. This leads to a constant factor approximation for the point guarding problem.

To discretize the point guarding problem into an instance of the geometric set cover problem, besides a given grid, we can use a decomposition approach proposed here. No matter how we decompose , each convex region obtained from the initial decomposition () is called a spanning convex region, and the set of the spanning convex regions is denoted by SCR

. We subdivide every spanning convex region such that every region after this subdivision estimates a place for a guard. Every such region is called a

guarding-region. Every guarding-region carries a list of completely visible spanning convex regions. In fact, the characteristic of every guarding-region is that any spanning convex region that is completely visible to a point in a guarding-region is also completely visible to every point of . The family of the visible lists of the guarding-regions is the family set of the geometric objects chosen for the set cover instance.

Therefore, our overall approach can be summarized in the following steps:

-Step 1: Choose a decomposition that decomposes into a set of spanning convex regions.

-Step 2: Compute approximate guard places inside the spanning convex regions (the guarding-regions), and obtain their corresponding visible lists.

-Step 3: Formulate the geometric set cover problem and solve the discretized version with the approximation approach presented in [9].

As mentioned previously, we can choose any approach to decompose into spanning convex regions, but the number of spanning convex regions determines the algorithm’s running time. Regardless of the chosen strategy to compute spanning convex regions, we can compute the corresponding guarding-regions, and the approximation factor remains constant. Choosing a more dense grid that is fine enough for our goals leads to a more precise solution. In Section 3, we define the precise terminologies, and we will see how to compute guarding-regions. The suggested approach uses pure computational geometric techniques. Section 4 introduces a decomposing approach to compute spanning convex regions that takes time to subdivide into a list of spanning convex regions, where is a given positive integer. Even for a tiny amount of , the final grid is remarkably dense, and as gets larger, the final grid gets exponentially denser. Section 5 illustrates an analysis for Algorithm 1, and finally Section 6 covers conclusion remarks.

3 The Discretization Technique

Consider a sub-region of . A guard may situate in either of the following positions: 1- The guard does not see any point of . 2- The guard can see partially. 3- The guard covers entirely. In the first and second situations, the proposed algorithm considers as invisible for . That is, for to be counted as area-visible to , all of its points must be visible to . A sub-region is area-visible to another sub-region or segment denoted as the , if all points of are visible to the .

Area-Visibility: A region is called area-visible to a source (a point, a segment, or a region), if all the points of are visible to all the points of the .

SC-Regions: Each minimal region formed from a decomposition of the given polygon into a set of convex components is called a sc-region, short form a spanning convex region. The set containing all of the spanning convex regions is denoted by SCR. Figure 1 (a) illustrates an example of decomposing into sc-regions. As mentioned before, will be decomposed into other smaller special sub-regions called “guarding-regions”. If we put two guards in different arbitarary positions inside a guarding-region, the same sub-set of sc-regions is area-visible to both points. In order to compute guarding-regions we decompose every sc-region into guarding-regions. For a more precise definition for guarding-regions see the following definition. guarding-regions: Consider a simple polygon , decompose into sc-regions. Given a query point in , a subset of sc-regions are area-visible to . Call this subset as the visible list of and denote this list by VL. A guarding-region is a convex polygon that the list of area-visible sc-regions to every point is the same. We will estimate the visibility polygon of a guard in any arbitrary position inside a guarding-region by the visible list of that guarding-region. Denote the cardinality of a visible-list corresponding to a guarding-region by . Based on this definition, for a more straightforward presentation, we may refer to guarding-region’s visibility list instead of a guard visibility polygon.

In order to compute guarding-regions inside a sc-region, in the initial step we need to count on the area-visibility of each sc-region individually. A sub-region inside each sc-region that sees another sc-region completely is called a temporary sub-region, for short, we call each of them a temp-sub-region. See the following definition. Temp-sub-region: Given two sc-region and (), suppose there is a sub-region inside denoted by that is area-visible to , we call this sub-region a temp-sub-region. These temp-sub-regions will be computed by checking the edges of each sc-region individually. Each temp-sub-region eventually will be used to divide sc-regions into guarding-regions. Then, we sweep on each sc-region and decompose it to guarding-regions by the help of temp-sub-regions. For the presentation to be simpler we define a visible list for each temp-sub-region too. Consider a temp-sub-region inside the sc-region that is area-visible to (), the visible list of contains and .

3.1 Approximation Algorithm

Here we present an algorithm that computes the set of all the guarding-regions, this set is denoted by . Algorithm 1 illustrates the pseudo-code of the approach. In Step 1, we decompose into sc-regions, which indicates the number of all the sc-regions (Recall that no matter how we compute sc-regions, we can compute the corresponding list of guarding-regions). Step 2 contains three for loops that corresponding to each sc-region, we check their edges one by one to find temp-sub-regions. Suppose has edges. Note that any guard inside may see other sc-regions ( ) only through ’s edges. Step 2 uses a procedure called Findtsr to compute temp-sub-regions correspond to every edge of a given sc-region.

Step 3 receives all temp-sub-regions inside a given sc-region and decomposes them into guarding-regions. This step also uses a procedure called . This procedure receives a sc-region as a parameter. Then, by sweeping on that sc-region splits it into guarding-regions. The given sc-region denoted by will be decomposed into a set of guarding-regions called . The set is the final set that contains all the guarding-regions, and let denote the cardinality of . The algorithm computes every and adds it to (). By the end of Algorithm 1 contains all guarding-regions, and their visible-lists. In fact, contains pairs () of all the guarding-regions and their corresponding visible lists. A minimum subset of guarding-regions whose visible-list cover all the sc-regions solves the problem. In Step 4, by converting the problem to the geometric set cover problem we mange to solve the problem with a constant factor. There is an algorithm with -approximation factor for the Point Guarding problem and with -approximation factor with polynomial running time for the restricted Point Guarding problem (problem 1) if the size of the restricted grid is polynomial in the complexity of the given gallery (). Subsection LABEL:sec:approximation-analysis deals with the approximation analysis of the algorithm.

1:procedure Point Guarding()
2:     define = Add an element to a set/list.
3:     define = The temp-sub-region in the sc-region where is area-visible to .
4:     define //* = comment //* Step 1
5:     Decomposing into sc-regions and put them in SCR. //* Step 2
6:     for  i= 1 ; ; i++  do //* i selects a sc-region
7:         for  k=1 ; ; k++  do //* pick the edge of
8:              for  j=1 ; ; j++  do //* find every corresponding to every inside
9:                   = Findtsr(,) //* is the th edge of
10:                  if do
11:                                               //* Step 3 //*Extracting guarding-regions from temp-sub-regions in each :
12:     for  i= 1 ; ; i++ do
13:         Decompose()
14:          (the result regions, corresponding visible-lists).
15:         for  each  in  do
16:               ;               //* Step 4
17:     Formulate the set cover problem and solve it approximately.
Algorithm 1 Main Procedure
Figure 1: Figure (a) illustrates a given polygon that is decomposed into a set of sc-regions. Figure (b) shows a specific sc-region called source. Consider one edge of this sc-region denoted by , and a target sc-region denoted by . Figure (c) illustrates , , and more clearly. Figure (d) illustrates a temp-sub-region inside that every point of this temp-sub-region sees all the points of .

3.1.1 Procedure Findtsr(a segment, a sc-region)

Consider a given segment as a viewer, we intend to find out if can see a given spanning convex region called completely. Suppose that is a given edge of a spanning convex region called .

We compute the complete-visibility-polygon of () and check if the target fits inside that. If the answer is yes, then we found a target that is area-visible to . We use the endpoints of to find a temp-sub-region that can make the target area-visible. If so, we add it to the output set of the Findtsr procedure. While we check the complete-visible-polygon of , consider the rays coming out of the endpoints of that touch the boundary of the target. These rays must release from and reach the target. The opposite direction from the target to makes two half-lines that intersect on its endpoints.

We extend these half-lines backward inside the source. The intersection between these two half-lines and the boundary creates a temp-sub-region . By using binary search on the boundary of (which is a convex hull), we can compute this intersection in time, where denotes the complexity of the source. Now we know that is area-visible to .

For a specific edge , to compute a temp-sub-region ; It takes time to compute its complete-visibility-polygon, and it takes to compute the boundary of . Thus, it takes time for each run of the procedure. Later we will see that the complexity if a spanning convex region is polynomial in terms of , so the Find procedure takes time.

To compute all temp-sub-regions inside the source, we need to count on all the edges of the source. Note that there might only one point or an interval on that sc-region is area-visible to that.

3.1.2 Procedure Decompose(spanning convex region)

This procedure intends to decompose a given spanning convex region () into guarding-regions. According to Algorithm 1

when we reach this procedure, every spanning convex region is divided into some temp-sub-regions that probably share common areas. Line 12 counts every spanning convex region, and line 13 calls the

procedure to obtain guarding-regions inside a given spanning convex region. The procedure computes the guarding-regions inside from the temp-sub-regions (see Figure 4).

Figure 2: Three sc-regions are considered in this figure. The one that is illustrated and denoted by , and two others, let call them and . Figure illustrates a temp-sub-region () in blue. Any guard inside can make area-visible. Figure illustrates , is area-visible to . Finally, figure  illustrates the decomposition of into four guarding-regions. See figure , is illustrated in orange and makes only area-visible. Any guard inside can make and area-visible but not .

A temp-sub-region is obtained from the area between two half-lines (backward rays). We aim to decompose every sc-regions using their intersection with the area between these half-lines. Denote the number of temp-sub-regions inside , including , by , which indicates the complexity of . For each temp-sub-region in , except for itself, denote a starting half-line by , and an ending half-line by . So, inside a temp-sub-region is between two half-lines and . We are going to sweep on , regardless of the direction we move on, for a simpler presentation, we refer to these half-lines and . From the previous steps of Algorithm 1, for every two starting and ending half-lines it is already specified what sc-regions () are visible to the points between any two half-lines and .

A sc-region can be decomposed into guarding-regions in , where denotes the complexity of a sc-region.


To decompose , we use a sweep-line denoted by . We start sweeping parallel to an edge of . Various events may appear, checks every possibility and chooses its next action in each step. Appendix subsection A deals with the decomposition procedure. As the complexity of a sc-region is the sweeping approach may needs time. ∎

4 Computing Spanning Convex Regions

In this section we propose a strategy to obtain spanning convex regions to be used in the initial step of Algorithm 1. As mentioned before, we can use other decomposition strategies like the grid proposed by Bonnet and Miltzo [7]. However, if we choose that grid in addition to the grid points, we need to include the reflex vertices111A reflex vertex is a vertex that the angle between the two edges of incident on that vertex inside is greater than . and intersections of extending lines (the extension of of two vertices is the line that contains those vertices). Otherwise, we run into an issue illustrated in Figure 1 of  [7]. Here, we do not give details of that decomposition. Instead, we refer interested readers to [7] for further details.

First consider the following approach to decompose into a set of spanning convex regions denoted by SCR. Every iteration of the decomposition approach subdivides into a set of cells. The final set of cells determines the set of spanning convex regions.

Decomposition Approach #1

  1. Ignore the edges of . Connect every vertex of , and obtain every unique line passing from the vertices. Compute all the intersections of these the lines.

  2. Run this step times: Connect all the intersection points and compute the lines crossing them. Compute the criss-cross of all the new lines with the previous lines.

  3. Trace and compute the intersection of this network with .

Consider a guard in OPT. A reflex vertex may block the visibility of not to see a part of . Consider a situation where a blocking reflex vertex rf causes to see a sc-region partially. The rest of must be covered by some other guards in OPT. Without loss of generality, suppose that there is a visible area of that is independently covered by . Denote the whole visible part of that is visible to by . If a decomposition approach can split so that every visible part of each guard in the optimal solution suits sc-regions, then the solution of the restricted point guarding equals the solution of the general point guarding. This is because, in such a situation, every sc-region becomes completely visible by at least one guard in the optimal solution. Recall that Algorithm 1 counts on the complete visibility of the sc-regions to construct visible lists of the guarding-regions.

Consider one cell after step of the decomposition approach #1. For two guards in the optimal solution and , consider the visible parts and . Suppose and share an area in . The common area lies between two lines passing through and , where and are two blocking reflex vertices. After steps, if we divide so that the area gets covered by exclusive sc-regions, then the decomposition approach works for the general point guarding problem. Otherwise, we have to restrict guards to lie on the vertices of the grid constructed by the decomposition process.

Consider the unique line passing through , for a guard in OPT and a blocking reflex vertex rf. This line determines three sets of cells in each step of a decomposition approach: The set of cells that are completely visible to , the set of cells that are partially visible to , and the set of cells that are completely invisible to . As the polygon is a simple polygon, if a cell is partially visible or if it is invisible, it cannot become visible from elsewhere by the same guard. For , either a completely visible or a completely invisible cell in each step is called a Marked Cell by .

Consider step , we know that every cell is a convex hull. In the decomposition approach #1, when we connect the intersection points to each other to obtain new lines for the subdivision operation in the step, we indeed connect the diagonals of every cell. So, every cell in the step gets at least divided to the sub-cells obtaining from the connection of its vertices (the diagonals). Except for a triangle, by connecting the diagonals of a convex hull, there will be at least one point in the middle of the convex hull that holds some sub-cells around itself. Denote such a middle point by . Consider the unique line passing through that makes partially visible, and suppose that is not completely visible by any other guard in OPT. This line can only passes either through one side of or it can pass through . No matter how this line may be situated, there is at least one sub-cell inside that after the subdivision process of the step becomes a marked cell for . So, for each partially visible cell in the step we know that after the subdivision step at least one sub-cell becomes marked for every guard in OPT. So the area of partially visible cells gets smaller by each iteration. A simple analysis reveals that using a binary search after at most steps, the subdivided cells gets close enough to the shared area between the visible parts of the guards. Thus, if we set the decomposition approach works in the case of general point guarding problem.

However, if in the step, a cell is a triangle. Then, we have to split so that there exists a middle point inside . This point can make the decomposition process split an unmarked into a set of sub-cells so that at least one sub-cell becomes a marked cell for each guard in OPT after the step. The decomposition approach #2 presented in the following modifies the first decomposition approach to split the triangles correctly.

Decomposition Approach #2 (The main approach)

-order-Convex-Regions: Each minimal region formed in the step of the subsequent approach is called an -order-convex-region. Consider a small given constant denoted by that .

  1. Ignore the edges of . Consider every unique line passing from connecting every vertex of , and compute all the intersections of all the lines crossing each other. The set of cells obtained form this subdivision demonstrates the zero-order-convex-regions.

  2. In the step , run the following splitting process times. For each -order-convex-region, draw all the unique lines crossing the specified segments designated in the below:

    1. Connect every two intersection points to each other.

    2. If the -order-convex-region is a triangle connect the middle point of every edge to the third vertex of the triangle.

  3. Compute all the intersections of the above-mentioned lines.

  4. Now trace and compute the intersection of the boundary of and the above-mentioned lines.

The -order-convex-regions constructed from the above-mentioned approach specify the set of the spanning convex regions (see Figure 3 (a) and (b)).

Figure 3: Three steps of decomposition process.

Running Time Analysis of the Decomposition Approach:

A simple analysis reveals that given a constant , the Decomposition Approach works in polynomial time.

Without lost of generality we compute the complexity of Decomposition Approach #1. We know that the complexity of the running time of Decomposition Approach #2 is the same.

We know that lines can have at most intersections. The polygon has vertices. So, we have lines, and intersection-points. We connect these intersection-points to each other iteratively. For we have cells. So the running time of the Decomposition Approach is .

5 Analysis of Algorithm 1

This section covers analysis for Algorithm 1. First, note that due to line of the algorithm, we know that the guards chosen by the algorithm surely cover , so the algorithm provides a feasible solution. That is because when , every spanning convex region will be added to get covered in the final solution. Although each spanning convex region is decomposed into many temp-sub-regions, each of the result temp-sub-regions has in its visible-list. So, all the spanning convex regions and consequently will be covered.

Algorithm 1 takes polynomial time in the complexity of the grid size ().


A simple analysis reveals that the algorithm works in polynomial time if the number of the spanning convex regions, denoted by , be polynomial in complexity of the polygon. Every run of the Findtsr procedure takes time, and every run of the Decompose procure takes time complexity.

The Findtsr procedure will be invoked times, and the Decomposition procedure will be invoked times. So, the time complexity of the three first steps is . Step of the algorithm uses the previous polynomial time algorithms proposed by Kasturi Varadarajan [12, 13] and Timothy M. Chan et al. [9].

Suppose we are given a set of points in , and a set of visible-lists of guarding regions—the union of the visible-lists covers and consequently . We seek the minimum subset of that covers . This is clearly an instance of the combinatorial set cover problem. We intend to apply an efficient approximation algorithm proposed by Timothy M. Chan et al. [9] in 2011, which is based on the approach proposed by Kasturi in 2010 [12]

. To use Timothy M. Chan et al. and Kasturi’s approach, we need to make sure that the complexity of the boundary of the union (union complexity) of the visible-lists is near-linear. The approximation factor obtained by rounding the natural linear programming relaxation of the set cover problem is related to the combinatorial problem of bounding the size of an

-net. For objects with union complexity , Kastur obtained an approximation factor of [13], and Timothy M. Chan et al. improved the result into a constant factor of approximation.

The decomposition we obtained yields a set of sc-regions that we need to cover all of them to cover . Pick an arbitrary point inside each sc-region and put them in . Since any visible-list of a guarding-region covers the entire region of a sc-region in the visible-list, choosing an arbitrary point from every sc-region is enough to cover , so . Furthermore, the union complexity of all the visible-lists equals the complexity of the number of sc-regions. Therefore, the union complexity of our objects is linear to the number of objects.

6 Discussion

The point guarding problem has known to be one of the preliminary versions of the Art Gallery problem. Since years ago, this version of the problem was interesting for many scientists and even regular people who wanted to guard a place. The problem has been modeled in many versions; however, the point guarding version that allows the guards to be placed inside a simple polygon was proved to be NP-hard. In 1998, Eidenbenz proved that there could not be any algorithm that solves the problem with a approximation factor. In other words, there is no PTAS for this problem. In 2020, which is more than twenty years after Eidenbenz’s result, Bonnet and Miltzow presented a -approximation factor for the point guarding problem. Therefore, there was a gap between these results, and finding a constant approximation factor should be noteworthy.

Here, we presented an algorithm with a -approximation factor for the point guarding problem where guards are restricted to lie on an arbitrary dense grid. If we choose the grid proposed by Bonnet and Miltzow, we can solve the general point guarding problem with a constant factor approximation in running time polynomial in the ratio of the longest and shortest pairwise distances of the vertices of the art gallery. Otherwise, if we choose the approach proposed in this paper, the restricted point guarding problem can be solved in , where can be chosen to be fine enough. It remains open that if for a constant the grid solution is indeed an approximation of an optimal solution. That is, we do not know if there is constant so that the optimal solution restricted to the final grid is at most a constant times larger than the general optimal solution.

For the sake of simplicity, we only considered the case of an art gallery without holes. For future work, we generalize the approach for the case of an art gallery with holes.


  • [1] É. Bonnet, T. Miltzow. Parameterized Hardness of Art Gallery Problems. ACM Transactions on Algorithms, https://doi.org/10.1145/3398684, 16(4), 2020.
  • [2] A. Vaezi, M. Ghodsi. Visibility extension via reflection-edges to cover invisible segments. Theoretical Computer Science, https://doi.org/10.1016/j.tcs.2019.02.011, 2019.
  • [3] S. Ashur, O. Filtser, M. J. Katz, R. Saban. Terrain-Like Graphs: PTASs for Guarding Weakly-Visible Polygons and Terrains. WAOA 2019: Approximation and Online Algorithms, 1–17, 2019.
  • [4] S. Ashur, O. Filtser, M. J. Katz. A Constant-Factor Approximation Algorithm for Vertex Guarding a WV-Polygon. arXiv:1907.01228, 2019.
  • [5] P. Bhattacharya, S. K. Ghosh, S. P. Pal. Constant Approximation Algorithms for Guarding Simple Polygons using Vertex Guards. arXiv:1712.05492, 2018.
  • [6] M. Abrahamsen, A. Adamaszek, T. Miltzow. The Art Gallery Problem is -complete.

    Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing, STOC

    , 65–-73, 2018.
  • [7] É. Bonnet, T. Miltzow. An Approximation Algorithm for the Art Gallery Problem. Proceedings of the 33rd International Symposium on Computational Geometry (SoCG’17) Article 20, DOI:https://doi.org/10.4230/LIPIcs.SoCG.2017.20, 15 pages, 2017.
  • [8] P. Bhattacharyay, S. K. Ghosh, B. Roy. Vertex Guarding in Weak Visibility Polygons. Algorithms and Discrete Applied Mathematics, Springer, Cham, vol 8959, 45–57, 2015.
  • [9] T.M. Chan, E. Grant, J. Könemann, M. Sharpe. Weighted Capacitated, Priority, and Geometric Set Cover via Improved Quasi-Uniform Sampling. Proceedings of the 2012 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), Doi.org/10.1137/1.9781611973099.125, 2012.
  • [10] J. King, D. Kirkpatrick. Improved Approximation for Guarding Simple Galleries from the Perimeter. Discrete Comput Geom, https://doi.org/10.1007/s00454-011-9352-x, 46, 252–269 2011.
  • [11] S. K. Ghosh. Approximation algorithms for Art Gallery problems in polygons. Discrete Applied Mathematics, 158(6): 718–722, 2010.
  • [12] K. R. Varadarajan. Weighted Geometric Set Cover via Quasi-Uniform Sampling. Proceedings of the 42nd ACM Symposium on Theory of Computing, STOC, DOI: 10.1145/1806689.1806777, 641-–648, 2010.
  • [13] K. R. Varadarajan. Epsilon nets and union complexity. Proceedings of ACM-SIAM Symposium on Computational Geometry, 11-16, 2009.
  • [14] B. Aronov, E. Ezra, M. Sharir. Small-size -nets for axis-parallel rectangles and boxes. Proceeding of ACM Symposium on the Theory of Computing (STOC), 639–648, 2009.
  • [15] G. Karakostas. A better approximation ratio for the vertex cover problem. ACM Transactions on Algorithms. 5 (4): 41:1–41:8. CiteSeerX doi:10.1145/1597036.1597045. S2CID 2525818. ECCC TR04-084, 2009.
  • [16] M. de Berg, M. van Kreveld, M. Overmars, O. Schwarzkopf Computational Geometry Algorithms and Applications. Springer, third edition Department of Computer Science Utrecht University, 13,14 2008.
  • [17] A. Deshpande, T. Kim, E. D. Demaine, and S. E. Sarma. A pseudo-polynomial time -approximation algorithm for art galley problems. WADS, 163-174, 2007.
  • [18] K. Clarkson, K. Varadarajan Improved approximation algorithms for geometric set cover. Discrete & Computational Geometry., 37, 43–58, 2007.
  • [19] A. Deshpande, T. Kim, E. D. Demaine, S. E. Sarma. A pseudopolynomial time -approximation algorithm for art gallery problems. Algorithms and Data Structures, 10th International Workshop, WADS 2007, Halifax, Canada, 163–174, 2007.
  • [20] A. Efrat, S. Har-Peled. Guarding galleries and terrains. Inf. Process. Lett., 100(6) , 238-245, 2006.
  • [21] A. Deshpande. A pseudo-polynomial time -approximation algorithm for art galley problems. Master’s thesis, Department of anical Engineering, Department of Electical and Computer Science, MIT, 2006.
  • [22] S. Eidenbenz, C. Stamm, P. Widmayer. Inapproximability results for guarding polygons and terrains. Algorithmica, 31(1), 79–-113, 2001.
  • [23] U. Feige. A threshold of ln n for approximating set cover. J. ACM, 45(4), 634–-652, 1998.
  • [24] S. Eidenbenz. Inapproximability results for guarding polygons without holes. Proc. 9th Int. Symp. Algorithms and Computation. Lecture Notes in Computer Science, vol. 1533, 427-–436, 1998.
  • [25] R. Raz, S. Safra. A sub-constant error-probability low-degree-test and a sub-constant errorprobability PCP characterization of NP. Proc. 29th ACM Symp. Theory of Computing. El Paso,TX, 475–-484, 1997.
  • [26] B. Aronov, A.R. Davis, T.K. Dey, S.P. Pal, D.C. Prasad. Visibility with one reflection. Discrete & Computational Geometry, 19.4, 553-574, 1998.
  • [27] B. Aronov, A.R. Davis, T.K. Dey, S.P. Pal, D.C. Prasad. Visibility with multiple reflections. Discrete & Computational Geometry, 20.1, 61-78, 1998.
  • [28] M. Karpinski, A. Zelikovsky, Alexander. Approximating dense cases of covering problems. Proceedings of the DIMACS Workshop on Network Design: Connectivity and Facilities Location. DIMACS Series in Discrete Mathematics and Theoretical Computer Science. 40. American Mathematical Society, 169–178, 1998.
  • [29] Approximation algorithms for Art Gallery problems. Proc. Canadian Information Processing Society Congress, 429-–436, 1987.
  • [30] J. O’Rourke. Art Gallery Theorems and Algorithms. Oxford University Press., ISBN:0-19-503965-3, 1987.
  • [31] L. J. Guibas, J. Hershberger, D. Leven, M. Sharir, and R. E. Tarjan. Linear-time algorithms for visibility and shortest path problems inside triangulated simple polygons. Algorithmica, 2: 209–233, 1987.
  • [32] D.T. Lee and A.K. Lin. Computational complexity of Art Gallery problems. IEEE Transactions on Information Theory, 32: 276–282, 1986.
  • [33] A. Aggarwal. The Art Gallery theorem: its variations, applications and algorithmic aspects. Ph.D. thesis, The Johns Hopkins University, Baltimore, MD, 1984.
  • [34] D. T. Lee. Visibility of a simple polygon. Computer Vision, Graphics, and Image Processing, 22: 207–221, 1983.
  • [35] J. O’Rourke, K. Supowit. Some NP-hard polygon decomposition problems. IEEE Trans. Inf. Theory, 29(2), 181–-189, 1983.
  • [36] D. Avis, G. T. Toussaint. An optional algorithm for determining the visibility of a polygon from an edge. IEEE Transactions on Computers, C-30: 910-1014, 1981.
  • [37] M. R. Garey, D. S. Johnson. Computers and Intractability: A Guide to the Theory of NP-Completeness. W.H. Freeman. ISBN 0-7167-1045-5. A1.1: GT1, 190, 1979.
  • [38] S. Fisk. A short proof of Chvátal’s watchman theorem. J. Comb. Theory, Ser. B, 24(3), 374, 1978.

Appendix A Decomposing a spanning convex region

In this subsection, we see how to decompose a given sc-region into distinct and disjoint guarding-regions. This subsection is the complete version of  subsubsection 3.1.2. Here, we also prove subsubsection 3.1.2.

Form the previous steps of Algorithm 1 we know that a temp-sub-region is created based on the collision of two half-lines with the boundary of the given sc-region. The approach sweeps on the given sc-region. When the sweeper reaches a half-line that starts/ends a temp-sub-region, we add/eliminate the visible sc-region corresponding to that temp-sub-region to the visible-list of currently in progress guarding-region. If the sweeper reaches an intersection point of many half-lines, there could be more than one sc-region that we should add or eliminate from the currently in progress guarding-regions. The approach is presented in details in the following:

Decomposition-Process: Consider a sc-region . To decompose , we use a sweep-line called . The sweeping process starts from an edge of . The sweep-line first contains , and moves on parallel to till it reaches the end of where sees all the points of .

The final decomposition of results in several newly created guarding-regions. The Decompose procedure puts the final guarding-regions in a set called . Note that we have to compute a visible-list for every new guarding-region . We already know that contains . The sweep-line has a list of currently in progress guarding-regions that should decide where to end them. Denote this list by inPL. Denote the number of guarding-regions in the current list of the sweep-line by . During the sweeping process may encounter with three cases: 1) It may reach a starting half-line . 2) It may reach an intersection-point of several or half-lines. 3) Or it may reach an ending half-line .

Figure 4: Figure shows that when reaches a half-line we should create new guarding-regions with new visible-lists. We have to add to the visible-list of the guarding-regions that has just passed. Figure illustrates a similar situation where reaches an ending half-line . In such a situation we have to end the currently in process guarding-regions and create new guarding-regions with new corresponding visible-lists that do not contain in their visible-lists. In Figure may reaches an intersection point of several half-lines (either or ). In this case, there is a determinative half-line that passes . This half-line can be either a starting half-line or an ending half-line. Since the sweep-line has encountered previously, the half-line do not make any new guarding-region itself. Nevertheless, the intersection-point make new guarding-regions from previously visited half-lines. See Figure (c), exhibited in green or in white are the new guarding-regions that are starting from . However, and are ended at . For and it is sufficient to update their visible-lists. Based on the type of each half-line we can easily create the new guarding-regions around , and also we can determine their corresponding visible-lists. Note that if is parallel to the direction of then the sweep-line reaches a new half-line and a point, and the creation process of the new guarding-regions is a combined procedure of the above-mentioned strategies. In such a case, we have to consider as an additional or removal region in the visible-lists of the new guarding-regions below .

Consider an arbitrary and suppose can make area-visible. There are three different cases. See Figure 4 as an example. In this figure, the numbers on power of are normal indicators to itemize different guarding-regions. This figure illustrates three different cases where a sweep-line may encounter while tracing a sc-region to decompose it into guarding-regions. The three cases:

1,2) If reaches a starting half-line or an ending half-line ; Do these steps:

  1. End all the guarding-regions in the inPL. That is because all the previously submitted guarding-regions in inPL are ended by the the new line.

  2. Add every newly ended guarding-region to (the output set).

  3. Based on the number of crossing lines with the half-line , create new guarding-regions in inPL. Each of such new guarding-regions starts from and has its own boundary.

  4. Create a visible-list for each new () with the initiation value of .

  5. For each , if has on the other side (the already swept side) of , set

    . Note that we only check one line at a moment, so only one temp-sub-region and consequently the visibility of one sc-region is checked, and other visible sc-regions are still visible.

  6. For each new ,

    if reaches ;

    Add to .

    else reaches ;

    Remove from .

3) If reaches an intersection-point of half-lines and half-lines;
Without loss of generality suppose all of these half-lines are on distinct lines, and assume that the sweep-line is slightly tilted so that it considers the intersections one by one. We already know that (see Figure 4(c)). So, all the half-lines are already seen by . The most recently visited half-line is either a or a . Again, w. l. o. g. suppose it is , and is parallel to the direction of the sweep-line .

Do the following steps:

  1. End every guarding-region in inPL. These guarding-regions are above , where was moving before it reaches .

  2. Add every newly ended guarding-region to .

  3. Based on the lines crossing , create new guarding-regions in inPL.

  4. Create a visible-list for each new guarding-region () in inPL ().

  5. Add to every .

  6. There are nv newly guarding-regions created in . For each check it with each half-line intersected in .

    (a) If is a starting half-line and lies between and , then add to .

    (b) If is an ending half-line and is not between and anymore, then remove from .

Set from the above-mentioned approach as the output, which is the decomposed set of a given sc-region.

Appendix B List of Notations

For a better presentation and the convince of the reader, we list the frequent notations that we used throughout the paper.

= a sc-region

= a guarding-region

rf = a reflex-vertex

VP = visibility polygon of a point or a guard

Vp = visible part of a guard inside a sc-region

VL = visible-list of a guarding-region

= the set of all guarding-regions after the decomposition of into guarding-regions by the beginning of Step 4 of Algorithm 1

OPT = the set of guards in the optimal solution of the point guarding problem

= the set of guards in the optimal solution that can be obtained from .