418 research outputs found

    A Polynomial-time Bicriteria Approximation Scheme for Planar Bisection

    Full text link
    Given an undirected graph with edge costs and node weights, the minimum bisection problem asks for a partition of the nodes into two parts of equal weight such that the sum of edge costs between the parts is minimized. We give a polynomial time bicriteria approximation scheme for bisection on planar graphs. Specifically, let WW be the total weight of all nodes in a planar graph GG. For any constant ε>0\varepsilon > 0, our algorithm outputs a bipartition of the nodes such that each part weighs at most W/2+εW/2 + \varepsilon and the total cost of edges crossing the partition is at most (1+ε)(1+\varepsilon) times the total cost of the optimal bisection. The previously best known approximation for planar minimum bisection, even with unit node weights, was O(logn)O(\log n). Our algorithm actually solves a more general problem where the input may include a target weight for the smaller side of the bipartition.Comment: To appear in STOC 201

    Travelling on Graphs with Small Highway Dimension

    Get PDF
    We study the Travelling Salesperson (TSP) and the Steiner Tree problem (STP) in graphs of low highway dimension. This graph parameter was introduced by Abraham et al. [SODA 2010] as a model for transportation networks, on which TSP and STP naturally occur for various applications in logistics. It was previously shown [Feldmann et al. ICALP 2015] that these problems admit a quasi-polynomial time approximation scheme (QPTAS) on graphs of constant highway dimension. We demonstrate that a significant improvement is possible in the special case when the highway dimension is 1, for which we present a fully-polynomial time approximation scheme (FPTAS). We also prove that STP is weakly NP-hard for these restricted graphs. For TSP we show NP-hardness for graphs of highway dimension 6, which answers an open problem posed in [Feldmann et al. ICALP 2015]

    Engineering an Approximation Scheme for Traveling Salesman in Planar Graphs

    Get PDF
    We present an implementation of a linear-time approximation scheme for the traveling salesman problem on planar graphs with edge weights. We observe that the theoretical algorithm involves constants that are too large for practical use. Our implementation, which is not subject to the theoretical algorithm\u27s guarantee, can quickly find good tours in very large planar graphs

    Parameterized Approximation Algorithms for Bidirected Steiner Network Problems

    Get PDF
    The Directed Steiner Network (DSN) problem takes as input a directed edge-weighted graph G=(V,E)G=(V,E) and a set DV×V\mathcal{D}\subseteq V\times V of kk demand pairs. The aim is to compute the cheapest network NGN\subseteq G for which there is an sts\to t path for each (s,t)D(s,t)\in\mathcal{D}. It is known that this problem is notoriously hard as there is no k1/4o(1)k^{1/4-o(1)}-approximation algorithm under Gap-ETH, even when parametrizing the runtime by kk [Dinur & Manurangsi, ITCS 2018]. In light of this, we systematically study several special cases of DSN and determine their parameterized approximability for the parameter kk. For the bi-DSNPlanar_\text{Planar} problem, the aim is to compute a planar optimum solution NGN\subseteq G in a bidirected graph GG, i.e., for every edge uvuv of GG the reverse edge vuvu exists and has the same weight. This problem is a generalization of several well-studied special cases. Our main result is that this problem admits a parameterized approximation scheme (PAS) for kk. We also prove that our result is tight in the sense that (a) the runtime of our PAS cannot be significantly improved, and (b) it is unlikely that a PAS exists for any generalization of bi-DSNPlanar_\text{Planar}, unless FPT=W[1]. One important special case of DSN is the Strongly Connected Steiner Subgraph (SCSS) problem, for which the solution network NGN\subseteq G needs to strongly connect a given set of kk terminals. It has been observed before that for SCSS a parameterized 22-approximation exists when parameterized by kk [Chitnis et al., IPEC 2013]. We give a tight inapproximability result by showing that for kk no parameterized (2ε)(2-\varepsilon)-approximation algorithm exists under Gap-ETH. Additionally we show that when restricting the input of SCSS to bidirected graphs, the problem remains NP-hard but becomes FPT for kk

    Linear-Space Approximate Distance Oracles for Planar, Bounded-Genus, and Minor-Free Graphs

    Full text link
    A (1 + eps)-approximate distance oracle for a graph is a data structure that supports approximate point-to-point shortest-path-distance queries. The most relevant measures for a distance-oracle construction are: space, query time, and preprocessing time. There are strong distance-oracle constructions known for planar graphs (Thorup, JACM'04) and, subsequently, minor-excluded graphs (Abraham and Gavoille, PODC'06). However, these require Omega(eps^{-1} n lg n) space for n-node graphs. We argue that a very low space requirement is essential. Since modern computer architectures involve hierarchical memory (caches, primary memory, secondary memory), a high memory requirement in effect may greatly increase the actual running time. Moreover, we would like data structures that can be deployed on small mobile devices, such as handhelds, which have relatively small primary memory. In this paper, for planar graphs, bounded-genus graphs, and minor-excluded graphs we give distance-oracle constructions that require only O(n) space. The big O hides only a fixed constant, independent of \epsilon and independent of genus or size of an excluded minor. The preprocessing times for our distance oracle are also faster than those for the previously known constructions. For planar graphs, the preprocessing time is O(n lg^2 n). However, our constructions have slower query times. For planar graphs, the query time is O(eps^{-2} lg^2 n). For our linear-space results, we can in fact ensure, for any delta > 0, that the space required is only 1 + delta times the space required just to represent the graph itself
    corecore