fpt by treewidth and degree

This work addresses efficient algorithms for bipartiteness-related graph problems—including $K_t$-subgraph covering, odd-cycle transversal, and maximum weighted cut—by introducing a novel graph width parameter: *bipartite treewidth* (btw), which unifies treewidth and odd-cycle transversal number. Building upon an enhanced tree decomposition framework, we develop the first dynamic programming paradigm tailored to btw, yielding fixed-parameter tractable (FPT) algorithms for multiple NP-hard problems. Furthermore, for any 2-connected graph $H$, we establish a complexity dichotomy theorem for $H$-odd-subgraph packing and related problems: under the btw parameterization, we precisely delineate the boundary between para-NP-completeness and XP-solvability. Integrating parameterized algorithmics, dynamic programming, and structural graph modeling, this work substantially extends the applicability of the treewidth framework to non-bipartite graph problems.

This work investigates the computational complexity and approximation algorithms for tree-partition-width. Regarding problem hardness, we establish that computing tree-partition-width exactly is XALP-complete—resolving a long-standing open question—and derive as a corollary the XALP-completeness of domino treewidth. We further characterize structural relationships between tree-partition-width and tree-cut width. Methodologically, we design the first polynomial-time O(k⁷)-approximation algorithm, running in kᴼ(¹)n² time, and prove that the problem is W[t]-hard for all t, revealing its intrinsic parameterized intractability. Collectively, our results precisely situate tree-partition-width within the sparse graph parameterization landscape: they resolve fundamental gaps concerning both exact solvability (via XALP-completeness) and efficient approximability (via the first nontrivial approximation guarantee), thereby providing a comprehensive theoretical foundation for this structural graph parameter.

This paper addresses the problem of efficiently maintaining tree decompositions for dynamic graphs under edge insertions and deletions, specifically for graphs with treewidth at most $k$, aiming to sustain a tree decomposition of width at most $9k+8$ and support dynamic programming queries over it. The method introduces the novel concept of *downward well-linked* tree decompositions and integrates a splay-tree-inspired local rotation mechanism with amortized analysis. This yields the first fully dynamic algorithm achieving $O_k(log n)$ amortized update time—breaking the previous best $O_k(n^{o(1)})$ bound established at FOCS’23. Moreover, the approach enables a practical realization of the dynamic Courcelle’s theorem: it reduces the dependence on $n$ from $n^{o(1)}$ to $log n$, while delivering a simpler structural design and a more unified analytical framework.

This work addresses the computational complexity and approximability of treewidth. Using a direct, self-contained reduction from 3-SAT to treewidth—bypassing indirect approaches via cutwidth or pathwidth—the authors achieve a technical breakthrough through refined analysis of graph expansion and tree decompositions. Their contributions are threefold: (1) They establish NP-hardness of computing a 1.00005-approximation to treewidth, thereby proving that no polynomial-time algorithm can achieve this approximation factor unless P = NP; (2) Assuming the Exponential Time Hypothesis (ETH), they prove a tight lower bound of $2^{Omega(n)}$ for exact treewidth computation on $n$-vertex graphs; (3) For any constant $delta > 1$, they show that $delta$-approximation requires $2^{Omega(n / log^c n)}$ time for some $c > 0$. This resolves long-standing open questions regarding the tightness of treewidth lower bounds and fills a critical gap in parameterized complexity theory.

This paper studies the parameterized Vertex Cover problem, aiming to break the long-standing O*(1.2738^k) time-complexity lower bound established by Chen, Kanj, and Xia (2010). We introduce the first potential function jointly tracking both the solution size k and the optimal value λ of the LP relaxation. Based on this, we design novel branching rules to overcome local obstructions in the search tree. Our algorithm integrates LP-based preprocessing, structural analysis of maximum independent sets, and over-approximation techniques for vertex cover. Through meticulous potential-function analysis, we achieve tight control over the branching process in the branch-and-bound framework. The resulting deterministic algorithm runs in O*(1.25284^k) time—currently the fastest known parameterized algorithm for Vertex Cover—and significantly advances the theoretical time bound for this fundamental problem.

本文研究了在局部度约束下计算最小生成树的问题，通过不同参数化方法（如树深）探讨了三种形式问题的复杂性差异。

This paper establishes lower bounds for pure dynamic programming (DP) algorithms solving connectivity problems—such as the Traveling Salesman Problem (TSP)—on graphs of bounded pathwidth. It addresses the open question of whether algebraic techniques (e.g., convolution, determinant computation) are inherently necessary to achieve optimal worst-case time complexity. Method: The authors forge a novel connection between tropical circuit complexity and nondeterministic communication complexity, integrating compatibility matrix construction with structural characterizations of pathwidth-k graphs. Contribution/Results: They prove that any pure DP algorithm for such problems requires at least $2^{Omega(k log log k)}$ state transition units on graphs of pathwidth $k$. This is the first exponential lower bound for canonical problems like TSP within the pure DP framework, breaking the prior dominance of algebraic-method-based analyses. The result rigorously confirms the indispensability of algebraic techniques for achieving optimal time complexity in this setting.

Traditional tree decomposition–based dynamic programming struggles to scale to large graphs, limiting its applicability to NP-hard graph optimization problems. This work proposes a general-purpose enhancement framework that overcomes this limitation by efficiently constructing treewidth modulators to partition the original graph into an easily solvable component and a residual subgraph of small treewidth. The framework seamlessly integrates heuristic methods—such as greedy algorithms, evolutionary search, and graph neural networks—with tree decomposition–based dynamic programming in a synergistic manner. Notably, it introduces tree decomposition–based dynamic programming as a universal booster applicable across diverse heuristic paradigms. Empirical evaluations on the maximum independent set, minimum vertex cover, and maximum cut problems demonstrate substantial performance gains over baseline algorithms; remarkably, the enhanced greedy approach matches or even surpasses state-of-the-art commercial solvers.

This work addresses classical parameterized graph problems—including $k$-Path, MaxLeaf SubTree, and Tree Multicut—under memory-constrained settings. Moving beyond conventional vertex/edge deletion paradigms, we introduce a novel graph structural compression scheme coupled with lightweight tree decomposition traversal. Our approach integrates controlled recursion depth with polylogarithmic-space dynamic programming. This yields the first unified framework achieving $f(k) cdot mathrm{poly}(n)$ time and $g(k) cdot mathrm{polylog}(n)$ space complexity for these problems. Crucially, our algorithms avoid $Omega(mathrm{poly}(n))$ memory overhead, enabling scalability from gigabyte- to terabyte-scale graphs. The proposed methods significantly alleviate memory bottlenecks in large-scale graph processing and constitute the first systematic sublinear-space solution for parameterized graph computation in memory-sensitive environments.

This work proposes a randomized algorithm for the Hamiltonian cycle and path problems on graphs of tree-depth τ, achieving a running time of 4^τ·n^{O(1)} while using only polynomial space. The key innovation lies in introducing a novel representation termed “ordered consistent matching pairs,” which replaces the conventional use of perfect matchings in auxiliary graphs within dynamic programming frameworks. This new formulation enables more efficient state transitions in the dynamic programming process, thereby improving the time complexity from the previous best-known 5^τ to 4^τ for polynomial-space algorithms parameterized by tree-depth. To the best of our knowledge, this constitutes the fastest known polynomial-space algorithm for these problems under the tree-depth parameterization.