Algorithm For Planar Graphs Research Articles

Clique Transversal Variants on Graphs: A Parameterized-Complexity Perspective

The clique transversal problem and its variants have garnered significant attention in the last two decades due to their practical applications in communication networks, social-network theory and transceiver placement for cellular telephones. While previous research primarily focused on determining the polynomial-time solvability or NP-hardness/NP-completeness of specific graphs, this paper adopts a parameterized-complexity approach. It thoroughly explores four clique transversal variants: the d-fold transversal problem, the {d}-clique transversal problem, the signed clique transversal problem and the minus clique transversal problem. The paper presents various findings regarding the parameterized complexity of the clique transversal problem and its variants. It establishes the W[2]-completeness and para-NP-completeness of the d-fold transversal problem, the {d}-clique transversal problem, the signed clique transversal problem and the minus clique transversal problem within specific graph classes. Additionally, it introduces fixed-parameter tractable algorithms for planar graphs and graphs with bounded treewidth, offering efficient solutions for these specific instances of the problems. The research further explores the relationship between planar graphs and graphs with bounded treewidth to enhance the time complexity of the d-fold clique transversal problem and the {d}-clique transversal problem. By analyzing the parameterized complexity of the clique transversal problem and its variants, this research contributes to our understanding of the computational limitations and potentially efficient algorithms for solving these problems.

On computing the Hamiltonian index of graphs

For an integer r≥0 the r-th iterated line graphLr(G) of a graph G is defined by: (i) L0(G)=G and (ii) Lr(G)=L(L(r−1)(G)) for r>0, where L(G) denotes the line graph of G. The Hamiltonian Indexh(G) of G is the smallest r such that Lr(G) has a Hamiltonian cycle [Chartrand, 1968]. Checking if h(G)=k is NP-hard for any fixed integer k≥0 even for subcubic graphs G [Ryjáček et al., 2011]. We study the parameterized complexity of this problem with the parameter treewidth, tw(G), and show that we can find h(G) in time1O⋆((1+2(ω+3))tw(G)) where ω is the matrix multiplication exponent. Prior work on computing h(G) includes various O⋆(2O(tw(G)))-time algorithms for checking if h(G)=0 holds; i.e., whether G has a Hamiltonian Cycle [Cygan et al., FOCS 2011; Bodlaender et al., Inform. Comput., 2015; Fomin et al., JACM 2016]; an O⋆(tw(G)O(tw(G)))-time algorithm for checking if h(G)=1 holds; i.e., whether L(G) has a Hamiltonian Cycle [Lampis et al., Discrete Appl. Math., 2017]; and, most recently, an O⋆((1+2(ω+3))tw(G))-time algorithm for checking if h(G)=1 holds [Misra et al., CSR 2019]. Our algorithm for computing h(G) generalizes these results.The NP-hard Eulerian Steiner Subgraph problem takes as input a graph G and a specified subset K of terminal vertices of G and asks if G has an Eulerian2 subgraph H containing all the terminals. A key ingredient of our algorithm for finding h(G) is an algorithm which solves Eulerian Steiner Subgraph in O⋆((1+2(ω+3))tw(G)) time. To the best of our knowledge this is the first FPT algorithm for Eulerian Steiner Subgraph. Prior work on the special case of finding a spanning Eulerian subgraph (i.e., with K=V(G)) includes a polynomial-time algorithm for series-parallel graphs [Richey et al., 1985] and an O⋆(2O(n))-time algorithm for planar graphs on n vertices [Sau and Thilikos, 2010]. Our algorithm for Eulerian Steiner Subgraph generalizes both these results.

Faster shortest paths in dense distance graphs, with applications

We show how to combine two techniques for efficiently computing shortest paths in directed planar graphs. The first is the linear-time shortest-path algorithm of Henzinger, Klein, Subramanian, and Rao [STOC'94]. The second is Fakcharoenphol and Rao's algorithm [FOCS'01] for emulating Dijkstra's algorithm on the dense distance graph (DDG). A DDG is defined for a decomposition of a planar graph G into regions of at most r vertices each, for some parameter r<n. The vertex set of the DDG is the set of Θ(nr−1/2) vertices of G that belong to more than one region (boundary vertices). The DDG has Θ(n) arcs, such that distances in the DDG are equal to the distances in G. Fakcharoenphol and Rao's implementation of Dijkstra's algorithm on the DDG (nicknamed FR-Dijkstra) runs in O(nlog⁡(n)r−1/2log⁡r) time, and is a key component in many state-of-the-art planar graph algorithms for shortest paths, minimum cuts, and maximum flows. By combining these two techniques we remove the log⁡n dependency in the running time of the shortest-path algorithm at the price of an additional log⁡r factor, making it O(nr−1/2log2⁡r).This work is part of a research agenda that aims to develop new techniques that would lead to faster, possibly linear-time, algorithms for problems in planar graphs such as minimum-cut, maximum-flow, and shortest paths with negative arc lengths. As immediate applications, we show how to compute maximum flow in directed weighted planar graphs in O(nlog⁡p) time, and minimum st-cut in undirected weighted planar graphs in O(nlog⁡log⁡p) time, where p is the minimum number of edges on any path from the source to the sink. We also show how to compute any part of the DDG that corresponds to a region with r vertices and k boundary vertices in O(rlog⁡k) time, which is faster than has been previously known for small values of k.

Submatrix Maximum Queries in Monge Matrices and Partial Monge Matrices, and Their Applications

We describe a data structure for submatrix maximum queries in Monge matrices or partial Monge matrices, where a query seeks the maximum element in a contiguous submatrix of the given matrix. The structure, for an n × n Monge matrix, takes O ( n log n ) space and O ( n log n ) preprocessing time, and answers queries in O (log 2 n ) time. For partial Monge matrices, the space grows by α( n ), the preprocessing grows by α( n )log n (α( n ) is the inverse Ackermann function), and the query remains O (log 2 n ). Our design exploits an interpretation of the column maxima in a Monge (partial Monge, respectively) matrix as an upper envelope of pseudo-lines (pseudo-segments, respectively). We give two applications: (1) For a planar set of n points in an axis-parallel rectangle B , we build a data structure, in O ( n α( n )log 4 n ) time and O ( n α( n )log 3 n ) space, that returns, for a query point p , the largest-area empty axis-parallel rectangle contained in B and containing p , in O (log 4 n ) time. This improves substantially the nearly quadratic storage and preprocessing obtained by Augustine et al. [2010]. (2) Given an n -node arbitrarily weighted planar digraph, with possibly negative edge weights, we build, in O ( n log 2 n /log log n ) time, a linear-size data structure that supports edge-weight updates and graph-distance queries between arbitrary pairs of nodes in O ( n 2/3 log 5/3 n ) time per operation. This improves a previous algorithm of Fakcharoenphol and Rao [2006]. Our data structure has already been applied in a recent maximum flow algorithm for planar graphs in Borradaile et al. [2011].

The Parameterized Complexity of Graph Cyclability

The cyclability of a graph is the maximum integer k for which every k vertices lie on a cycle. The algorithmic version of the problem, given a graph G and a non-negative integer k, decide whether the cyclability of G is at least k, is NP-hard. We prove that this problem, parameterized by k, is co−W[1]-hard. We give an FPT algorithm for planar graphs that runs in time \(2^{2^{O(k^2\log k)}}\cdot n^2\). Our algorithm is based on a series of graph theoretical results on cyclic linkages in planar graphs.

Short and Simple Cycle Separators in Planar Graphs

We provide an implementation of an algorithm that, given a triangulated planar graph with m edges, returns a simple cycle that is a 3/4-balanced separator consisting of at most √8 m edges. An efficient construction of a short and balanced separator that forms a simple cycle is essential in numerous planar graph algorithms, for example, for computing shortest paths, minimum cuts, or maximum flows. To the best of our knowledge, this is the first implementation of such a cycle separator algorithm with a worst-case guarantee on the cycle length. We evaluate the performance of our algorithm and compare it to the planar separator algorithms recently studied by Holzer et al. [2009]. Out of these algorithms, only the Fundamental Cycle Separator (FCS) produces a simple cycle separator. However, FCS does not provide a worst-case size guarantee. We demonstrate that (1) our algorithm is competitive across all test cases in terms of running time, balance, and cycle length; (2) it provides worst-case guarantees on the cycle length, significantly outperforming FCS on some instances; and (3) it scales to large graphs.

On the Advice Complexity of the k-server Problem Under Sparse Metrics

We consider the k-Server problem under the advice model of computation when the underlying metric space is sparse. On one side, we introduce ź(1)-competitive algorithms for a wide range of sparse graphs. These algorithms require advice of (almost) linear size. We show that for graphs of size N and treewidth ź, there is an online algorithm that receives O (n(log ź + log log N))* bits of advice and optimally serves any sequence of length n. We also prove that if a graph admits a system of μ collective tree (q, r)-spanners, then there is a (q + r)-competitive algorithm which requires O (n(log μ + log log N)) bits of advice. Among other results, this gives a 3-competitive algorithm for planar graphs, when provided with O (n log log N) bits of advice. On the other side, we prove that advice of size Ω(n) is required to obtain a 1-competitive algorithm for sequences of length n even for the 2-server problem on a path metric of size N ź 3. Through another lower bound argument, we show that at least n2(logźź1.22)$\frac {n}{2}(\log \alpha - 1.22)$ bits of advice is required to obtain an optimal solution for metric spaces of treewidth ź, where 4 ≤ ź < 2k.

The Min-Max Edge q-Coloring Problem

In this paper we introduce and study a new problem named min-max edge q-coloring which is motivated by applications in wireless mesh networks. The input of the problem consists of an undirected graph and an integer q. The goal is to color the edges of the graph with as many colors as possible such that: (a) any vertex is incident to at most q different colors, and (b) the maximum size of a color group (i.e. set of edges identically colored) is minimized. We show the following results: Min-max edge q-coloring is NP-hard, for any q ≥ 2. A polynomial time exact algorithm for min-max edge q-coloring on trees. Exact formulas of the optimal solution for cliques and almost tight bounds for bicliques and hypergraphs. A non-trivial lower bound of the optimal solution with respect to the average degree of the graph. An approximation algorithm for planar graphs.

TOWARDS MORE EFFICIENT INFECTION AND FIRE FIGHTING

The firefighter problem models the situation where an infection, a computer virus, an idea or fire etc. is spreading through a network and the goal is to save as many as possible nodes of the network through targeted vaccinations. The number of nodes that can be vaccinated at a single time-step is typically one, or more generally O(1). In a non-standard model, the so called spreading model, the vaccinations also spread in contrast to the standard model. Our main results are concerned with general graphs in the spreading model. We provide a very simple exact [Formula: see text]-time algorithm. In the special case of trees, where the standard and spreading model are equivalent, our algorithm is substantially simpler than that exact subexponential algorithm for trees presented in Ref. 2. On the other hand, we show that the firefighter problem on weighted directed graphs in the spreading model cannot be approximated within a constant factor better than 1 − 1/e unless NP ⊆ DTIME (nO( log log n)). We also present several results in the standard model. We provide approximation algorithms for planar graphs in case when at least two vaccinations can be performed at a time-step. We also derive trade-offs between approximation factors for polynomial-time solutions and the time complexity of exact or nearly exact solutions for instances of the firefighter problem for the so called directed layered graphs.

Comparison of Swendsen‐Wang and heat‐bath dynamics

AbstractWe prove that the spectral gap of the Swendsen‐Wang process for the Potts model on graphs with bounded degree is bounded from below by some constant times the spectral gap of any single‐spin dynamics. This implies rapid mixing for the two‐dimensional Potts model at all temperatures above the critical one, as well as rapid mixing at the critical temperature for the Ising model. After this we introduce a modified version of the Swendsen‐Wang algorithm for planar graphs and prove rapid mixing for the two‐dimensional Potts models at all non‐critical temperatures. © 2012 Wiley Periodicals, Inc. Random Struct. Alg., 42, 520–535, 2013

Improved Bounds on the Planar Branchwidth with Respect to the Largest Grid Minor Size

For graph G, let bw(G) denote the branchwidth of G and gm(G) the largest integer g such that G contains a g×g grid as a minor. We show that bw(G)≤3 gm(G) for every planar graph G. This is an improvement over the bound bw(G)≤4 gm(G) due to Robertson, Seymour and Thomas. Our proof is constructive and implies quadratic time constant-factor approximation algorithms for planar graphs for both problems of finding a largest grid minor and of finding an optimal branch-decomposition: (3+ϵ)-approximation for the former and (2+ϵ)-approximation for the latter, where ϵ is an arbitrary positive constant. We also study the tightness of the above bound. We show that for any constant c<2, the bound of ${\mathop {\mathrm {bw}}}(G)\leq c\; {\mathop {\mathrm {gm}}}(G) + o({\mathop {\mathrm {gm}}}(G))$ does not hold in general for a planar graph G.

Approximation Algorithms and Hardness Results for Packing Element-Disjoint Steiner Trees in Planar Graphs

We study the problem of packing element-disjoint Steiner trees in graphs. We are given a graph and a designated subset of terminal nodes, and the goal is to find a maximum cardinality set of element-disjoint trees such that each tree contains every terminal node. An element means a non-terminal node or an edge. (Thus, each non-terminal node and each edge must be in at most one of the trees.) We show that the problem is APX-hard when there are only three terminal nodes, thus answering an open question. Our main focus is on the special case when the graph is planar. We show that the problem of finding two element-disjoint Steiner trees in a planar graph is NP-hard. Similarly, the problem of finding two edge-disjoint Steiner trees in a planar graph is NP-hard. We design an algorithm for planar graphs that achieves an approximation guarantee close to 2. In fact, given a planar graph that is k element-connected on the terminals (k is an upper bound on the number of element-disjoint Steiner trees), the algorithm returns $\lfloor\frac{k}{2} \rfloor-1$ element-disjoint Steiner trees. Using this algorithm, we get an approximation algorithm for the edge-disjoint version of the problem on planar graphs that improves on the previous approximation guarantees. We also show that the natural LP relaxation of the planar problem has an integrality ratio approaching 2.

Network flow interdiction on planar graphs

The network flow interdiction problem asks to reduce the value of a maximum flow in a given network as much as possible by removing arcs and vertices of the network constrained to a fixed budget. Although the network flow interdiction problem is strongly NP-complete on general networks, pseudo-polynomial algorithms were found for planar networks with a single source and a single sink and without the possibility to remove vertices. In this work, we introduce pseudo-polynomial algorithms that overcome various restrictions of previous methods. In particular, we propose a planarity-preserving transformation that enables incorporation of vertex removals and vertex capacities in pseudo-polynomial interdiction algorithms for planar graphs. Additionally, a new approach is introduced that allows us to determine in pseudo-polynomial time the minimum interdiction budget needed to remove arcs and vertices of a given network such that the demands of the sink node cannot be completely satisfied anymore. The algorithm works on planar networks with multiple sources and sinks satisfying that the sum of the supplies at the sources equals the sum of the demands at the sinks. A simple extension of the proposed method allows us to broaden its applicability to solve network flow interdiction problems on planar networks with a single source and sink having no restrictions on the demand and supply. The proposed method can therefore solve a wider class of flow interdiction problems in pseudo-polynomial time than previous pseudo-polynomial algorithms and is the first pseudo-polynomial algorithm that can solve non-trivial planar flow interdiction problems with multiple sources and sinks. Furthermore, we show that the k -densest subgraph problem on planar graphs can be reduced to a network flow interdiction problem on a planar graph with multiple sources and sinks and polynomially bounded input numbers.

New Approximation Algorithms for Minimum Cycle Bases of Graphs

We consider the problem of computing an approximate minimum cycle basis of an undirected non-negative edge-weighted graph G with m edges and n vertices; the extension to directed graphs is also discussed. In this problem, a {0,1} incidence vector is associated with each cycle and the vector space over $\mathbb{F}_{2}$ generated by these vectors is the cycle space of G. A set of cycles is called a cycle basis of G if it forms a basis for its cycle space. A cycle basis where the sum of the weights of the cycles is minimum is called a minimum cycle basis of G. Cycle bases of low weight are useful in a number of contexts, e.g. the analysis of electrical networks, structural engineering, chemistry, and surface reconstruction. Although in most such applications any cycle basis can be used, a low weight cycle basis often translates to better performance and/or numerical stability. Despite the fact that the problem can be solved exactly in polynomial time, we design approximation algorithms since the performance of the exact algorithms may be too expensive for some practical applications. We present two new algorithms to compute an approximate minimum cycle basis. For any integer k≥1, we give (2k−1)-approximation algorithms with expected running time O(kmn 1+2/k +mn (1+1/k)(ω−1)) and deterministic running time O(n 3+2/k ), respectively. Here ω is the best exponent of matrix multiplication. It is presently known that ω<2.376. Both algorithms are o(m ω ) for dense graphs. This is the first time that any algorithm which computes sparse cycle bases with a guarantee drops below the Θ(m ω ) bound. We also present a 2-approximation algorithm with expected running time $O(m^{\omega}\sqrt{n\log n})$ , a linear time 2-approximation algorithm for planar graphs and an O(n 3) time 2.42-approximation algorithm for the complete Euclidean graph in the plane.

Approximation Algorithms and Hardness for Domination with Propagation

The Power Dominating Set (PDS) problem is the following extension of the well-known dominating set problem: find a smallest-size set of nodes S that power dominates all the nodes, where a node v is power dominated if (1) v is in S or v has a neighbor in S, or (2) v has a neighbor w such that w and all of its neighbors except v are power dominated. We show a hardness of approximation threshold of $2^{\log^{1-\epsilon}n}$ in contrast to the logarithmic hardness for the dominating set problem. We give an $O(\sqrt{n})$-approximation algorithm for planar graphs and show that our methods cannot improve on this approximation guarantee. Finally, we initiate the study of PDS on directed graphs and show the same hardness threshold of $2^{\log^{1-\epsilon}n}$ for directed acyclic graphs. Also we show that the directed PDS problem can be solved optimally in linear time if the underlying undirected graph has bounded tree-width.

Shortest paths in linear time on minor-closed graph classes, with an application to Steiner tree approximation

We generalize the linear-time shortest-paths algorithm for planar graphs with nonnegative edge-weights of Henzinger et al. (1994) to work for any proper minor-closed class of graphs. We argue that their algorithm can not be adapted by standard methods to all proper minor-closed classes. By using recent deep results in graph minor theory, we show how to construct an appropriate recursive division in linear time for any graph excluding a fixed minor and how to transform the graph and its division afterwards, so that it has maximum degree three. Based on such a division, the original framework of Henzinger et al. can be applied. Afterwards, we show that using this algorithm, one can implement Mehlhorn’s (1988) 2-approximation algorithm for the Steiner tree problem in linear time on these graph classes.

The Ferry Cover Problem

In this paper we define and study a family of optimization problems called Ferry problems, which may be viewed as generalizations of the classical wolf-goat-cabbage puzzle. We present the Ferry Cover problem (FC), where the objective is to determine the minimum required boat size to safely transport n items represented by a graph G and demonstrate a close connection with Vertex Cover which leads to hardness and approximation results. We also completely solve the problem on trees. Then we focus on a variation of the same problem with the added constraint that only 1 round-trip is allowed (FC1). We present a reduction from MAX-NAE-{3}-SAT which shows that this problem is NP-hard and APX-hard. We also provide an approximation algorithm for bipartite graphs with a factor asymptotically equal to $\frac{4}{3}$and a 1.56-approximation algorithm for planar graphs. Finally, we generalize the above problem to define FCm , where at most m round-trips are allowed, and MFTk , which is the problem of minimizing the number of round-trips when the boat capacity is k. We present some preliminary lemmata for both, which provide bounds on the value of the optimal solution, and relate them to FC.

Treewidth Lower Bounds with Brambles

In this paper we present a new technique for computing lower bounds for graph treewidth. Our technique is based on the fact that the treewidth of a graph G is the maximum order of a bramble of G minus one. We give two algorithms: one for general graphs, and one for planar graphs. The algorithm for planar graphs is shown to give a lower bound for both the treewidth and branchwidth that is at most a constant factor away from the optimum. For both algorithms, we report on extensive computational experiments that show that the algorithms often give excellent lower bounds, in particular when applied to (close to) planar graphs.

A self-stabilizing ( [formula omitted])-edge-coloring algorithm for planar graphs in anonymous uniform systems

This paper proposes a self-stabilizing edge-coloring algorithm using ( Δ + 4 ) colors for distributed systems of a planar graph topology, where Δ ⩾ 5 is the maximum degree of the graph. The algorithm can be applied to anonymous uniform systems and its time complexity is O ( n 2 ) moves under the central daemon model.

Algorithms for finding distance-edge-colorings of graphs

For a bounded integer ℓ, we wish to color all edges of a graph G so that any two edges within distance ℓ have different colors. Such a coloring is called a distance-edge-coloring or an ℓ-edge-coloring of G. The distance-edge-coloring problem is to compute the minimum number of colors required for a distance-edge-coloring of a given graph G. A partial k-tree is a graph with tree-width bounded by a fixed constant k. We first present a polynomial-time exact algorithm to solve the problem for partial k-trees, and then give a polynomial-time 2-approximation algorithm for planar graphs.