81 research outputs found

### Positive-Instance Driven Dynamic Programming for Treewidth

Consider a dynamic programming scheme for a decision problem in which all
subproblems involved are also decision problems. An implementation of such a
scheme is {\em positive-instance driven} (PID), if it generates positive
subproblem instances, but not negative ones, building each on smaller positive
instances.
We take the dynamic programming scheme due to Bouchitt\'{e} and Todinca for
treewidth computation, which is based on minimal separators and potential
maximal cliques, and design a variant (for the decision version of the problem)
with a natural PID implementation. The resulting algorithm performs extremely
well: it solves a number of standard benchmark instances for which the optimal
solutions have not previously been known. Incorporating a new heuristic
algorithm for detecting safe separators, it also solves all of the 100 public
instances posed by the exact treewidth track in PACE 2017, a competition on
algorithm implementation.
We describe the algorithm, prove its correctness, and give a running time
bound in terms of the number of positive subproblem instances. We perform an
experimental analysis which supports the practical importance of such a bound.Comment: A preliminary and abridged version appeared in ESA 201

### A contraction-recursive algorithm for treewidth

Let tw(G) denote the treewidth of graph G. Given a graph G and a positive
integer k such that tw(G) <= k + 1, we are to decide if tw(G) <= k. We give a
certifying algorithm RTW ("R" for recursive) for this task: it returns one or
more tree-decompositions of G of width <= k if the answer is YES and a minimal
contraction H of G such that tw(H) > k otherwise.
RTW uses a heuristic variant of Tamaki's PID algorithm for treewidth
(ESA2017), which we call HPID. RTW, given G and k, interleaves the execution of
HPID with recursive calls on G /e for edges e of G, where G / e denotes the
graph obtained from G by contracting edge e. If we find that tw(G / e) > k,
then we have tw(G) > k with the same certificate. If we find that tw(G / e) <=
k, we "uncontract" the bags of the certifying tree-decompositions of G / e into
bags of G and feed them to HPID to help progress. If the question is not
resolved after the recursive calls are made for all edges, we finish HPID in an
exhaustive mode. If it turns out that tw(G) > k, then G is a certificate for
tw(G') > k for every G' of which G is a contraction, because we have found tw(G
/ e) <= k for every edge e of G. This final round of HPID guarantees the
correctness of the algorithm, while its practical efficiency derives from our
methods of "uncontracting" bags of tree-decompositions of G / e to useful bags
of G, as well as of exploiting those bags in HPID.
Experiments show that our algorithm drastically extends the scope of
practically solvable instances. In particular, when applied to the 100
instances in the PACE 2017 bonus set, the number of instances solved by our
implementation on a typical laptop, with the timeout of 100, 1000, and 10000
seconds per instance, are 72, 92, and 98 respectively, while these numbers are
11, 38, and 68 for Tamaki's PID solver and 65, 82, and 85 for his new solver
(SEA 2022).Comment: 17 pages, 2 figures, submitted IPEC 202

### Treedepth Parameterized by Vertex Cover Number

To solve hard graph problems from the parameterized perspective, structural parameters have commonly been used. In particular, vertex cover number is frequently used in this context. In this paper, we study the problem of computing the treedepth of a given graph G. We show that there are an O(tau(G)^3) vertex kernel and an O(4^{tau(G)}*tau(G)*n) time fixed-parameter algorithm for this problem, where tau(G) is the size of a minimum vertex cover of G and n is the number of vertices of G

### An Improved Fixed-Parameter Algorithm for One-Page Crossing Minimization

Book embedding is one of the most well-known graph drawing models and is extensively studied in the literature. The special case where the number of pages is one is of particular interest: an embedding in this case has a natural circular representation useful for visualization and graphs that can be embedded in one page without crossings form an important graph class, namely that of outerplanar graphs.
In this paper, we consider the problem of minimizing the number of crossings in a one-page book embedding, which we call one-page crossing minimization. Here, we are given a graph G with n vertices together with a non-negative integer k and are asked whether G can be embedded into a single page with at most k crossings. Bannister and Eppstein (GD 2014) showed that this problem is fixed-parameter tractable. Their algorithm is derived through the application of Courcelle\u27s theorem (on graph properties definable in the monadic second-order logic of graphs) and runs in f(L)n time, where L = 2^{O(k^2)} is the length of the formula defining the property that the one-page crossing number is at most k and f is a computable function without any known upper bound expressible as an elementary function. We give an explicit dynamic programming algorithm with a drastically improved running time of 2^{O(k log k)}n

### Constant-factor approximations of branch-decomposition and largest grid minor of planar graphs in O(n1+Ïµ) time

AbstractWe give constant-factor approximation algorithms for computing the optimal branch-decompositions and largest grid minors of planar graphs. For a planar graph G with n vertices, let bw(G) be the branchwidth of G and gm(G) the largest integer g such that G has a gÃ—g grid as a minor. Let câ‰¥1 be a fixed integer and Î±,Î² arbitrary constants satisfying Î±>c+1 and Î²>2c+1. We give an algorithm which constructs in O(n1+1clogn) time a branch-decomposition of G with width at most Î±bw(G). We also give an algorithm which constructs a gÃ—g grid minor of G with gâ‰¥gm(G)Î² in O(n1+1clogn) time. The constants hidden in the Big-O notations are proportional to cÎ±âˆ’(c+1) and cÎ²âˆ’(2c+1), respectively

### Spanning trees crossing few barriers

We consider the problem of finding low-cost spanning trees for sets of n points in the plane,
where the cost of a spanning tree is defined as the total number of intersections of tree edges
with a given set of m barriers. We obtain the following results:
(i) if the barriers are possibly intersecting line segments, then there is always a spanning
tree of cost O(min(m2,m SQRT(n)));
(ii) if the barriers are disjoint line segments, then there is always a spanning tree of cost
O(m);
(iii) if the barriers are disjoint convex objects, then there is always a spanning tree of cost
O(n + m).
All our bounds are worst-case optimal

- â€¦