We consider the Vertex Cover problem in intersection graphs of axis-parallel rectangles on the plane. We present two algorithms: The first is an EPTAS for non-crossing rectangle families, rectangle families @math where @math is connected for every pair of rectangles @math . This algorithm extends to intersection graphs of pseudo-disks. The second algorithm achieves a factor of @math in general rectangle families, for any fixed @math , and works also for the weighted variant of the problem. Both algorithms exploit the plane properties of axis-parallel rectangles in a non-trivial way.
, and its dual counterpart , have been previously studied in many geometric intersection graphs other than rectangle graphs. Gavril @cite_16 gave a polynomial-time algorithm for both of these problem in chordal graphs, intersection graphs of subgraphs of a tree. Apostolico @cite_20 gave a polynomial-time algorithm for these two problems in intersection graphs of chords on a circle, which were later improved by Cenek and Stuart @cite_28 , while Golumbic and Hammer @cite_0 gave a polynomial-time algorithm for intersection graphs of arcs on a circle which was later improved in @cite_9 . A good survey of many generalizations of these results can be found in @cite_46 @cite_17 . Hochbaum and Maass and later Chleb ' k and Chleb ' i kov ' a considered intersection graphs of @math -dimensional boxes in @math @cite_33 @cite_26 , while Erlebach @cite_5 considered intersection graphs of general fat objects in the plane. @cite_4 @cite_8 , approximation algorithms were suggested for and in the class of multiple-interval graphs.
@cite_26 @cite_4 @cite_33 @cite_8 @cite_28 @cite_9 @cite_0 @cite_5 @cite_46 @cite_16 @cite_20 @cite_17
2012427196 1976676339 2569784685 2084266654 2170546552 2151239055 1968027460 2726678275 1968429800 2156756707 2004779317 128419235
The intersection graph of a set of geometric objects is defined as a graph G = (S, E) in which there is an edge between two nodes si, sj ∈ S if si ∩ sj ≠ 0. The problem of computing a maximum independent set in the intersection graph of a set of objects is known to be NP-complete for most cases in two and higher dimensions. We present approximation algorithms for computing a maximum independent set of intersection graphs of convex objects in R2. Specifically, given (i) a set of n line segments in the plane with maximum independent set of size α, we present algorithms that find an independent set of size at least (α (2 log(2n α)))1 2 in time O(n3) and (α (2log(2n α)))1 4 in time O(n4 3 logcn), (ii) a set of n convex objects with maximum independent set of size α, we present an algorithm that finds an independent set of size at least (α (2log(2n α)))1 3 in time O(n3 + τ (S)), assuming that S can be preprocessed in time τ(S) to answer certain primitive operations on these convex sets, and (iii) a set of n rectangles with maximum independent set of size βn, for β≤ 1, we present an algorithm that computes an independent set of size Ω (β2n). All our algorithms use the notion of partial orders that exploit the geometric structure of the convex objects. In this paper, we show that many graph search problems can be solved quite efficiently for a geometric intersection graph of horizontal and vertical line segments. We first extract several basic operations for depth first search and breadth first search on a graph. Then we present data structures for the intersection graph in terms of which those operations can be implemented in an efficient manner. The data structures enable us to solve various graph search problems besides depth first search and breadth first search. Specifying the results obtained in this paper for an intersection graph of n horizontal and vertical segments with m pairs of intersecting segments, we obtain algorithms with the following complexity, where @math . (i) Depth first search and breadth first search can be executed in @math time and @math space. (ii) The biconnected components can be found in @math time and @math space. (iii) A maximum matching and a maximum independent set can be found in $O... Abstract In this paper we continue the study of the edge intersection graphs of single bend paths on a rectangular grid (i.e., the edge intersection graphs where each vertex is represented by one of the following shapes: ⌞ , ⌜ , ⌟ , ⌝ ). These graphs, called B 1 - EPG graphs, were first introduced by (2009) [Golumbic, M. C., M. Lipshteyn and M. Stern, Edge intersection graphs of single bend paths on a grid , Networks 54 :3 (2009), 130–138]. We focus on the class [⌞] (the edge intersection graphs of ⌞-shapes) and show that testing for membership in [⌞] is NP-complete. We then give a characterization and polytime recognition algorithm for special subclasses of Split ∩ [ ⌞ ] . We also consider the natural subclasses of B 1 -EPG formed by the subsets of the four single bend shapes (i.e., ⌞ , ⌞ , ⌜ , ⌞ , ⌝ , ⌞ , ⌜ , ⌝ – note: all other subsets are isomorphic to these up to 90 degree rotation). We observe the expected strict inclusions and incomparability (i.e., [ ⌞ ] ⊊ [ ⌞ , ⌜ ] , [ ⌞ , ⌝ ] ⊊ [ ⌞ , ⌜ , ⌝ ] ⊊ B 1 -EPG and [ ⌞ , ⌜ ] is incomparable with [ ⌞ , ⌝ ] ). Computing the maximum number of disjoint elements in a collection C of geometric objects is a classical problem in computational geometry with applications ranging from frequency assignment in cellular networks to map labeling in computational cartography. The problem is equivalent to finding the independence number, α(GC), of the intersection graph GC of C, obtained by connecting two elements of C with an edge if and only if their intersection is nonempty. This is known to be an NP-hard task even for systems of segments in the plane with at most two different slopes. The best known polynomial time approximation algorithm for systems of arbitrary segments is due to Agarwal and Mustafa, and returns in the worst case an n1 2+o(1)-approximation for α. Using extensions of the Lipton-Tarjan separator theorem, we improve this result and present, for every e > 0, a polynomial time algorithm for computing α(GC) with approximation ratio at most ne. In contrast, for general graphs, for any e > 0 it is NP-hard to approximate the independence number within a factor of n1−e. We also give a subexponential time exact algorithm for computing the independence number of intersection graphs of arcwise connected sets in the plane. Mulmuley [Mul12a] recently gave an explicit version of Noether’s Normalization lemma for ring of invariants of matrices under simultaneous conjugation, under the conjecture that there are deterministic black-box algorithms for polynomial identity testing (PIT). He argued that this gives evidence that constructing such algorithms for PIT is beyond current techniques. In this work, we show this is not the case. That is, we improve Mulmuley’s reduction and correspondingly weaken the conjecture regarding PIT needed to give explicit Noether Normalization. We then observe that the weaker conjecture has recently been nearly settled by the authors ([FS12]), who gave quasipolynomial size hitting sets for the class of read-once oblivious algebraic branching programs (ROABPs). This gives the desired explicit Noether Normalization unconditionally, up to quasipolynomial factors. As a consequence of our proof we give a deterministic parallel polynomial-time algorithm for deciding if two matrix tuples have intersecting orbit closures, under simultaneous conjugation. We also study the strength of conjectures that Mulmuley requires to obtain similar results as ours. We prove that his conjectures are stronger, in the sense that the computational model he needs PIT algorithms for is equivalent to the well-known algebraic branching program (ABP) model, which is provably stronger than the ROABP model. Finally, we consider the depth-3 diagonal circuit model as defined by Saxena [Sax08], as PIT algorithms for this model also have implications in Mulmuley’s work. Previous work (such as [ASS12] and [FS12]) have given quasipolynomial size hitting sets for this model. In this work, we give a much simpler construction of such hitting sets, using techniques of Shpilka and Volkovich [SV09]. Given an arc-weighted directed graph G = (V, A, spl lscr ) and a pair of nodes s, t, we seek to find an s-t walk of length at most B that maximizes some given function f of the set of nodes visited by the walk. The simplest case is when we seek to maximize the number of nodes visited: this is called the orienteering problem. Our main result is a quasi-polynomial time algorithm that yields an O(log OPT) approximation for this problem when f is a given submodular set function. We then extend it to the case when a node v is counted as visited only if the walk reaches v in its time window [R(v), D(v)]. We apply the algorithm to obtain several new results. First, we obtain an O(log OPT) approximation for a generalization of the orienteering problem in which the profit for visiting each node may vary arbitrarily with time. This captures the time window problem considered earlier for which, even in undirected graphs, the best approximation ratio known [Bansal, (2004)] is O(log sup 2 OPT). The second application is an O(log sup 2 k) approximation for the k-TSP problem in directed graphs (satisfying asymmetric triangle inequality). This is the first non-trivial approximation algorithm for this problem. The third application is an O(log sup 2 k) approximation (in quasi-poly time) for the group Steiner problem in undirected graphs where k is the number of groups. This improves earlier ratios (Garg, ) by a logarithmic factor and almost matches the inapproximability threshold on trees (Halperin and Krauthgamer, 2003). This connection to group Steiner trees also enables us to prove that the problem we consider is hard to approximate to a ratio better than spl Omega (log sup 1- spl epsi OPT), even in undirected graphs. Even though our algorithm runs in quasi-poly time, we believe that the implications for the approximability of several basic optimization problems are interesting. We give polynomial time algorithms for the maximum independent set and maximum clique problems for classes of overlap graphs, assuming an overlap model is provided as input. The independent set algorithm applies to any class of overlap graphs for which the maximum weight independent set problem is polynomially solvable on the corresponding intersection graph class, where the vertex weights are nonnegative integers on which arithmetic operations can be performed in constant time. The maximum clique algorithm requires only that the overlap model satisfy the Helly property. In both cases, the size of the overlap model must be bounded by a polynomial in the size of the graph. The conditions for both algorithms are satisfied by the class of overlap graphs of subtrees in a tree, which contains chordal graphs, circle graphs, circular-arc graphs, cocomparability graphs, and polygon-circle graphs. We continue research into a well-studied family of problems that ask if the vertices of a graph can be partitioned into sets A and B, where A is an independent set and B induces a graph from some specified graph class G. We let G be the class of k-degenerate graphs. The problem is known to be polynomial-time solvable if k=0 (bipartite graphs) and NP-complete if k=1 (near-bipartite graphs) even for graphs of diameter 4, as shown by Yang and Yuan, who also proved polynomial-time solvability for graphs of diameter 2. We show that recognizing near-bipartite graphs of diameter 3 is NP-complete resolving their open problem. To answer another open problem, we consider graphs of maximum degree D on n vertices. We show how to find A and B in O(n) time for k=1 and D=3, and in O(n^2) time for k >= 2 and D >= 4. These results also provide an algorithmic version of a result of Catlin [JCTB, 1979] and enable us to complete the complexity classification of another problem: finding a path in the vertex colouring reconfiguration graph between two given k-colourings of a graph of bounded maximum degree. We study the quantitative geometry of graphs in terms of their genus, using the structure of certain "cut graphs," i.e. subgraphs whose removal leaves a planar graph. In particular, we give optimal bounds for random partitioning schemes, as well as various types of embeddings. Using these geometric primitives, we present exponentially improved dependence on genus for a number of problems like approximate max-flow min-cut theorems, approximations for uniform and nonuniform Sparsest Cut, treewidth approximation, Laplacian eigenvalue bounds, and Lipschitz extension theorems and related metric labeling problems. We list here a sample of these improvements. All the following statements refer to graphs of genus g, unless otherwise noted. • We show that such graphs admit an O(log g)-approximate multi-commodity max-flow min-cut theorem for the case of uniform demands. This bound is optimal, and improves over the previous bound of O(g) [KPR93, FT03]. For general demands, we show that the worst possible gap is O(log g + CP), where CP is the gap for planar graphs. This dependence is optimal, and already yields a bound of O(log g + √log n), improving over the previous bound of O(√g log n) [KLMN04]. • We give an O(√log g)-approximation for the uniform Sparsest Cut, balanced vertex separator, and treewidth problems, improving over the previous bound of O(g) [FHL05]. • If a graph G has genus g and maximum degree D, we show that the kth Laplacian eigenvalue of G is (log g)2 · O(kgD n), improving over the previous bound of g2·O(kgD n) [KLPT09]. There is a lower bound of Ω(kgD n), making this result almost tight. • We show that if (X, d) is the shortest-path metric on a graph of genus g and S ⊆ X, then every L-Lipschitz map f: S → Z into a Banach space Z admits an O(L log g)-Lipschitz extension f: X → Z. This improves over the previous bound of O(Lg) [LN05], and compares to a lower bound of Ω(L√log g). In a related way, we show that there is an O(log g)-approximation for the 0-extension problem on such graphs, improving over the previous O(g) bound. • We show that every n-vertex shortest-path metric on a graph of genus g embeds into L2 with distortion O(log g + √log n), improving over the previous bound of O(√g log n). Our result is asymptotically optimal for every dependence g = g(n). There are several successful systems that provide algorithms that allow for the intersection of polygonal objects or other primitive shapes to create more complex objects. Our intent is to provide similar algorithms for intersecting surface patches. There have been contributions to this concept at the display algorithm level, that is, computing the intersection at the time the frame is generated. In an animation environment, however, it becomes important to incorporate the intersection in the data generation routines, in order that those parts of the intersected object that never contribute to an image are not processed by the display algorithm. This only increases the complexity of the object unnecessarily, and subsequently puts an additional burden on the display algorithms. An algorithm is described which uses a modified Catmull recursive subdivision scheme to find the space curve which is the intersection of two bicubic patches. An associated data structure is discussed which incorporates this curve of intersection in the patch description in a way suitable for efficient display of the intersected object. Sample output of these intersections are shown which serve to illustrate the capabilities and limitations of the described procedures. For a graph G and a collection of vertex pairs (s"1,t"1),...,(s"k,t"k) , the k disjoint paths problem is to find k vertex-disjoint paths P"1,...,P"k, where P"i is a path from s"i to t"i for each i=1,...,k. In the corresponding optimization problem, the shortest disjoint paths problem, the vertex-disjoint paths P"i have to be chosen such that a given objective function is minimized. We consider two different objectives, namely minimizing the total path length (minimum sum, or short: Min-Sum), and minimizing the length of the longest path (Min-Max), for k=2,3. Min-Sum: We extend recent results by Colin de Verdiere and Schrijver to prove that, for a planar graph and for terminals adjacent to at most two faces, the Min-Sum 2 Disjoint Paths Problem can be solved in polynomial time. We also prove that, for six terminals adjacent to one face in any order, the Min-Sum 3 Disjoint Paths Problem can be solved in polynomial time. Min-Max: The Min-Max 2 Disjoint Paths Problem is known to be NP-hard for general graphs. We present an algorithm that solves the problem for graphs with tree-width 2 in polynomial time. We thus close the gap between easy and hard instances, since the problem is weakly NP-hard for graphs with tree-width 3. Given n orthogonal line segments on the plane, their intersection graph is defined such that each vertex corresponds to a segment, and each edge corresponds to a pair of intersecting segments. Although this graph can have Θ(n2) edges, we show that breadth first search can be accomplished in O(nlogn) time and O(n) space. As an application, we show that the minimum link rectilinear path between two points s and t amidst rectilinear polygonal obstacles can be computed in O(nlogn) time and O(n) space, which is optimal. We mention other related results in the paper.