FPT Algorithms and Kernels for the Directed $k$-Leaf Problem

A subgraph $T$ of a digraph $D$ is an {\em out-branching} if $T$ is an oriented spanning tree with only one vertex of in-degree zero (called the {\em root}). The vertices of $T$ of out-degree zero are {\em leaves}. In the {\sc Directed $k$-Leaf} Problem, we are given a digraph $D$ and an integral parameter $k$, and we are to decide whether $D$ has an out-branching with at least $k$ leaves. Recently, Kneis et al. (2008) obtained an algorithm for the problem of running time $4^{k}\cdot n^{O(1)}$. We describe a new algorithm for the problem of running time $3.72^{k}\cdot n^{O(1)}$. In {\sc Rooted Directed $k$-Leaf} Problem, apart from $D$ and $k$, we are given a vertex $r$ of $D$ and we are to decide whether $D$ has an out-branching rooted at $r$ with at least $k$ leaves. Very recently, Fernau et al. (2008) found an $O(k^3)$-size kernel for {\sc Rooted Directed $k$-Leaf}. In this paper, we obtain an $O(k)$ kernel for {\sc Rooted Directed $k$-Leaf} restricted to acyclic digraphs.

💡 Research Summary

The paper addresses two central questions concerning the Directed k‑Leaf problem, a parameterized version of finding an out‑branching (a spanning arborescence) with at least k leaves in a directed graph D. The first contribution is a faster fixed‑parameter tractable (FPT) algorithm, improving on the previously best known 4^k·n^{O(1)} running time (Kneis et al., 2008) to 3.72^k·n^{O(1)}. The second contribution is a linear‑size kernel for the rooted variant of the problem when the input digraph is acyclic.

Background and definitions.
An out‑branching is a directed spanning tree with a unique root (in‑degree 0). Leaves are vertices of out‑degree 0. The Directed k‑Leaf problem asks whether D contains an out‑branching with at least k leaves. The rooted version additionally fixes a vertex r that must be the root. Prior work established FPT algorithms for all digraphs (Bonsma & Dorn, 2009; Kneis et al., 2008) and an O(k^3) kernel for the rooted problem (Fernau et al., 2008). However, no polynomial kernel is possible for the unrooted version unless the polynomial hierarchy collapses.

Improved FPT algorithm.
The authors start from the recursive framework of Kneis et al. but introduce a crucial preprocessing step (Step 2 of Algorithm A). For each leaf x of the current partial out‑tree T that is not already forced to be a leaf (i.e., x∉L), they test whether ℓ_max(D,T,L∪{x}) = 0, where ℓ_max denotes the maximum number of leaves achievable by extending (T,L) to a full out‑branching. If this test succeeds, x can never be a leaf in any feasible solution, so all its outgoing arcs are added to T and x is turned into an internal vertex. This “leaf‑to‑internal conversion” eliminates many fruitless branches early in the search tree.

The correctness of this conversion relies on Lemma 2.3 (which expresses ℓ_max(D,T,L) as the maximum of the two cases where a leaf is forced to stay a leaf or is forced to become internal) and Lemma 2.5 (which refines the case analysis when the subtree rooted at x contains more than one leaf). By repeatedly applying these lemmas, the algorithm guarantees that every recursive call works on a proper (D,T,L) triple and that no optimal solution is lost.

The recursion proceeds by picking an undecided leaf x, branching on the two possibilities (keep x as a leaf, or convert it using the T_root(D,L,x) construction), and recursing on the resulting instances. Because the preprocessing step often reduces ℓ_max, the depth of the recursion is bounded more tightly than in the original 4^k algorithm. A careful counting argument shows that the number of leaves in the recursion tree is at most 3.72^k, yielding the claimed running time O(3.72^k·n^{O(1)}). The algorithm remains polynomial‑space and can be implemented with standard graph data structures.

Linear kernel for acyclic digraphs.
For acyclic digraphs, the rooted and unrooted versions coincide: there is a unique vertex of in‑degree 0, which must be the root of any out‑branching. The authors exploit this structural property to design a kernelization procedure that reduces any instance (D,k) to an equivalent instance (D’,k’) with |V(D’)| = O(k). The reduction rules are:

1. Degree‑1 leaf rule: If a vertex has out‑degree 1, it must be a leaf in any solution; add it to L and delete it.
2. Degree‑≥ 2 internal rule: Vertices of out‑degree at least 2 can be forced to be internal; their incident arcs are retained but the vertex itself is kept only if it contributes to reaching k leaves.
3. Unreachable removal: Vertices not reachable from the unique source are deleted, as they cannot belong to any out‑branching.

Repeated application of these rules shrinks the graph while preserving the existence of an out‑branching with ≥ k leaves. The authors prove (Lemma 4.1) that after exhaustive reduction the number of remaining vertices is at most 2k − 2, establishing an O(k) kernel (Theorem 4.2). The reduction runs in linear time O(n+m).

Implications and open problems.
The new exponent 3.72 brings the algorithm close to the threshold asked by Fellows et al. (2014), who wondered whether a running time f(k)·n^{O(1)} with f(50) < 10^{20} exists. While the paper does not fully resolve this, it dramatically narrows the gap. The linear kernel for acyclic digraphs shows that, under structural restrictions, the Directed k‑Leaf problem admits much more efficient preprocessing than in the general case. Future work may aim at (i) further reducing the exponential base for arbitrary digraphs, (ii) extending linear kernels to broader graph classes (e.g., bounded directed tree‑width), and (iii) empirical evaluation on real‑world networks where leaf‑maximizing arborescences have applications (e.g., broadcast trees, phylogenetic reconstruction).

Conclusion.
Overall, the paper delivers two significant advances: a faster FPT algorithm with base 3.72 and a linear‑size kernel for the rooted problem on acyclic digraphs. Both results deepen our understanding of the parameterized complexity of leaf‑maximization in directed graphs and open promising avenues for both theoretical refinement and practical algorithm design.