Computing Maximum Independent Set on Outerstring Graphs and Their Relatives

03/17/2019 ∙ by Prosenjit Bose, et al. ∙ University of Saskatchewan Carleton University Ben-Gurion University of the Negev 0

A graph G with n vertices is called an outerstring graph if it has an intersection representation of a set of n curves inside a disk such that one endpoint of every curve is attached to the boundary of the disk. Given an outerstring graph representation, the Maximum Independent Set (MIS) problem of the underlying graph can be solved in O(s^3) time, where s is the number of segments in the representation (Keil et al., Comput. Geom., 60:19--25, 2017). If the strings are of constant size (e.g., line segments, L-shapes, etc.), then the algorithm takes O(n^3) time. In this paper, we examine the fine-grained complexity of the MIS problem on some well-known outerstring representations. We show that solving the MIS problem on grounded segment and grounded square-L representations is at least as hard as solving MIS on circle graph representations. Note that no O(n^2-δ)-time algorithm, δ>0, is known for the MIS problem on circle graphs. For the grounded string representations where the strings are y-monotone simple polygonal paths of constant length with segments at integral coordinates, we solve MIS in O(n^2) time and show this to be the best possible under the strong exponential time hypothesis (SETH). For the intersection graph of n L-shapes in the plane, we give a (4· OPT)-approximation algorithm for MIS (where OPT denotes the size of an optimal solution), improving the previously best-known (4· n)-approximation algorithm of Biedl and Derka (WADS 2017).

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

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

Let be an undirected graph with ; graph is weighted if each edge in is associated with a non-negative value, called its weight. A set is an independent set if no two vertices in are adjacent. The objective of the Maximum Independent Set () problem is to compute a maximum-cardinality independent set of . The problem is -complete and it is known that no approximation algorithm with approximation factor within is possible for any  [20]. The inapproximability of the problem has motivated a rich body of research to study the problem on the intersection graph of geometric objects. Let be a set of geometric objects in the plane. Then, the intersection graph of has the objects in as its vertices and two vertices are adjacent in the graph if and only if . If is a set of curves in the plane (resp., a set of chords of a circle), then the intersection graph of is called a string graph (resp., circle graph); see Figure 1(b–c) for an example.

Ehrlich et al. [12] showed in 1976 that every planar graph has a string representation. Moreover, the longstanding Scheinerman’s conjecture [31], stating that all planar graphs can be represented as intersection graphs of line segments was proved affirmatively only in 2009 by Chalopin and Gonçalves [9]. For the problem, Fox and Pach [15] gave an algorithm with an approximation factor of when the input consists of a set of curves, any two intersecting at most a constant number of times. The problem has been studied on the intersection graph of other geometric objects such as line segments [1], disks and squares [13], rectangles [8] and pseudo-disks [10].

We study the problem on outerstring graphs and their relatives with respect to the time-complexity of solving in circle graph representations.

Definition 1.1 (Outerstring Graph [24]).

Graph is called an outerstring graph if it is the intersection graph of a set of curves that lie inside a disk such that each curve intersects the boundary of the disk in one of its endpoints.

Figure 1(d) shows an example of an outerstring graph. A string representation of a graph is called grounded, if one endpoint of each string is attached to a grounding line and all strings lie on one side of . For example, a graph is called a grounded segment graph, if it is the intersection graph of a set of segments such that each segment is attached to a grounding line at one of its endpoints and all segments lie on one side of ; see Figure 1(e).

Figure 1: (a) A graph with six vertices. (b) A string graph, (c) a circle graph, (d) an outerstring graph, (e) a segment graph, (f) a grounded , and (g) a grounded square- representation of .

Gavril [17] presented an algorithm for solving the problem on circle graphs. Subsequent improvement reduced the complexity to  [32, 3]. Several algorithms exist with running time sensitive to various graph parameters, e.g., time [2, 33], or time [30]. Here is a parameter known as the density of the circle graph, and is the independence number of the circle graph. However, no truly subquadratic-time algorithm (i.e., an -time algorithm where ) is known for the problem on circle graphs.

Although recognizing an intersection graph may require time (since there could be edges), the problem can be solved faster if an intersection representation is given. For example, in an interval graph representation can be solved in time [16]. Moreover, recognizing outerstring graphs is -complete [7], but given an outerstring representation, one can solve the weighted problem in time, where is the number of segments in the representation [23]. For grounded segment graphs, this yields a time complexity of , where is the number of vertices in the grounded segment graph. Although the strings in a grounded segment graph are straight line segments, no faster algorithm is known for this case. Thus a natural question is to ask whether one can prove non-trivial lower bounds on the time complexity of the problem for outerstring graphs or simpler variants of such graphs.

An -shape is the union of a vertical segment and a horizontal segment that share an endpoint; hence, there are four possible types of -shapes: . A graph is called a B-VPG graph if it is the intersection graph of a set of -shapes in the plane. This class of string graphs belongs to a larger class called the Vertex intersection of Paths on a Grid (VPG) and denoted by B-VPG, where indicates the maximum number of bends each path can have in the grid representation [4]. These graphs and their relatives have been studied extensively in terms of recognition problems (e.g., see [19, 14, 11, 4]). Recently, there has been an increasing attention on studying optimization problems on these graphs; see [5, 27, 6, 28] and the references therein. For the problem, it is known that the problem is -complete on B-VPG graphs even when  [25], and the previously best-known approximation algorithms have factor  [6, 28]. Combining B-VPG and grounded string graphs, we consider the problem on grounded and grounded square- graphs.

Definition 1.2 (Grounded and Grounded Square- Graphs.).

Graph is called a grounded graph if is the intersection of a set of -shapes such that each -shape is of type and the lower endpoint of the vertical segment of each -shape is attached to a grounding line . If the vertical and horizontal segments of every -shape in a grounded representation of have the same length, then we call a grounded square- graph.

See Figure 1(f–g) for examples of these graphs. We now summarize our contribution in .

  • C1. (Section 2): We first examine the time-complexity of the problem on the grounded segment graphs with respect to its relation to the problem in circle graphs. Middendorf and Pfeiffer [29] showed that every intersection graph of -shapes of types and (not necessarily grounded) can be transformed into a segment representation. If the -shapes are grounded, then the transformation yields a grounded segment graph. Since every circle graph is a grounded graph [22], they are also grounded segment graphs. However, the transformation [29] into the grounded segment representation is by an inductive proof, and it is unclear whether the constructed representation can be encoded in a subquadratic number of bits. We show that the problem in a circle graph representation is -time reducible to the problem in an implicit representation of a grounded segment graph, where the representation takes bits. This indicates that solving in such grounded segment representations is as hard as solving in circle graph representations.

  • C2. (Sections 34): Since grounded graphs include circle graphs, we examined a simpler variant: grounded square- graphs. We show that there exist grounded square- graphs (resp., grounded graphs) that are not circle graphs (resp., grounded square- graphs). Although grounded square- is a simpler variant, we prove that it includes the circle graphs. In fact, we give an -time reduction, showing that in grounded square- representations is at least as hard as in circle graph representations. In contrast, for the grounded string representations where the strings are -monotone simple polygonal paths of constant length with segments at integral coordinates, we can solve in time. Assuming the strong exponential time hypothesis (SETH) [21], we show that an -time algorithm, where , for computing in outerstring representations of size is unlikely, even when each string has one bend.

  • C3. (Section 5): We give a -approximation algorithm for the weighted problem on the intersection graph of a set of -shapes in the plane. This improves the previously best-known algorithm, which has an approximation factor of  [6, 28]. Moreover, we show that our algorithm also gives a -approximation for the weighted problem on a set of axis-parallel rectangles in the plane. We note that for the special case of , this improves the -approximation algorithm of Chalermsook and Chuzhoy [8].

2 on Grounded Segment Representations

In this section, we show that the problem in a circle graph representation is -time reducible to the problem in a representation of a grounded segment graph, where the representation takes bits. This indicates that solving on grounded segment representations could be as hard as solving on circle graph representations.

An overlap graph is an intersection graph of intervals, where two vertices are adjacent if and only if their corresponding intervals properly intersects (i.e., the intersection is non-empty but neither contains the other). Gavril [17] showed that a graph is a circle graph if and only if it is an overlap graph. Given the circle graph representation, one can find an overlap representation in linear time by computing the shadow of each chord on a horizontal line below the circle, assuming the point light source is at the apex of the circle as illustrated in Figure 2(a–c). It now suffices to show that the overlap representation can be transformed into a grounded segment representation in linear time.

Figure 2: (a) A circle graph . (b) A circle graph representation of . (c) Transformation into an overlap graph. (d)-(e) Transformation into a grounded segment graph. We only show a schematic representation for space constraints.

We assume that the circle graph representation is non-degenerate, i.e., no two chords share a common endpoint. Consequently, the overlap representation is also non-degenerate. We now sort the endpoints of the intervals and relabel them with integral coordinates. For each interval in the overlap graph, we define a line segment with coordinates . Note that all the segments are grounded at the line ; i.e., line in Figure 2(d). Moreover, it is straightforward to encode the representation implicitly in bits (note that an explicit representation would require bits). Let the resulting representation be . In the proof of the following theorem we show that is the required grounded segment representation.

Theorem 2.1.

Given a circle graph representation with chords, in time one can transform it into an implicit grounded segment representation, which uses bits. Thus, the problem on grounded segment representations could be as hard as the problem on circle graph representations.

Proof.

Consider the representation constructed from the overlap representation of the circle graph. It is straightforward to observe that if two intervals do not intersect in the overlap graph, then the corresponding segments do not intersect in . We now need to prove that if two intervals properly intersect, then the corresponding segments intersect in ; otherwise, one interval contains the other and the segments do not intersect in .

Let and be two intervals that properly intersect; i.e., , and let and be the corresponding segments. Note that intersects the line at height . Hence, will intersect if it intersects the line at the same or a higher point. Therefore, we need to show that holds. Observe that

Since and , the above condition will hold for any integral , and hence the segments will intersect.

Finally, if the interval contains the interval , i.e., , then the height of at is , whereas the height of is . Since , for any integral , the height of at will be larger than that of . Hence the segments will not intersect. ∎

3 on Grounded Square- Representations

In this section, we show that solving in a circle graph representation is -time reducible to solving in a grounded square- representation.

Given a circle graph representation, we first compute the corresponding overlap graph in the same way as we did in Section 2, and relabel the endpoints with integral coordinates from to . We now transform this into a grounded square- representation. The idea is to process the intervals in the order of their endpoints, and sometimes shifting the endpoints by a certain offset to avoid unnecessary crossings. We now give formal description of the steps of the construction by .

. Initialize an empty list , and then process the intervals in the increasing order of the -coordinates of their left endpoints. While processing an interval , we first find the closest non-intersecting interval to the left of . If no such interval exists, then we continue processing the next interval. Otherwise, let be the tuple at the end of the list (assume a dummy tuple if the list is empty). If , then append a new tuple ) to .

. For each pair of consecutive tuples and in , update the -coordinates of the endpoints originally lying in by adding the integer . Finally, for the last tuple , update the -coordinates of the endpoints originally lying in , by adding the integer . Figure 3(a–b) illustrate this step.

. For each interval in the increasing order of their left endpoints, construct a square- shape with endpoints and , and create the bend point at . See Figure 3(c).

By , it is straightforward to see that all the shapes are grounded on the line . Let be the resulting grounded square- representation. The following lemma claims the correctness of the representation.

Figure 3: (a) An overlap representation. (b) Modification after step . (c) The grounded square- representation constructed at ; is grounded at .
Lemma 3.1.

The graph represented by is the same as the graph represented by the overlap representation.

Proof.

Let be the graph corresponding to the input overlap representation. While processing the th interval in , it suffices to verify the invariant that the subgraph of induced by and the intervals with left endpoints smaller than has been correctly represented with a grounded square- representation.

The invariant is trivial for the first interval, and assume that it holds for , where . Consider now the th interval . Let be the vertex corresponding to interval , and let another vertex in , and denote by , the interval of . Let be the modified intervals (computed in ). For any interval , let be the square- shape constructed as in . We now consider the following cases.

Case 1 ( and are adjacent in ): In this case and properly intersect; i.e., neither contains the other. Note that the coordinate updates in ensures that will not intersect , where the corresponding is the closest non-intersecting interval to the left of . Thus would not intersect . However, this requires updating the all the endpoints after by an offset. We now show that this still maintains a valid representation.

Consider a pair of vertices in in , and let and be their intervals in . Let and be the modified intervals in . If and are adjacent, then they must properly intersect, and there are only three possible ways their endpoints may be updated in step , as shown in Figure 4. Since and intersect (Figure 4(right)), the constructed and must intersect. Now consider the case when and are not adjacent. If one of and contains the other, then the same argument holds. If neither contains the other, then the offset may only increase their distance. Therefore, if and do not intersect, then and cannot intersect.

Figure 4: Illustration for Case 1 in the proof of Lemma 3.1.

Case 2 ( and are non-adjacent in ): In this case either and do not intersect, or one contains the other.

If contains or contains , then by the same argument as in Case 1, we can see that and will not intersect.

Assume now that and do not intersect. Recall that has been processed after . While we processed in , we first computed the closest interval to the left of . Hence . In , we ensured that the endpoints of are shifted to the right by at least an amount of . Here, corresponds to the overall shift for to accommodate the segments that were processed before , and represents the distance relative to to avoid the crossing between and . Since , the shapes and cannot intersect. ∎

Theorem 3.1.

Given a circle graph representation with chords, in time one can transform it into a grounded square- representation. Thus, the problem on grounded square- representations is at least as hard as the problem on circle graph representations.

Proof.

By Lemma 3.1, one can construct the required grounded square- representation by following . We compute two sorted arrays, one for the left endpoints and the other for the right endpoints of the intervals in the overlap representation. The sorting takes time. We use these arrays to answer each query in steps in time by performing a binary search. We need only queries, and hence time in total. Steps take time. Hence the running time of the the overall transformation can be bounded by . ∎

Figure 5: (a) A graph , (b) the graph obtained from , and (c) a grounded square- representation of .

Our reduction shows that every circle graph is a grounded square- graph. However, the reverse is not true. Even, there are grounded graphs that are not grounded square- graphs.

Theorem 3.2.

There are grounded square- graphs that are not circle graphs. Moreover, there are grounded graphs that are not grounded square- graphs.

Proof.

We first show that not all grounded square- graphs are circle graphs. For a graph , let denote the graph obtained from by adding a new vertex to the graph and connecting it to every vertex in ; it is known that is a permutation graph if and only if is a circle graph [18]. Now, consider the graph shown in Figure 5(a). Limouzy [26] proved that is not a permutation graph. Consequently, the graph (shown in Figure 5(b)) is not a circle graph. However, a grounded square- representation of is shown in Figure 5(c).

We now show that there are grounded graphs that are not grounded square- graph. To this end, we show that (i.e., the wheel graph of order 5 as shown in Figure 6(a)) is a grounded graph, but not a grounded square- graph. A grounded graph representation of is shown in Figure 6(b). Suppose for a contradiction that shown in Figure 6(a) has a grounded square- graph representation. The idea is to show that the 5-cycle on the outerface has a unique representation (with respect to the order by which the corresponding -shapes are grounded) and that in this representation one cannot add the -shape corresponding to the centre vertex .

Consider the set of -shapes induced by the 5-cycle on the outerface and assume w.l.o.g. that is the highest -shape. Since is the highest -shape, both of its adjacent -shapes and must intersect from the left in such a way that and do not intersect each other. Assuming w.l.o.g. that is to the left of , this gives a unique representation of and as shown in Figure 6(c). Now, the -shape cannot intersect the horizontal segment because then it would also intersect , which is not allowed. This means that must be to the left of . Then, one can check that the only possibility for the -shape is to be between and , resulting in the unique representation shown in Figure 6(c).

Figure 6: An illustration for the proof of Theorem 3.2.

To see why cannot be added, consider the -shape . First, the -shape cannot be to the left because then it must intersect , which implies that the height of is smaller than that of . Consequently, cannot intersect , which is a contradiction. Therefore, must be to the right of . If the height of is smaller than that of , then cannot intersect — a contradiction. If the height of is larger than that of , then cannot intersect both and at the same time, which is a contradiction. This completes the proof of the theorem. ∎

Figure 7: Illustration for the proof of Theorem 3.3.

The strong exponential time hypothesis (SETH), introduced by Impagliazzo, Paturi, and Zane [21], has been used to analyze fine-grained time-complexity of problems that lie in P. Under SETH, CNF-SAT on variables cannot be solved in time for any . The following theorem sates that under SETH, finding in outerstring graphs requires time.

Theorem 3.3.

Assuming the strong exponential time hypothesis (SETH), computing an in an outerstring representation with strings requires time, even when each string contains bends.

Proof.

Given an instance of CNF-SAT, the idea is to partition its variables into two sets . For each of the truth assignments for the variables in , we construct a set of outerstrings that correspond to the clauses that it satisfies. For example, an interval , , in Figure 7, corresponds to a truth assignment of the variables of the variables in , and the strings (solid lines) grounded in correspond to the clauses that the assignment satisfies. We construct the strings for the set symmetrically. We show that an of size (where is the number of clauses) would correspond to an affirmative solution to the CNF-SAT instance, and vice versa. We next give the details.

Let be an instance of CNF-SAT on variables and clauses. Partition the variables into two sets and , each containing variables. By the above discussion, it now suffices to construct a corresponding outerstring representation of size in time such that an of size in corresponds to an affirmative answer to and vice versa.

Let be the clauses, and denote by the “clause-point” , the point , where is a positive constant. Let , where , be the truth value assignments for the variables in . For , assign intervals , each of length , consecutively on the grounding line, as illustrated in Figure 7. If the assignment corresponding to satisfies a set of clauses, then we will create outerstrings that starts at , and each connects to a distinct clause in . It is straightforward to ensure that the strings lie on the left half-plane of , and do not intersect themselves. For each string, we create a bend on the line so that for any , where , the strings that originate from intersect those that originate from . Construct the strings for symmetrically. Let be the resulting representation.

We now show that an of size on corresponds to an affirmative solution to . Without loss of generality assume that the contains a string that starts at some . Then we can choose at most strings from the left-halfplane, where these strings correspond to the clauses satisfied by the assignment . We take as the assignment for the variables in . If , then we can choose any assignment for the variables in . If , then there must be a string on the right-halfplane in the solution, and we can choose an assignment for the variables in that together with , satisfies all the clauses.

If admits an affirmative answer, then the corresponding assignment of the variables on and will correspond to two intervals and to the left and right half-planes of , respectively. Since these assignments together satisfy all the clauses, choosing all the strings from , and all from except those that intersect the ones from , will give an independent set of size . ∎

4 Representations with Bounded-Length Integral Shapes

In this section, we consider string representations where the strings are -monotone (not necessarily strict) polygonal paths, the length of each string is bounded by a constant , and all the bends and endpoints are on integral coordinates. We show that the problem on such representations can be solved in time. For simplicity, we first examine the case when each string is an -shape of type . Denote by , an axis-aligned simple -monotone (not necessarily strictly monotone) polygonal path that satisfies the following three constraints: (a) starts at point , and ends at a point on the line . (b) contains at most bends, and (c) the length of each line segment in is bounded by . Then the number of such distinct strings can be at most (since is a constant). Denote the set of such strings by .

We employ a dynamic programming technique, where we express a subproblem with two points on the grounding line and two monotone paths and . Figure 8(a) illustrates a subproblem . The subproblem contains all the -shapes of the given representation that are in the region between and . The left side of the region is open and the right side is closed, hence the -shape that starts at must be excluded. While constructing subproblems, we will ensure that and belong to the set of grounding points on the grounding line. The initial problem can be expressed as , where is a grounding point of a dummy -shape lying to the left of all the -shapes, and is the grounding point of the rightmost -shape. and are two strings that bound all the -shapes in between.

Given a problem of the form , we first find a grounding point at the median position among the distinct grounding points between and , as illustrated in Figure 8(b). Note that -shapes can share grounding points, and we only consider the distinct points while considering the median point. If coincides with , then we have the base case where all the -shapes starts at . We thus return 1 or 0 depending on whether there exists a -shape in the region between and (this takes time). Otherwise, we compute the solution using the following recurrence relation.

Figure 8: Illustration for the dynamic programming. (a) A subproblem. (b) Splitting into subproblems. (c)–(d) General -monotone strings.

To verify the correctness of the recurrence relation, observe that any independent set of can be partitioned by a string in . The size of the dynamic programming table is bounded by , where the first term comes from the choices for and , and the term corresponds to the possible choices for and . Computing a base case requires time. In the base case, and are consecutive on the ground line, and hence there can be at most distinct base cases, requiring time in total. Computing an entry in the general case requires time (using constant time table look-up). Hence the running time for the general case is also bounded by in total.

Although we described the algorithm for -shapes, it is straightforward to generalize the algorithm for -monotone strings, as illustrated in Figure 8(c)–(d). The only difference is that we need to define as a simple -monotone path. The following theorem summarizes the results of this section.

Theorem 4.1.

Let be a string representation such that the strings are -monotone (not necessarily strict), the length of each string is bounded by a constant, and all the bends and endpoints are on integral coordinates. Then, the problem in can be solved in time.

5 A -Approximation Algorithm

In this section, we give a -approximation algorithm for the problem on the intersection graph of a set of -shapes. To this end, we first give a -approximation algorithm for the problem when the input consist of only -shapes of type . We discuss the generalization of our algorithm to the weighted version of the problem and for approximating the problem on rectangles at the end of this section.

Consider the input -shapes from left to right in the increasing order of the -coordinate of their vertical segment; we denote the th -shape in this ordering by . For any , we define as the set of -shapes such that (i) , and (ii) does not intersect the line through the vertical segment of . We add a dummy -shape far to the right such that no input -shape intersects the line through the vertical segment of ; thus, is the set of all input -shapes. Moreover, let denote the size of an optimal solution for the problem on the set of -shapes in ; we denote simply by . For any such and some , let denote the set of -shapes such that (i) and (ii) intersects the line through the vertical segment of . Moreover, let be the size of an optimal solution for the problem on the intersection graph induced by the -shapes in .

We define as the solution returned by our algorithm on the -shapes in , for all . Initially, for every pair , if , then we set . Then, for every pair , we check to see if ; if so, then we directly store in . Otherwise, we compute as follows.

The algorithm returns as the solution. Computing the actual solution can be done in the standard manner; to this end, we also store the corresponding value of in .

Approximation factor.

To show the approximation factor, let be the set of -shapes in . If , then we have . We now prove by induction that for all , if , then . Suppose that for all for which . Take any pair for which , and let be the index such that is the median of the -shapes in (i.e., each and contains at most -shapes). Notice that

(1)

Now, if , then we know that . Otherwise, by the induction hypothesis, we have

(2)

Similarly, if , then we know that . Otherwise, by the induction hypothesis, we have

(3)

Therefore,

The first inequality is because our algorithm tries all values of , which includes . Moreover, the second inequality is because of (3), (2) and (1). Now, if , then we are done. Otherwise,

This completes the proof of the induction step. By setting and , we have .

Running time.

For a fixed triple and , we can compute in time because the corresponding graph is an outerstring graph for which can be solved in time [23]. Since there are choices for for a fixed pair of and , and entries in the table for and , the overall running time of the algorithm is . We next show how to improve the running time to time by performing the following preprocessing. For a fixed triple and , we first compute and store the value in a table , and will then do one look-up when computing the corresponding table entry of . To this end, we first note that index is irrelevant for computing because for a fixed and , the set of -shapes is the same for all . Therefore, for all pairs , we compute using the algorithm of Keil et al. [23] and store it in . Since their algorithm takes and there are entries for , the preprocessing step takes overall time. Consequently, this improves the overall running time of computing the entries of table to and so we have the following result.

Lemma 5.1.

There exists an -time -approximation algorithm for the problem on a set of -shapes of type , where denotes the size of an optimal solution.

When the input consists of all four types of -shapes, we run the algorithm of Lemma 5.1 four times (once for each type of the input -shapes), and then return the largest solution as the final answer. Clearly, this gives us a -approximation algorithm for the original problem and so we have the main result of this section.

Theorem 5.1.

There exists an -time -approximation algorithm for the weighted problem on any set of -shapes, where denotes the size of an optimal solution.

Generalizations.

Our algorithm can be generalized in two ways: for the weighted version of the problem on -shapes, and for the weighted problem on axis-parallel rectangles.

Theorem 5.2.

There exists an -time -approximation algorithm (resp., an -time -approximation algorithm) for the weighted problem on any set of -shapes (resp., a set of axis-parallel rectangles in the plane), where is the size of an optimal solution.

Proof.

Suppose that each -shape has a weight, that is greater than or equal to 1. To apply our algorithm, we now use the “weighted” median of the -shapes in . Moreover, the algorithm of Keil et al. [23] for the problem on outerstring graphs works for weighted outerstring graphs as well. Finally, we can still compute the optimal solution for the weighted problem when for all . Hence, we have an -time -approximation algorithm for the weighted problem.

Next, we show that our algorithm can also be applied to get a -approximation algorithm for the weighted on the intersection graph of a set of axis-parallel rectangles in the plane. To see this, we sort the rectangles from left to right by the increasing order of the -coordinate of their left sides, and consider the weighted median. Moreover, we can still compute the optimal solution for the weighted problem when for all . To solve the problem on the rectangles in , notice that the intersection graph induced by the rectangles in is equivalent to the interval graph obtained by projecting each rectangle of onto the vertical line through the left side of , the th rectangle in the ordering. Hence, we can solve the weighted on the rectangles in in time (given an ordering of these rectangles). The latter improves the overall running time of the algorithm in Theorem 5.1 to because we can now compute all the entries of table in overall time. Finally, since we have only one type of input rectangles, we do not need to apply our algorithm four times in the case of rectangles and so we have a -approximation algorithm. This completes the proof of Theorem 5.2. ∎

We note that in the special case of , our algorithm improves the previously best-known approximation factor for rectangles, which is  [8].

6 Conclusion

In this paper, we studied the time-complexity and approximability of the problem on outerstring graphs and their relatives. Our work gives rise to some natural open questions:

  • Does there exist a quadratic-time algorithm that can solve the problem on grounded segment or grounded square- graphs?

  • Can we improve the approximation factor of the algorithm of Theorem 5.1?

  • Can we find an -time lower bound under SETH for finding in grounded segment representations?

References

  • [1] Pankaj K. Agarwal and Nabil H. Mustafa. Independent set of intersection graphs of convex objects in 2d. Comput. Geom., 34(2):83–95, 2006.
  • [2] Alberto Apostolico, Mikhail J. Atallah, and Susanne E. Hambrusch. New clique and independent set algorithms for circle graphs. Discrete Applied Mathematics, 36(1):1–24, 1992.
  • [3] T. Asano, H. Imai, and A. Mukaiyama. Finding a maximum weight independent set of a circle graph. IEICE Transactions, E74(4):681–683, 1991.
  • [4] Andrei Asinowski, Elad Cohen, Martin Charles Golumbic, Vincent Limouzy, Marina Lipshteyn, and Michal Stern. Vertex intersection graphs of paths on a grid. J. Graph Algorithms Appl., 16(2):129–150, 2012.
  • [5] Sayan Bandyapadhyay, Anil Maheshwari, Saeed Mehrabi, and Subhash Suri. Approximating dominating set on intersection graphs of rectangles and L-frames. In proceedings of the 43rd International Symposium on Mathematical Foundations of Computer Science (MFCS 2018), Liverpool, UK, pages 37:1–37:15, 2018.
  • [6] Therese C. Biedl and Martin Derka. Splitting B-VPG graphs into outer-string and co-comparability graphs. In proceedings of the 15th International Symposium on Algorithms and Data Structures (WADS 2017), St. John’s, NL, Canada, pages 157–168, 2017.
  • [7] Jean Cardinal, Stefan Felsner, Tillmann Miltzow, Casey Tompkins, and Birgit Vogtenhuber. Intersection graphs of rays and grounded segments. J. Graph Algorithms Appl., 22(2):273–295, 2018.
  • [8] Parinya Chalermsook and Julia Chuzhoy. Maximum independent set of rectangles. In proceedings of the 20th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2009), New York, NY, USA, pages 892–901, 2009.
  • [9] Jérémie Chalopin and Daniel Gonçalves. Every planar graph is the intersection graph of segments in the plane: extended abstract. In

    proceedings of the 41st Annual ACM Symposium on Theory of Computing (STOC 2009), Bethesda, MD, USA

    , pages 631–638, 2009.
  • [10] Timothy M. Chan and Sariel Har-Peled. Approximation algorithms for maximum independent set of pseudo-disks. Discrete & Computational Geometry, 48(2):373–392, 2012.
  • [11] Steven Chaplick, Vít Jelínek, Jan Kratochvíl, and Tomás Vyskocil. Bend-bounded path intersection graphs: Sausages, noodles, and waffles on a grill. In proceedings of the 38th International Workshop on Graph-Theoretic Concepts in Computer Science (WG 2012), Jerusalem, Israel, pages 274–285, 2012.
  • [12] Gideon Ehrlich, Shimon Even, and Robert Endre Tarjan. Intersection graphs of curves in the plane. J. Comb. Theory, Ser. B, 21(1):8–20, 1976.
  • [13] Thomas Erlebach, Klaus Jansen, and Eike Seidel. Polynomial-time approximation schemes for geometric intersection graphs. SIAM J. Comput., 34(6):1302–1323, 2005.
  • [14] Stefan Felsner, Kolja B. Knauer, George B. Mertzios, and Torsten Ueckerdt. Intersection graphs of L-shapes and segments in the plane. Discrete Applied Mathematics, 206:48–55, 2016.
  • [15] Jacob Fox and János Pach. Computing the independence number of intersection graphs. In proceedings of the 22nd Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2011), San Francisco, CA, USA, pages 1161–1165, 2011.
  • [16] András Frank. Some polynomial algorithms for certain graphs and hypergraphs. In proceedings of the 5th British Combinatorial Conference, 1975.
  • [17] Fanica Gavril. Algorithms for a maximum clique and a maximum independent set of a circle graph. Networks, 3:261–273, 1973.
  • [18] Martin C. Golumbic. Algorithmic Graph Theory and Perfect Graphs, volume vol. 57. in: Annals of Discrete Mathematics, North-Holland, Amsterdam, 2nd edition edition, 2004.
  • [19] Daniel Gonçalves, Lucas Isenmann, and Claire Pennarun. Planar graphs as L-intersection or L-contact graphs. In proceedings of the 29th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2018), New Orleans, LA, USA, pages 172–184, 2018.
  • [20] Johan Håstad. Clique is hard to approximate within . In proceedings of the 37th Annual Symposium on Foundations of Computer Science (FOCS 1996), Burlington, Vermont, USA, pages 627–636, 1996.
  • [21] Russell Impagliazzo, Ramamohan Paturi, and Francis Zane. Which problems have strongly exponential complexity? J. Comput. Syst. Sci., 63(4):512–530, 2001.
  • [22] Vít Jelínek and Martin Töpfer. On grounded L-graphs and their relatives. CoRR, abs/1808.04148, 2018.
  • [23] J. Mark Keil, Joseph S. B. Mitchell, Dinabandhu Pradhan, and Martin Vatshelle. An algorithm for the maximum weight independent set problem on outerstring graphs. Comput. Geom., 60:19–25, 2017.
  • [24] Jan Kratochvíl. String graphs. I. the number of critical nonstring graphs is infinite. J. Comb. Theory, Ser. B, 52(1):53–66, 1991.
  • [25] Abhiruk Lahiri, Joydeep Mukherjee, and C. R. Subramanian. Maximum independent set on B-VPG graphs. In

    proceedings of the 9th International Conference Combinatorial Optimization and Applications (COCOA 2015), Houston, TX, USA

    , pages 633–646, 2015.
  • [26] Vincent Limouzy. Seidel minor, permutation graphs and combinatorial properties. In proceedings of the 21st International Symposium on Algorithms and Computation (ISAAC 2010), pages 194–205, 2010.
  • [27] Saeed Mehrabi. Approximating domination on intersection graphs of paths on a grid. In proceedings of the 15th International Workshop on Approximation and Online Algorithms (WAOA 2017), Vienna, Austria, pages 76–89, 2017.
  • [28] Saeed Mehrabi. Approximation algorithms for independence and domination on B-VPG and B-EPG graphs. CoRR, abs/1702.05633, 2017.
  • [29] Matthias Middendorf and Frank Pfeiffer. Weakly transitive orientations, Hasse diagrams and string graphs. Discrete Mathematics, 111(1-3):393–400, 1993.
  • [30] Nicholas Nash and David Gregg. An output sensitive algorithm for computing a maximum independent set of a circle graph. Inf. Process. Lett., 110(16):630–634, 2010.
  • [31] Edward R. Scheinerman. Intersection Classes and Multiple Intersection Parameters of Graphs. PhD thesis, Princeton University, 1984.
  • [32] K. J. Supowit. Finding a maximum planar subset of a set of nets in a channel. IEEE Trans. on CAD of Integrated Circuits and Systems, 6(1):93–94, 1987.
  • [33] Gabriel Valiente. A new simple algorithm for the maximum-weight independent set problem on circle graphs. In proceedings of the 14th International Symposium on Algorithms and Computation (ISAAC 2003), Kyoto, Japan, pages 129–137, 2003.