Separator Theorems for Minor-Free and Shallow Minor-Free Graphs with Applications

Alon, Seymour, and Thomas generalized Lipton and Tarjan's planar separator theorem and showed that a $K_h$-minor free graph with $n$ vertices has a separator of size at most $h^{3/2}\sqrt n$. They gave an algorithm that, given a graph $G$ with $m$ edges and $n$ vertices and given an integer $h\geq 1$, outputs in $O(\sqrt{hn}m)$ time such a separator or a $K_h$-minor of $G$. Plotkin, Rao, and Smith gave an $O(hm\sqrt{n\log n})$ time algorithm to find a separator of size $O(h\sqrt{n\log n})$. Kawarabayashi and Reed improved the bound on the size of the separator to $h\sqrt n$ and gave an algorithm that finds such a separator in $O(n^{1 + \epsilon})$ time for any constant $\epsilon > 0$, assuming $h$ is constant. This algorithm has an extremely large dependency on $h$ in the running time (some power tower of $h$ whose height is itself a function of $h$), making it impractical even for small $h$. We are interested in a small polynomial time dependency on $h$ and we show how to find an $O(h\sqrt{n\log n})$-size separator or report that $G$ has a $K_h$-minor in O(\poly(h)n^{5/4 + \epsilon}) time for any constant $\epsilon > 0$. We also present the first O(\poly(h)n) time algorithm to find a separator of size $O(n^c)$ for a constant $c < 1$. As corollaries of our results, we get improved algorithms for shortest paths and maximum matching. Furthermore, for integers $\ell$ and $h$, we give an $O(m + n^{2 + \epsilon}/\ell)$ time algorithm that either produces a $K_h$-minor of depth $O(\ell\log n)$ or a separator of size at most $O(n/\ell + \ell h^2\log n)$. This improves the shallow minor algorithm of Plotkin, Rao, and Smith when $m = \Omega(n^{1 + \epsilon})$. We get a similar running time improvement for an approximation algorithm for the problem of finding a largest $K_h$-minor in a given graph.Comment: To appear at FOCS 201

A linear-time algorithm for finding a complete graph minor in a dense graph

Let g(t) be the minimum number such that every graph G with average degree d(G) \geq g(t) contains a K_{t}-minor. Such a function is known to exist, as originally shown by Mader. Kostochka and Thomason independently proved that g(t) \in \Theta(t*sqrt{log t}). This article shows that for all fixed \epsilon > 0 and fixed sufficiently large t \geq t(\epsilon), if d(G) \geq (2+\epsilon)g(t) then we can find this K_{t}-minor in linear time. This improves a previous result by Reed and Wood who gave a linear-time algorithm when d(G) \geq 2^{t-2}.Comment: 6 pages, 0 figures; Clarification added in several places, no change to arguments or result

Parallel Graph Decompositions Using Random Shifts

We show an improved parallel algorithm for decomposing an undirected unweighted graph into small diameter pieces with a small fraction of the edges in between. These decompositions form critical subroutines in a number of graph algorithms. Our algorithm builds upon the shifted shortest path approach introduced in [Blelloch, Gupta, Koutis, Miller, Peng, Tangwongsan, SPAA 2011]. By combining various stages of the previous algorithm, we obtain a significantly simpler algorithm with the same asymptotic guarantees as the best sequential algorithm

Faster Separators for Shallow Minor-Free Graphs via Dynamic Approximate Distance Oracles

Plotkin, Rao, and Smith (SODA'97) showed that any graph with $m$ edges and $n$ vertices that excludes $K_h$ as a depth $O(\ell\log n)$-minor has a separator of size $O(n/\ell + \ell h^2\log n)$ and that such a separator can be found in $O(mn/\ell)$ time. A time bound of $O(m + n^{2+\epsilon}/\ell)$ for any constant $\epsilon > 0$ was later given (W., FOCS'11) which is an improvement for non-sparse graphs. We give three new algorithms. The first has the same separator size and running time O(\mbox{poly}(h)\ell m^{1+\epsilon}). This is a significant improvement for small $h$ and $\ell$. If $\ell = \Omega(n^{\epsilon'})$ for an arbitrarily small chosen constant $\epsilon' > 0$, we get a time bound of O(\mbox{poly}(h)\ell n^{1+\epsilon}). The second algorithm achieves the same separator size (with a slightly larger polynomial dependency on $h$) and running time O(\mbox{poly}(h)(\sqrt\ell n^{1+\epsilon} + n^{2+\epsilon}/\ell^{3/2})) when $\ell = \Omega(n^{\epsilon'})$. Our third algorithm has running time O(\mbox{poly}(h)\sqrt\ell n^{1+\epsilon}) when $\ell = \Omega(n^{\epsilon'})$. It finds a separator of size O(n/\ell) + \tilde O(\mbox{poly}(h)\ell\sqrt n) which is no worse than previous bounds when $h$ is fixed and $\ell = \tilde O(n^{1/4})$. A main tool in obtaining our results is a novel application of a decremental approximate distance oracle of Roditty and Zwick.Comment: 16 pages. Full version of the paper that appeared at ICALP'14. Minor fixes regarding the time bounds such that these bounds hold also for non-sparse graph

Structured recursive separator decompositions for planar graphs in linear time (Extended Abstract)

Given a triangulated planar graph G on n vertices and an integer r &lt; n, an r-division of G with few holes is a decomposition of G into O(n/r) regions of size at most r such that each region contains at most a constant number of faces that are not faces of G (also called holes), and such that, for each region, the total number of vertices on these faces is O( √ r). We provide an algorithm for computing r-divisions with few holes in linear time. In fact, our algorithm computes a structure, called decomposition tree, which represents a recursive decomposition of G that includes r-divisions for essentially all values of r. In particular, given an exponentially increasing sequence r = (r1, r2, ...), our algorithm can produce a recursive r-division with few holes in linear time. r-divisions with few holes have been used in efficient algorithms to compute shortest paths, minimum cuts, and maximum flows. Our linear-time algorithm improves upon the decomposition algorithm used in the state-of-the-art algorithm for minimum st-cut (Italiano, Nussbaum, Sankowski, and Wulff-Nilsen, STOC 2011), removing one of the bottlenecks in the overall running time of their algorithm (analogously for minimum cut in planar and bounded-genus graphs)