Cubic Augmentation of Planar Graphs

In this paper we study the problem of augmenting a planar graph such that it becomes 3-regular and remains planar. We show that it is NP-hard to decide whether such an augmentation exists. On the other hand, we give an efficient algorithm for the variant of the problem where the input graph has a fixed planar (topological) embedding that has to be preserved by the augmentation. We further generalize this algorithm to test efficiently whether a 3-regular planar augmentation exists that additionally makes the input graph connected or biconnected. If the input graph should become even triconnected, we show that the existence of a 3-regular planar augmentation is again NP-hard to decide.Comment: accepted at ISAAC 201

An Exact Algorithm for TSP in Degree-3 Graphs via Circuit Procedure and Amortization on Connectivity Structure

The paper presents an O^*(1.2312^n)-time and polynomial-space algorithm for the traveling salesman problem in an n-vertex graph with maximum degree 3. This improves the previous time bounds of O^*(1.251^n) by Iwama and Nakashima and O^*(1.260^n) by Eppstein. Our algorithm is a simple branch-and-search algorithm. The only branch rule is designed on a cut-circuit structure of a graph induced by unprocessed edges. To improve a time bound by a simple analysis on measure and conquer, we introduce an amortization scheme over the cut-circuit structure by defining the measure of an instance to be the sum of not only weights of vertices but also weights of connected components of the induced graph.Comment: 24 pages and 4 figure

Finding 2-Edge and 2-Vertex Strongly Connected Components in Quadratic Time

We present faster algorithms for computing the 2-edge and 2-vertex strongly connected components of a directed graph, which are straightforward generalizations of strongly connected components. While in undirected graphs the 2-edge and 2-vertex connected components can be found in linear time, in directed graphs only rather simple $O(m n)$-time algorithms were known. We use a hierarchical sparsification technique to obtain algorithms that run in time $O(n^2)$. For 2-edge strongly connected components our algorithm gives the first running time improvement in 20 years. Additionally we present an $O(m^2 / \log{n})$-time algorithm for 2-edge strongly connected components, and thus improve over the $O(m n)$ running time also when $m = O(n)$. Our approach extends to k-edge and k-vertex strongly connected components for any constant k with a running time of $O(n^2 \log^2 n)$ for edges and $O(n^3)$ for vertices

Almost-Tight Distributed Minimum Cut Algorithms

We study the problem of computing the minimum cut in a weighted distributed message-passing networks (the CONGEST model). Let $\lambda$ be the minimum cut, $n$ be the number of nodes in the network, and $D$ be the network diameter. Our algorithm can compute $\lambda$ exactly in $O((\sqrt{n} \log^{*} n+D)\lambda^4 \log^2 n)$ time. To the best of our knowledge, this is the first paper that explicitly studies computing the exact minimum cut in the distributed setting. Previously, non-trivial sublinear time algorithms for this problem are known only for unweighted graphs when $\lambda\leq 3$ due to Pritchard and Thurimella's $O(D)$-time and $O(D+n^{1/2}\log^* n)$-time algorithms for computing $2$-edge-connected and $3$-edge-connected components. By using the edge sampling technique of Karger's, we can convert this algorithm into a $(1+\epsilon)$-approximation $O((\sqrt{n}\log^{*} n+D)\epsilon^{-5}\log^3 n)$-time algorithm for any $\epsilon>0$. This improves over the previous $(2+\epsilon)$-approximation $O((\sqrt{n}\log^{*} n+D)\epsilon^{-5}\log^2 n\log\log n)$-time algorithm and $O(\epsilon^{-1})$-approximation $O(D+n^{\frac{1}{2}+\epsilon} \mathrm{poly}\log n)$-time algorithm of Ghaffari and Kuhn. Due to the lower bound of $\Omega(D+n^{1/2}/\log n)$ by Das Sarma et al. which holds for any approximation algorithm, this running time is tight up to a $\mathrm{poly}\log n$ factor. To get the stated running time, we developed an approximation algorithm which combines the ideas of Thorup's algorithm and Matula's contraction algorithm. It saves an $\epsilon^{-9}\log^{7} n$ factor as compared to applying Thorup's tree packing theorem directly. Then, we combine Kutten and Peleg's tree partitioning algorithm and Karger's dynamic programming to achieve an efficient distributed algorithm that finds the minimum cut when we are given a spanning tree that crosses the minimum cut exactly once

Distributed Minimum Cut Approximation

We study the problem of computing approximate minimum edge cuts by distributed algorithms. We use a standard synchronous message passing model where in each round, $O(\log n)$ bits can be transmitted over each edge (a.k.a. the CONGEST model). We present a distributed algorithm that, for any weighted graph and any $\epsilon \in (0, 1)$, with high probability finds a cut of size at most $O(\epsilon^{-1}\lambda)$ in $O(D) + \tilde{O}(n^{1/2 + \epsilon})$ rounds, where $\lambda$ is the size of the minimum cut. This algorithm is based on a simple approach for analyzing random edge sampling, which we call the random layering technique. In addition, we also present another distributed algorithm, which is based on a centralized algorithm due to Matula [SODA '93], that with high probability computes a cut of size at most $(2+\epsilon)\lambda$ in $\tilde{O}((D+\sqrt{n})/\epsilon^5)$ rounds for any $\epsilon>0$. The time complexities of both of these algorithms almost match the $\tilde{\Omega}(D + \sqrt{n})$ lower bound of Das Sarma et al. [STOC '11], thus leading to an answer to an open question raised by Elkin [SIGACT-News '04] and Das Sarma et al. [STOC '11]. Furthermore, we also strengthen the lower bound of Das Sarma et al. by extending it to unweighted graphs. We show that the same lower bound also holds for unweighted multigraphs (or equivalently for weighted graphs in which $O(w\log n)$ bits can be transmitted in each round over an edge of weight $w$), even if the diameter is $D=O(\log n)$. For unweighted simple graphs, we show that even for networks of diameter $\tilde{O}(\frac{1}{\lambda}\cdot \sqrt{\frac{n}{\alpha\lambda}})$, finding an $\alpha$-approximate minimum cut in networks of edge connectivity $\lambda$ or computing an $\alpha$-approximation of the edge connectivity requires $\tilde{\Omega}(D + \sqrt{\frac{n}{\alpha\lambda}})$ rounds

On the Maximum Crossing Number

Research about crossings is typically about minimization. In this paper, we consider \emph{maximizing} the number of crossings over all possible ways to draw a given graph in the plane. Alpert et al. [Electron. J. Combin., 2009] conjectured that any graph has a \emph{convex} straight-line drawing, e.g., a drawing with vertices in convex position, that maximizes the number of edge crossings. We disprove this conjecture by constructing a planar graph on twelve vertices that allows a non-convex drawing with more crossings than any convex one. Bald et al. [Proc. COCOON, 2016] showed that it is NP-hard to compute the maximum number of crossings of a geometric graph and that the weighted geometric case is NP-hard to approximate. We strengthen these results by showing hardness of approximation even for the unweighted geometric case and prove that the unweighted topological case is NP-hard.Comment: 16 pages, 5 figure

Approximating Source Location and Star Survivable Network Problems

Abstract. In Source Location (SL) problems the goal is to select a minimum cost source set S ⊆ V such that the connectivity (or flow) ψ(S, v) from S to any node v is at least the demand dv of v. In many SL problems ψ(S, v) = dv if v ∈ S, namely, the demand of nodes se-lected to S is completely satisfied. In a node-connectivity variant sug-gested recently by Fukunaga [6], every node v gets a “bonus ” pv ≤ dv if it is selected to S, namely, ψ(S, v) = pv + κ(S \ {v}, v) if v ∈ S and ψ(S, v) = κ(S, v) otherwise, where κ(S, v) is the maximum number of internally disjoint (S, v)-paths. While the approximability of many SL problems was seemingly settled to Θ(ln d(V)) in [18], Fukunaga [6] showed that for undirected graphs one can achieve ratio O(k ln k) for his variant, where k = maxv∈V dv is the maximum demand. We improve this by achieving ratio min{p ∗ ln k, k} · O(ln(k/q∗)) for a more general version with node capacities, where p ∗ = maxv∈V pv is the maximum bonus and q ∗ = minv∈V qv is the minimum capacity. In particular, for the most natural case p ∗ = 1 considered in [6] we improve the ratio from O(k ln k) to O(ln2 k). Our result also implies ratio k for the edge-connectivity version. To derive these results, we consider a particular case of the Survivable Network (SN) problem when all edges of positive cost form a star. We give ratio O(min{lnn, ln2 k}) for this variant, improving over the best ratio known for the general case O(k3 lnn) of Chuzhoy and Khanna [3]. In addition, we show that directed SL with unit costs is Ω(logn)-hard to approximate even for 0, 1 demands, while SL with uniform demands can be solved in polynomial time. Finally, we consider a generalization of SL where we also have edge-costs {ce: e ∈ E} and flow-cost bounds {bv: v ∈ V}, and require that for every node v, the minimum cost of a flow of value dv from S to v is at most bv. We show that this problem admits approximation ratio O(ln d(V) + ln(nc(E) − b(V)).

Sorting by reversals, block interchanges, tandem duplications, and deletions

<p>Abstract</p> <p>Background</p> <p>Finding sequences of evolutionary operations that transform one genome into another is a classic problem in comparative genomics. While most of the genome rearrangement algorithms assume that there is exactly one copy of each gene in both genomes, this does not reflect the biological reality very well – most of the studied genomes contain duplicated gene content, which has to be removed before applying those algorithms. However, dealing with unequal gene content is a very challenging task, and only few algorithms allow operations like duplications and deletions. Almost all of these algorithms restrict these operations to have a fixed size.</p> <p>Results</p> <p>In this paper, we present a heuristic algorithm to sort an ancestral genome (with unique gene content) into a genome of a descendant (with arbitrary gene content) by reversals, block interchanges, tandem duplications, and deletions, where tandem duplications and deletions are of arbitrary size.</p> <p>Conclusion</p> <p>Experimental results show that our algorithm finds sorting sequences that are close to an optimal sorting sequence when the ancestor and the descendant are closely related. The quality of the results decreases when the genomes get more diverged or the genome size increases. Nevertheless, the calculated distances give a good approximation of the true evolutionary distances.</p