Tom C. van der Zanden

Subexponential Time Algorithms for Embedding H-Minor Free Graphs

We establish the complexity of several graph embedding problems: Subgraph Isomorphism, Graph Minor, Induced Subgraph and Induced Minor, when restricted to H-minor free graphs. In each of these problems, we are given a pattern graph P and a host graph G, and want to determine whether P is a subgraph (minor, induced subgraph or induced minor) of G. We show that, for any fixed graph H and epsilon > 0, if P is H-Minor Free and G has treewidth tw, (induced) subgraph can be solved 2^{O(k^{epsilon}*tw+k/log(k))}*n^{O(1)} time and (induced) minor can be solved in 2^{O(k^{epsilon}*tw+tw*log(tw)+k/log(k))}*n^{O(1)} time, where k = |V(P)|. We also show that this is optimal, in the sense that the existence of an algorithm for one of these problems running in 2^{o(n/log(n))} time would contradict the Exponential Time Hypothesis. This solves an open problem on the complexity of Subgraph Isomorphism for planar graphs. The key algorithmic insight is that dynamic programming approaches can be sped up by identifying isomorphic connected components in the pattern graph. This technique seems widely applicable, and it appears that there is a relatively unexplored class of problems that share a similar upper and lower bound.

PSPACE-Completeness of Bloxorz and of Games with 2-Buttons

Bloxorz is an online puzzle game where players move a 1×1×2 block by tilting it on a subset of the two dimensional grid, that also features switches that open and close trapdoors. The puzzle is to move the block from its initial position to an upright position on the goal square. We show that the problem of deciding whether a given Bloxorz level is solvable is PSPACE-complete and that this remains so even when all trapdoors are initially closed or all trapdoors are initially open. We also answer an open question of Viglietta [6], showing that 2-buttons are sufficient for PSPACE-hardness of general puzzle games. We also examine the hardness of some variants of Bloxorz, including variants where the block is a 1×1×1 cube, and variants with single-use tiles.

Computing treewidth on the GPU

We present a parallel algorithm for computing the treewidth of a graph on a GPU. We implement this algorithm in OpenCL, and experimentally evaluate its performance. Our algorithm is based on an O*(2^n)-time algorithm that explores the elimination orderings of the graph using a Held-Karp like dynamic programming approach. We use Bloom filters to detect duplicate solutions. GPU programming presents unique challenges and constraints, such as constraints on the use of memory and the need to limit branch divergence. We experiment with various optimizations to see if it is possible to work around these issues. We achieve a very large speed up (up to 77x) compared to running the same algorithm on the CPU.

On the Exact Complexity of Hamiltonian Cycle and q-Colouring in Disk Graphs

We study the exact complexity of the Hamiltonian Cycle and the q-Colouring problem in disk graphs. We show that the Hamiltonian Cycle problem can be solved in \(2^{O(\sqrt{n})}\) on n-vertex disk graphs where the ratio of the largest and smallest disk radius is O(1). We also show that this is optimal: assuming the Exponential Time Hypothesis, there is no \(2^{o(\sqrt{n})}\)-time algorithm for Hamiltonian Cycle, even on unit disk graphs. We give analogous results for graph colouring: under the Exponential Time Hypothesis, for any fixed q, q-Colouring does not admit a \(2^{o(\sqrt{n})}\)-time algorithm, even when restricted to unit disk graphs, and it is solvable in \(2^{O(\sqrt{n})}\)-time on disk graphs.

Complexity of the Maximum k -Path Vertex Cover Problem

This paper introduces the maximum version of the k-path vertex cover problem, called the Maximum k-Path Vertex Cover problem (\(\mathsf{{Max}}{P_k}\mathsf{VC}\) for short): A path consisting of k vertices, i.e., a path of length \(k-1\) is called a k-path. If a k-path \(P_k\) includes a vertex v in a vertex set S, then we say that S or v covers \(P_k\). Given a graph \(G = (V, E)\) and an integer s, the goal of \(\mathsf{{Max}}{P_k}\mathsf{VC}\) is to find a vertex subset \(S\subseteq V\) of at most s vertices such that the number of k-paths covered by S is maximized. \(\mathsf{{Max}}{P_k}\mathsf{VC}\) is generally NP-hard. In this paper we consider the tractability/intractability of \(\mathsf{{Max}}{P_k}\mathsf{VC}\) on subclasses of graphs: We prove that \(\mathsf{{Max}}{P_3}\mathsf{VC}\) and \(\mathsf{{Max}}{P_4}\mathsf{VC}\) remain NP-hard even for split graphs and for chordal graphs, respectively. Furthermore, if the input graph is restricted to graphs with constant bounded treewidth, then \(\mathsf{{Max}}{P_3}\mathsf{VC}\) can be solved in polynomial time.

A framework for ETH-tight algorithms and lower bounds in geometric intersection graphs

We give an algorithmic and lower-bound framework that facilitates the construction of subexponential algorithms and matching conditional complexity bounds. It can be applied to a wide range of geometric intersection graphs (intersections of similarly sized fat objects), yielding algorithms with running time 2O(n1−1/d) for any fixed dimension d≥ 2 for many well known graph problems, including Independent Set, r-Dominating Set for constant r, and Steiner Tree. For most problems, we get improved running times compared to prior work; in some cases, we give the first known subexponential algorithm in geometric intersection graphs. Additionally, most of the obtained algorithms work on the graph itself, i.e., do not require any geometric information. Our algorithmic framework is based on a weighted separator theorem and various treewidth techniques. The lower-bound framework is based on a constructive embedding of graphs into d-dimensional grids, and it allows us to derive matching 2Ω(n1−1/d) lower bounds under the Exponential Time Hypothesis even in the much more restricted class of d-dimensional induced grid graphs.

On the exact complexity of polyomino packing

We show that the problem of deciding whether a collection of polyominoes, each fitting in a 2 x O(log n) rectangle, can be packed into a 3 x n box does not admit a 2^{o(n/log{n})}-time algorithm, unless the Exponential Time Hypothesis fails. We also give an algorithm that attains this lower bound, solving any instance of polyomino packing with total area n in 2^{O(n/log{n})} time. This establishes a tight bound on the complexity of Polyomino Packing, even in a very restricted case. In contrast, for a 2 x n box, we show that the problem can be solved in strongly subexponential time.

On exploring always-connected temporal graphs of small pathwidth

Abstract We show that the Temporal Graph Exploration Problem is NP-complete, even when the underlying graph has pathwidth 2 and at each time step, the current graph is connected.

On the maximum weight minimal separator

Given an undirected and connected graph \(G=(V, E)\) and two vertices \(s, t\in V\), a vertex subset S that separates s and t is called an s-t separator, and an s-t separator is called minimal if no proper subset of S separates s and t. In this paper, we consider finding a minimal s-t separator with maximum weight on a vertex-weighted graph. We first prove that this problem is NP-hard. Then, we propose an \(\mathbf{tw}^{O(\mathbf{tw})}n\)-time deterministic algorithm based on tree decompositions. Moreover, we also propose an \(O^*(9^\mathbf{tw}\cdot W^2)\)-time randomized algorithm to determine whether there exists a minimal s-t separator where W is its weight and \(\mathbf{tw}\) is the treewidth of G.

Improved lower bounds for graph embedding problems

In this paper, we give new, tight subexponential lower bounds for a number of graph embedding problems. We introduce two related combinatorial problems, which we call String Crafting and Orthogonal Vector crafting, and show that these cannot be solved in time \(2^{o(|s|/\log {|s|})}\), unless the Exponential Time Hypothesis fails.