Approximate tree decompositions of planar graphs in linear time

The classic algorithm of Bodlaender and Kloks [J. Algorithms, 1996] solves the following problem in linear fixed-parameter time: given a tree decomposition of a graph of (possibly suboptimal) width k, compute an optimum-width tree decomposition of the graph. In this work, we prove that this problem can also be solved in mso in the following sense: for every positive integer k, there is an mso transduction from tree decompositions of width k to tree decompositions of optimum width. Together with our recent results [LICS 2016], this implies that for every k there exists an mso transduction which inputs a graph of treewidth k, and nondeterministically outputs its tree decomposition of optimum width. We also show that mso transductions can be implemented in linear fixed-parameter time, which enables us to derive the algorithmic result of Bodlaender and Kloks as a corollary of our main result.

An implicit representation of chordal comparability graphs in linear time

We resolve the fine-grained parameterized complexity of detecting and counting small patterns in planar graphs, assuming the Exponential Time Hypothesis. Given an n-vertex planar graph G and a k-vertex pattern graph P, we compute the number of (induced) copies of P in G in time 2O(√k) n O(1), if P is a matching, independent set, or connected bounded maximum degree graph, 2 O(k/logk) n O(1), for any pattern P. Our results significantly advance the state of the art of the planar graph isomorphism problem: No 2 o(k) n O(1) time algorithms where previously known for counting patterns even in very restricted cases such as independent sets in subgraphs of grids, Even for detection, no 2 O(k/logk) n O(1) time algorithms for unrestricted patterns P were previously known, Our run times cannot be improved assuming the Exponential Time Hypothesis (ETH). Our results are a corollary of the following general result: We compute the number of (induced) copies of P in G in 2O(√k)(σ(P)n) O(1) time, where σ(P) denotes the number of non-isomorphic separations of P of order O(√k). To obtain the first sub-exponential time algorithms, we introduce a new general technique that we call efficient inclusion-exclusion. This technique allows us to efficiently use hierarchies of separators for counting problems. To resolve the optimal complexity of planar subgraph isomorphism we provide another technique that we call balanced cycle sparsification. This technique allows us to obtain from one balanced cycle separator in a planar graphs a family of balanced cycle separators that have limited mutual overlap, implying one separator has few vertices of the pattern copy.

Given a plane graph it is known how to compute the union of non-crossing shortest paths. These algorithms do not allow neither to list each single shortest path nor to compute length of shortest paths. Given the union of non-crossing shortest paths, we introduce the concept of shortcuts that allows us to establish whether a path is a shortest path by checking local properties on faces of the graph. By using shortcuts we can compute the length of each shortest path, given their union, in total linear time, and we can list each shortest path p in O(max{ℓ,ℓloglogkℓ}), where ℓ is the number of edges in p and k the number of shortest paths.

We present new algorithms for finding short cycles (of length at most 6) in planar graphs. Although there is an O(n) algorithm for finding any fixed subgraph H in a given n-vertex planar graph [5], the multiplication constant hidden in “O” notation (which depends on the size of H) is so high, that it rather cannot be used in practice even when |V(H)| = 4. Our approach gives faster “practical algorithms” which are additionally much easier to implement.As a side-effect of our approach we show that the maximum number of k-cycles in n-vertex planar graph is \(\Theta (n^{\lfloor \frac{k}{2} \rfloor})\).KeywordsPlanar GraphLinear TimeShort CycleInput GraphDisjoint PathThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Let G be a finite undirected graph with edge set E. An edge set E′⊆E is an induced matching in G if the pairwise distance of the edges of E′ in G is at least two; E′ is dominating in G if every edge e∈E∖E′ intersects some edge in E′. The Dominating Induced Matching Problem (DIM, for short) asks for the existence of an induced matching E′ which is also dominating in G; this problem is also known as the Efficient Edge Domination Problem. The DIM problem is related to parallel resource allocation problems, encoding theory and network routing. It is ${\mathbb{NP}}$ -complete even for very restricted graph classes such as planar bipartite graphs with maximum degree three. However, its complexity was open for P k -free graphs for any k≥5; P k denotes a chordless path with k vertices and k−1 edges. We show in this paper that the weighted DIM problem is solvable in linear time for P 7-free graphs in a robust way.

Bidimensionality Theory is a meta-algorithmic theory whose main ingredients are the Grid Exclusion Theorem of the Graph Minors series of Robertson and Seymour and the celebrated Courcelle’s Theorem. The grid exclusion theorem states that if a graph excludes a bidimensional grid as a minor (a graph H is a minor of a graph G if H can be obtained by some subgraph of G by con- tracting edges) then its structure topologically resembles the structure of a tree (in technical terms, it has small treewidth). Intuitively, this result says that the absence of the bidimensional structure of a grid implies that a graph has the “mono-dimensional” structure of a tree. On the other side, Courcelle’s theorem states that if a problem on graphs is expressible in Monadic Second Order Logic (MSOL), then it is possible to solve it in linear time when the treewidth of their input graphs is fixed. Intuitively, this theorem expresses the fact that the mono- dimensional structure of a tree (i.e., small treewidth) makes it possible to treat a graph as the input string of a finite-state tree automaton, where the finiteness of its states is guaranteed by the MSOL-expressibility of the problem. Combin- ing these two results together, we derive that the absence of the bidimensional structure of a grid, enables the applicability of the “divide-and-conquer” tech- nique for problems of certain descriptive complexity. It appears that for many graph theoretic problems the existence of a grid-minor (or other bidimensional strucures) on the input graph provides a certificate for an immediate negative (or positive) answer and, for the remaining instances, a dynamic programming approach on graphs of bounded treewidth may give an answer to the problem. This phenomenon reveals fruitful interleave between graph structure and logic in graph algorithms. Bidimensionality Theory aims at systematizing this idea and extending its applicability in diverse paradigms of algorithm design.

Grötzsch's theorem states that every triangle-free planar graph is 3-colorable, and several relatively simple proofs of this fact were provided by Thomassen and other authors. It is easy to convert these proofs into quadratic-time algorithms to find a 3-coloring, but it is not clear how to find such a coloring in linear time (Kowalik used a nontrivial data structure to construct anO(nlogn) algorithm).We design a linear-time algorithm to find a 3-coloring of a given triangle-free planar graph. The algorithm avoids using any complex data structures, which makes it easy to implement. As a by-product, we give a yet simpler proof of Grötzsch's theorem.

Grotzsch's theorem states that every triangle-free planar graph is 3-colorable, and several relatively simple proofs of this fact were provided by Thomassen and other authors. It is easy to convert these proofs into quadratic-time algorithms to find a 3-coloring, but it is not clear how to find such a coloring in linear time (Kowalik used a nontrivial data structure to construct an O(n log n) algorithm).We design a linear-time algorithm to find a 3-coloring of a given triangle-free planar graph. The algorithm avoids using any complex data structures, which makes it easy to implement. As a by-product we give a yet simpler proof of Grotzsch's theorem.

The problem of processing shortest pa th queries in graphs arises in application areas such as intelligent t ranspor ta t ion system (ITS), geographic information system (GIS), and robotics. In this paper, we present an efficient algorithmic solution for processing shortest pa th queries in undirected planar graphs with non-negative edge weights. Previous algorithms for this problem on planar graphs all have a tradeoff between the query t ime and the da ta structure space used by the solutions. The previously best known trade-off on an n-vertex planar graph G in the worst case is O(v/-r) t ime for a pa th length query and O(v/-r + L) t ime for report ing an actual shortest path, with a da ta structure of O(n2/x/~) space, where r is an integer parameter with 1 < r _< n and L is the number of edges on the output shortest path. We present a new scheme, called frame search, that exploits the graph planari ty in a novel fashion. Wi th this scheme, we build an improved da ta structure of O(n + pv/-r + p2/r) space (in O(n + p2/v/~ + pr 3/4) time), where p is the minimum cardinality of a face-covering of the planar embedding of G with 1 < p < O(n), and r is an integer parameter with 1 < r < p. This da ta structure enables us to process each length query in O(v/-rlog r + a(n)) t ime and report an actual shortest path in an addit ional O(L) time, where a(n) is the inverse of Ackermann's function. In the worst case, our approach reduces the previously best query t ime by a factor of up to O(n 1/4) if the same amount of space is used. Our technique can also be applied to improve the previous query algorithms for some geometric shortest pa th problems on the plane.

Rainbow colouring of split graphs

We consider the following problem. Let G=(V, E) be an undirected planar graph and let s, t∈V, s≠t. The problem is to find a set of pairwise edge-disjoint paths, each connecting s with t, with maximum cardinality. In other words, the problem is to find a maximum unit flow from s to t. The fastest algorithm in the literature has running time O(|V|log|V|)(¦V¦ log ¦V¦). In this paper now, we give a linear time algorithm.KeywordsPlanar GraphLinear TimeUnit FlowOuter FaceSearch PathThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Consider a graph G. A subset of vertices, F, is called a vertex cover \(P_t\) (\(VCP_t\)) set if every path of order t contains at least one vertex in F. Finding a minimum \(VCP_t\) set in a graph is is NP-hard for any integer \(t\ge 2\) and is called the \(MVCP_3\) problem. In this paper, we study the parameterized algorithms for the \(MVCP_3\) problem when the underlying graph G is parameterized by the treewidth. Given an n-vertex graph together with its tree decomposition of width at most p, we present an algorithm running in time \(4^{p}\cdot n^{O(1)}\) for the \(MVCP_3\) problem. Moreover, we show that for the \(MVCP_3\) problem on planar graphs, there is a subexponential parameterized algorithm running in time \(2^{O(\sqrt{k})}\cdot n^{O(1)}\) where k is the size of the optimal solution.

This paper presents algorithms whose input is an undirected graph, and whose output is a tree decomposition of width that approximates the optimal, the treewidth of that graph. The algorithms differ in their computation time and their approximation guarantees. The first algorithm works in polynomial-time and finds a factor-O(log OPT) approximation, where OPT is the treewidth of the graph. This is the first polynomial-time algorithm that approximates the optimal by a factor that does not depend on n, the number of nodes in the input graph. As a result, we get an algorithm for finding pathwidth within a factor of O(log OPT⋅log n) from the optimal. We also present algorithms that approximate the treewidth of a graph by constant factors of 3.66, 4, and 4.5, respectively and take time that is exponential in the treewidth. These are more efficient than previously known algorithms by an exponential factor, and are of practical interest. Finding triangulations of minimum treewidth for graphs is central to many problems in computer science. Real-world problems in artificial intelligence, VLSI design and databases are efficiently solvable if we have an efficient approximation algorithm for them. Many of those applications rely on weighted graphs. We extend our results to weighted graphs and weighted treewidth, showing similar approximation results for this more general notion. We report on experimental results confirming the effectiveness of our algorithms for large graphs associated with real-world problems.

The maximum number of 10- and 12-cycles in a planar graph