1 Introduction and Related Works
Consider a simple polygon with vertices. The maximal subpolygon of visible to a point in is called the visibility polygon of , which is denoted by . There are lineartime algorithms to compute when the viewer is a point [34]. For the segment inside , the weak visibility polygon of , denoted as , is the maximal subpolygon 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 boundaryguards (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 NPhard first for polygons with holes by [35]. For guarding simple polygons, it was proved to be NPcomplete 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 APXcomplete, meaning that we cannot do better than a constantfactor 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 NPhard 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 HarPeled 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 NPhard, 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 constantapproximation 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 predetermined grid.
Efrat and HarPeled [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 pseudopolynomial time algorithm proposed by Deshpande et al. in 2007 [21] with another approach presented by Efrat and HarPeled in 2006 [20]. The algorithm presented by Deshpande et al. is flawed and retracted by Bonnet and Miltzow. Efrat and HarPeledattain presented a randomized polynomialtime algorithms restricting guards to a very fine grid [20], where denotes an optimal set of guards that is restricted to some grid. Efrat and HarPeled 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 HarPeled, Edouard Bonnet and Tillmann Miltzow proposed the first randomized polynomialtime approximation algorithm for simple polygons [7]. The running time of the algorithm used by Efrat and HarPeled 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 twodimensional 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 NPhard problem admits several different polynomialtime 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 QuasiUniform sampling. He managed to propose a sublogarithmic approximation factor for fairly geometric objects. The approximation factor obtained by Kasturi in [12] is related to the wellknown 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 nearlinear [18, 14, 13]. Kasturi [12] proposed a randomized algorithm and used samples of nets for a strategy called QuasiUniform sampling. He used the QuasiUniform 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 nearlinear 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 QuasiUniform 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
guardingregion. Every guardingregion carries a list of completely visible spanning convex regions. In fact, the characteristic of every guardingregion is that any spanning convex region that is completely visible to a point in a guardingregion is also completely visible to every point of . The family of the visible lists of the guardingregions 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 guardingregions), 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 guardingregions, 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 guardingregions. 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 subregion 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 areavisible to , all of its points must be visible to . A subregion is areavisible to another subregion or segment denoted as the , if all points of are visible to the .
AreaVisibility: A region is called areavisible to a source (a point, a segment, or a region), if all the points of are visible to all the points of the .
SCRegions: Each minimal region formed from a decomposition of the given polygon into a set of convex components is called a scregion, 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 scregions. As mentioned before, will be decomposed into other smaller special subregions called “guardingregions”. If we put two guards in different arbitarary positions inside a guardingregion, the same subset of scregions is areavisible to both points. In order to compute guardingregions we decompose every scregion into guardingregions. For a more precise definition for guardingregions see the following definition. guardingregions: Consider a simple polygon , decompose into scregions. Given a query point in , a subset of scregions are areavisible to . Call this subset as the visible list of and denote this list by VL. A guardingregion is a convex polygon that the list of areavisible scregions to every point is the same. We will estimate the visibility polygon of a guard in any arbitrary position inside a guardingregion by the visible list of that guardingregion. Denote the cardinality of a visiblelist corresponding to a guardingregion by . Based on this definition, for a more straightforward presentation, we may refer to guardingregion’s visibility list instead of a guard visibility polygon.
In order to compute guardingregions inside a scregion, in the initial step we need to count on the areavisibility of each scregion individually. A subregion inside each scregion that sees another scregion completely is called a temporary subregion, for short, we call each of them a tempsubregion. See the following definition. Tempsubregion: Given two scregion and (), suppose there is a subregion inside denoted by that is areavisible to , we call this subregion a tempsubregion. These tempsubregions will be computed by checking the edges of each scregion individually. Each tempsubregion eventually will be used to divide scregions into guardingregions. Then, we sweep on each scregion and decompose it to guardingregions by the help of tempsubregions. For the presentation to be simpler we define a visible list for each tempsubregion too. Consider a tempsubregion inside the scregion that is areavisible to (), the visible list of contains and .
3.1 Approximation Algorithm
Here we present an algorithm that computes the set of all the guardingregions, this set is denoted by . Algorithm 1 illustrates the pseudocode of the approach. In Step 1, we decompose into scregions, which indicates the number of all the scregions (Recall that no matter how we compute scregions, we can compute the corresponding list of guardingregions). Step 2 contains three for loops that corresponding to each scregion, we check their edges one by one to find tempsubregions. Suppose has edges. Note that any guard inside may see other scregions ( ) only through ’s edges. Step 2 uses a procedure called Findtsr to compute tempsubregions correspond to every edge of a given scregion.
Step 3 receives all tempsubregions inside a given scregion and decomposes them into guardingregions. This step also uses a procedure called . This procedure receives a scregion as a parameter. Then, by sweeping on that scregion splits it into guardingregions. The given scregion denoted by will be decomposed into a set of guardingregions called . The set is the final set that contains all the guardingregions, and let denote the cardinality of . The algorithm computes every and adds it to (). By the end of Algorithm 1 contains all guardingregions, and their visiblelists. In fact, contains pairs () of all the guardingregions and their corresponding visible lists. A minimum subset of guardingregions whose visiblelist cover all the scregions 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:approximationanalysis deals with the approximation analysis of the algorithm.
3.1.1 Procedure Findtsr(a segment, a scregion)
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 completevisibilitypolygon of () and check if the target fits inside that. If the answer is yes, then we found a target that is areavisible to . We use the endpoints of to find a tempsubregion that can make the target areavisible. If so, we add it to the output set of the Findtsr procedure. While we check the completevisiblepolygon 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 halflines that intersect on its endpoints.
We extend these halflines backward inside the source. The intersection between these two halflines and the boundary creates a tempsubregion . 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 areavisible to .
For a specific edge , to compute a tempsubregion ; It takes time to compute its completevisibilitypolygon, 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 tempsubregions 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 scregion is areavisible to that.
3.1.2 Procedure Decompose(spanning convex region)
This procedure intends to decompose a given spanning convex region () into guardingregions. According to Algorithm 1
when we reach this procedure, every spanning convex region is divided into some tempsubregions that probably share common areas. Line 12 counts every spanning convex region, and line 13 calls the
procedure to obtain guardingregions inside a given spanning convex region. The procedure computes the guardingregions inside from the tempsubregions (see Figure 4).A tempsubregion is obtained from the area between two halflines (backward rays). We aim to decompose every scregions using their intersection with the area between these halflines. Denote the number of tempsubregions inside , including , by , which indicates the complexity of . For each tempsubregion in , except for itself, denote a starting halfline by , and an ending halfline by . So, inside a tempsubregion is between two halflines and . We are going to sweep on , regardless of the direction we move on, for a simpler presentation, we refer to these halflines and . From the previous steps of Algorithm 1, for every two starting and ending halflines it is already specified what scregions () are visible to the points between any two halflines and .
A scregion can be decomposed into guardingregions in , where denotes the complexity of a scregion.
Proof.
To decompose , we use a sweepline 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 scregion 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 vertices^{1}^{1}1A 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

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.

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

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 scregion 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 scregions, then the solution of the restricted point guarding equals the solution of the general point guarding. This is because, in such a situation, every scregion becomes completely visible by at least one guard in the optimal solution. Recall that Algorithm 1 counts on the complete visibility of the scregions to construct visible lists of the guardingregions.
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 scregions, 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 subcells 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 subcells 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 subcell 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 subcell 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 subcells so that at least one subcell 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)
orderConvexRegions: Each minimal region formed in the step of the subsequent approach is called an orderconvexregion. Consider a small given constant denoted by that .

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 zeroorderconvexregions.

In the step , run the following splitting process times. For each orderconvexregion, draw all the unique lines crossing the specified segments designated in the below:

Connect every two intersection points to each other.

If the orderconvexregion is a triangle connect the middle point of every edge to the third vertex of the triangle.


Compute all the intersections of the abovementioned lines.

Now trace and compute the intersection of the boundary of and the abovementioned lines.
The orderconvexregions constructed from the abovementioned approach specify the set of the spanning convex regions (see Figure 3 (a) and (b)).
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 intersectionpoints. We connect these intersectionpoints 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 tempsubregions, each of the result tempsubregions has in its visiblelist. So, all the spanning convex regions and consequently will be covered.
Algorithm 1 takes polynomial time in the complexity of the grid size ().
Proof.
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 visiblelists of guarding regions—the union of the visiblelists 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 visiblelists is nearlinear. 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 scregions that we need to cover all of them to cover . Pick an arbitrary point inside each scregion and put them in . Since any visiblelist of a guardingregion covers the entire region of a scregion in the visiblelist, choosing an arbitrary point from every scregion is enough to cover , so . Furthermore, the union complexity of all the visiblelists equals the complexity of the number of scregions. 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 NPhard. 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.
References
 [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 reflectionedges 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. TerrainLike Graphs: PTASs for Guarding WeaklyVisible Polygons and Terrains. WAOA 2019: Approximation and Online Algorithms, 1–17, 2019.
 [4] S. Ashur, O. Filtser, M. J. Katz. A ConstantFactor Approximation Algorithm for Vertex Guarding a WVPolygon. 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 QuasiUniform Sampling. Proceedings of the 2012 Annual ACMSIAM 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/s004540119352x, 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 QuasiUniform 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 ACMSIAM Symposium on Computational Geometry, 1116, 2009.
 [14] B. Aronov, E. Ezra, M. Sharir. Smallsize nets for axisparallel 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 10.1.1.649.7407. doi:10.1145/1597036.1597045. S2CID 2525818. ECCC TR04084, 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 pseudopolynomial time approximation algorithm for art galley problems. WADS, 163174, 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. HarPeled. Guarding galleries and terrains. Inf. Process. Lett., 100(6) , 238245, 2006.
 [21] A. Deshpande. A pseudopolynomial 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 subconstant errorprobability lowdegreetest and a subconstant 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, 553574, 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, 6178, 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:0195039653, 1987.
 [31] L. J. Guibas, J. Hershberger, D. Leven, M. Sharir, and R. E. Tarjan. Lineartime 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 NPhard 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, C30: 9101014, 1981.
 [37] M. R. Garey, D. S. Johnson. Computers and Intractability: A Guide to the Theory of NPCompleteness. W.H. Freeman. ISBN 0716710455. 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 scregion into distinct and disjoint guardingregions. 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 tempsubregion is created based on the collision of two halflines with the boundary of the given scregion. The approach sweeps on the given scregion. When the sweeper reaches a halfline that starts/ends a tempsubregion, we add/eliminate the visible scregion corresponding to that tempsubregion to the visiblelist of currently in progress guardingregion. If the sweeper reaches an intersection point of many halflines, there could be more than one scregion that we should add or eliminate from the currently in progress guardingregions. The approach is presented in details in the following:
DecompositionProcess: Consider a scregion . To decompose , we use a sweepline called . The sweeping process starts from an edge of . The sweepline 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 guardingregions. The Decompose procedure puts the final guardingregions in a set called . Note that we have to compute a visiblelist for every new guardingregion . We already know that contains . The sweepline has a list of currently in progress guardingregions that should decide where to end them. Denote this list by inPL. Denote the number of guardingregions in the current list of the sweepline by . During the sweeping process may encounter with three cases: 1) It may reach a starting halfline . 2) It may reach an intersectionpoint of several or halflines. 3) Or it may reach an ending halfline .
Consider an arbitrary and suppose can make areavisible. 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 guardingregions. This figure illustrates three different cases where a sweepline may encounter while tracing a scregion to decompose it into guardingregions. The three cases:
1,2) If reaches a starting halfline or an ending halfline ; Do these steps:

End all the guardingregions in the inPL. That is because all the previously submitted guardingregions in inPL are ended by the the new line.

Add every newly ended guardingregion to (the output set).

Based on the number of crossing lines with the halfline , create new guardingregions in inPL. Each of such new guardingregions starts from and has its own boundary.

Create a visiblelist for each new () with the initiation value of .

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 tempsubregion and consequently the visibility of one scregion is checked, and other visible scregions are still visible.

For each new ,
if reaches ;
Add to .
else reaches ;
Remove from .
3)
If reaches an intersectionpoint of halflines and halflines;
Without loss of generality suppose all of these halflines are on distinct lines, and assume that the sweepline is slightly tilted so that it considers the intersections one by one. We already know that (see Figure 4(c)). So, all the halflines are already seen by . The most recently visited halfline is either a or a . Again, w. l. o. g. suppose it is , and is parallel to the direction of the sweepline .
Do the following steps:

End every guardingregion in inPL. These guardingregions are above , where was moving before it reaches .

Add every newly ended guardingregion to .

Based on the lines crossing , create new guardingregions in inPL.

Create a visiblelist for each new guardingregion () in inPL ().

Add to every .

There are nv newly guardingregions created in . For each check it with each halfline intersected in .
(a) If is a starting halfline and lies between and , then add to .
(b) If is an ending halfline and is not between and anymore, then remove from .
Set from the abovementioned approach as the output, which is the decomposed set of a given scregion.
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 scregion
= a guardingregion
rf = a reflexvertex
VP = visibility polygon of a point or a guard
Vp = visible part of a guard inside a scregion
VL = visiblelist of a guardingregion
= the set of all guardingregions after the decomposition of into guardingregions 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 .
Comments
There are no comments yet.