Composing dynamic programming tree-decomposition-based algorithms

Given two integers $\ell$ and $p$ as well as $\ell$ graph classes $\mathcal{H}_1,\ldots,\mathcal{H}_\ell$, the problems $\mathsf{GraphPart}(\mathcal{H}_1, \ldots, \mathcal{H}_\ell,p)$, \break $\mathsf{VertPart}(\mathcal{H}_1, \ldots, \mathcal{H}_\ell)$, and $\mathsf{EdgePart}(\mathcal{H}_1, \ldots, \mathcal{H}_\ell)$ ask, given graph $G$ as input, whether $V(G)$, $V(G)$, $E(G)$ respectively can be partitioned into $\ell$ sets $S_1, \ldots, S_\ell$ such that, for each $i$ between $1$ and $\ell$, $G[S_i] \in \mathcal{H}_i$, $G[S_i] \in \mathcal{H}_i$, $(V(G),S_i) \in \mathcal{H}_i$ respectively. Moreover in $\mathsf{GraphPart}(\mathcal{H}_1, \ldots, \mathcal{H}_\ell,p)$, we request that the number of edges with endpoints in different sets of the partition is bounded by $p$. We show that if there exist dynamic programming tree-decomposition-based algorithms for recognizing the graph classes $\mathcal{H}_i$, for each $i$, then we can constructively create a dynamic programming tree-decomposition-based algorithms for $\mathsf{GraphPart}(\mathcal{H}_1, \ldots, \mathcal{H}_\ell,p)$, $\mathsf{VertPart}(\mathcal{H}_1, \ldots, \mathcal{H}_\ell)$, and $\mathsf{EdgePart}(\mathcal{H}_1, \ldots, \mathcal{H}_\ell)$. We apply this approach to known problems. For well-studied problems, like VERTEX COVER and GRAPH $q$-COLORING, we obtain running times that are comparable to those of the best known problem-specific algorithms. For an exotic problem from bioinformatics, called DISPLAYGRAPH, this approach improves the known algorithm parameterized by treewidth.


Introduction
In one of the first graph partition problems, one is asked, given a graph G and an integer k, whether V (G) can be partitioned into ℓ sets V 1 , . . ., V ℓ such that the number of edges between two different sets is small, see for instance Goldschmidt and Hochbaum (1994).These problems have many applications starting from clustering genes by Sharan et al. (2003), through optimizing financial problems by Mezuman and Weiss (2012), parallel scientific computing to image segmentation by Grady and Schwartz (2006) and Torres and Monteiro (2012), and analysis of social networks by Qian et al. (2010).The above specified graph partitioning problem favors cutting small sets of isolated vertices in the input graph as shown by Shi and Malik (2000) and Wu and Leahy (1993).In order to avoid this kind of solution which is often undesirable for many practical applications, restrictions are often imposed on the sets V i , i ∈ [1, ℓ].The most natural restriction is to require the partition to be balanced as done by Andreev and Racke (2006).Another one, used in image segmentation, is to consider normalized cuts as done by Shi and Malik (2000), that is, cuts that maximize the similarity within the sets while minimizing the dissimilarity between the 2 Julien Baste sets.In social networks, the graph clustering problem is a graph partition problem where the graphs G[V i ], i ∈ [1, ℓ], are required to be dense as studied by Schaeffer (2007).In this paper, we consider the graph partition problem in a general form defined in the following way.Given ℓ graph classes H 1 , . . ., H ℓ and an integer p, the GraphPart(H 1 , . . ., H ℓ , p) problem consists in, given a graph G, determining whether V (G) can be partitioned into ℓ sets V 1 , . . ., V ℓ such that {{u, v} ∈ E(G) | u ∈ V i , v ∈ V j , i = j}, i.e., the set of transversal edges, is of size at most p and G[V i ] ∈ H i for each i ∈ [1, ℓ].
Coloring problems are special kinds of graph partition problems where the number of transversal edges is not relevant anymore.So, in the VertPart(H 1 , . . ., H ℓ ) problem, the task is to determine whether the vertex set of the input graph G can be partitioned into ℓ sets V 1 , . . ., V ℓ such that G[V i ] ∈ H i for each i ∈ [1, ℓ].The most famous coloring problem is the GRAPH 3-COLORABILITY problem corresponding to VertPart(I, I, I) where I is the class of edgeless graphs.This problem is one of the first problems proved to be NP-hard by Karp (1972) and has attracted a lot of attention.While GRAPH 3-COLORABILITY is the best known, several other graph classes are also under study.For instance, Yang and Yuan (2004), Rajasingh and Shanthi (2013), and Yuan and Wang (2003) consider the induced matching partition where each vertex set of the partition should induce a graph of maximum degree 1. Chang et al. (2004) focus on VertPart(H 1 , . . ., H ℓ ) where ℓ is a fixed integer, H 1 = . . .= H ℓ = R, and R is either the class of every tree or the class of every forest.These problems are called TREE ARBORICITY when R is the class of every tree and VERTEX ARBORICITY when R is the class of every forest.They provide polynomial time algorithms for block-cactus graph, series-parallel graphs, and cographs.Yang and Yuan (2007) focus on planar graphs of diameter two.As shown by Janssen et al. (2019), these problems have, in particular, applications in bioinformatics for constructing phylogenetic trees.
The treewidth of a graph is a structural parameter that measures the similarity of the graph to a forest, see Section 2 for the formal definitions.Courcelle (1990) shows that every problem that can be expressed in monadic second-order logic can be solved in FPT-time parameterized by treewidth, i.e., in time f (tw) • n O(1) for some function f where n (resp.tw) denotes the number of vertices (resp.the treewidth) of the input graph.Rao (2007) shows that if there is a monadic second-order logic formula that recognizes a graph class H, then for any fixed integer ℓ, VertPart(H 1 , . . ., H ℓ ), with H i = H for all i ∈ [1, ℓ], can be solved in polynomial time on graphs of bounded treewidth.If Courcelle (1990) and Rao (2007) provide powerful meta-algorithms, the claimed running times may be far from being optimal.For instance, Courcelle (1990) provides an 2 2 O(tw) • n O(1) algorithm for GRAPH 3-COLORING when it is well known that an 2 O(tw) • n O(1) algorithm exists, see for instance (Cygan et al., 2015, Theorem 7.9).
Recently, treewidth has found several applications in bioinformatics when dealing with the so-called display graphs as illustrated in the work of Bryant and Lagergren (2006), Scornavacca et al. (2014), andBaste et al. (2017).In order to solve the DISPLAYGRAPH problem, Janssen et al. (2019) want to determine whether a given graph of bounded treewidth is a positive instance of VertPart(T , T ) where T is the class of all trees.Using Courcelle's theorem, they provide a 2 2 O(tw) • n O(1) algorithm.Using the approach developed in this paper, we obtain, as Corollary 14, an algorithm running in time 2 O(tw) • n O(1)  for this same problem.
The dynamic programming core model is a formalism introduced by Baste et al. (2022).It was first introduced in order to construct meta-algorithms for what are called diverse problems.It provides a formalism for dynamic programming algorithms that process a tree decomposition, once, in a bottom-up approach.This kind of algorithm is indeed widely used when working with treewidth.Therefore the dynamic programming core model allows us to manipulate most of the known algorithms that process a tree decomposition.
In the present paper, we use the expressive power of this formalism and show that, with some enhancement, it can be used to easily provide algorithms, with good running times, that solve the graph partition problems parameterized by treewidth.Roughly speaking, given ℓ graph classes H 1 , . . ., H ℓ , we show that solving GraphPart(H 1 , . . ., H ℓ , p) or VertPart(H 1 , . . ., H ℓ ) is not much harder than recognizing each H i , using a dynamic programming tree-decomposition-based algorithm.Moreover, we provide, in Theorem 10 and Theorem 11, the explicit running time needed for solving GraphPart(H 1 , . . ., H ℓ , p) and VertPart(H 1 , . . ., H ℓ ) respectively as a function of the running time needed for recognizing each H i .We provide, in Theorem 12, similar result for the case where we want to partition the edge set of the graph, that is, for the graph problem EdgePart(H 1 , . . ., H ℓ ) that, given a graph G, consists in determining whether E(G) can be partitioned into ℓ sets S 1 , . . ., S ℓ such that (V (G), The main feature of our contribution is to present a meta-approach that provides easy-to-build and efficient algorithms for exotic problems.Moreover the running time obtained for known problems are comparable to the best-known algorithms specifically designed for each given known problem.
In Section 2, we introduce the notations and useful definitions.Section 3 is devoted to the definition of the dynamic programming core model together with some examples of dynamic cores.The main results are given in Section 4. In Section 5, we show how these results can be applied to reproduce known results and to provide unknown algorithms for exotic problems.We provide a short conclusion in Section 6.

Preliminaries
We denote by N the set of nonnegative integers.Given two integers a and b we define [a, b] the set of every integer c such that a ≤ c ≤ b.Let G be a graph.Let ℓ be an integer and A = (m 1 , . . ., m ℓ ) be a ℓ-tuple.For each i ∈ [1, ℓ], we use the notation A.(i) to refer to the i-th coordinate of A, i.e., in this case to m i .Note that the coordinates are numbered from 1 to ℓ.Given a set S, we denote by 2 S the set of every subset of S. Given an alphabet Σ, we denote by W Σ the set of every finite words over Σ.We denote by Γ the set of three special letters denoted "(", ")", and ",".
We use V (G) and E(G) to denote the vertex and edge sets, respectively, of the graph G. Through out this paper, we assume that vertices are represented as elements of N. Given a set S ⊆ V (G), we denote by G[S] the subgraph of G induced by S. Given a set S ⊆ E(G), we denote by G[S] the graph (V (G), S).Given two sets S 1 , S 2 ⊆ V (G), we denote by edge G (S 1 , S 2 ) the set of every edge of G with one endpoint in S 1 and the other endpoint in S 2 .We also denote by G the set of every graph.We denote by I the class of edgeless graphs.Given an integer p, we denote by G p the class of every graph with at most p vertices.We also denote by T the set of every tree and by F the set of every forest.Given a tree T rooted at r, for each t ∈ V (T ), we denote by child(t) the set of every child of t in T and by desc(t) the set of every descendent of t in T .
A rooted tree decomposition of a graph G is a tuple D = (T, r, X ), where T is a tree rooted at r ∈ V (T ) and • for every edge {u, v} ∈ E, there is a t ∈ V (T ) such that {u, v} ⊆ X t , and • for each {x, y, z} ⊆ V (T ) such that z lies on the unique path between x and y in T , X x ∩X y ⊆ X z .
The width of a tree decomposition D = (T, r, X ), denoted by w(D), is defined as max t∈V (T ) |X t | − 1.The treewidth of a graph G, denoted by tw(G), is the smallest integer w such that there exists a tree decomposition of G of width at most w.We also define It is well known, see for instance Kloks (1994), that given a rooted tree decomposition D = (T, r, X ), we can, without loss of generality, assume that X r = ∅, that, for each t ∈ V (T ), t has at most 2 children and that |Y t | ≤ |X t | + 1.In the following we always assume that the rooted tree decompositions have these properties.
Given a graph G, a rooted tree decomposition D = (T, r, X ) of G, and a set S ⊆ V (G), we define 3 Dynamic programming core model In this section we define and use an improvement of the dynamic programming core model introduced by Baste et al. (2022).The main idea of this model is to formalize what is a dynamic programming algorithm based on a tree decomposition.This will allow us to manipulate these algorithms in their generic form in order to construct meta-algorithms.
Definition 1 (Dynamic Core).A dynamic core C over an alphabet Σ is a set of four functions: Σ , and In the following, we always assume that the associated alphabet is implicitly given when a dynamic core is mentioned and we denote by Σ C the alphabet associated to a dynamic core C. Given a dynamic core C, a graph G and a rooted tree decomposition D = (T, r, X ) of G, the data of C associated to (G, D) are, for each t ∈ V (T ): We would like to highlight that Definition 1 is the main addition of this paper, concerning the definition of the dynamic programming core model, compared to Baste et al. (2022).The functions Process C,0 , Process C,1 , and Process C,2 can be viewed as the rules to update the table of the given dynamic programming algorithm, and so allow to easily and naturally construct a dynamic core from a dynamic programming algorithm that is based on a tree decomposition.Note that these rules are given independently of the tree decomposition as it is usual to do for a dynamic programming algorithm.The definitions of Accept C,G,D and Process C,G,D , if we consider Σ = {0, 1}, are similar to the ones initially defined by Baste et al. (2022).
Note that, in this work, we assume that X r = ∅ and so Accept C,G,D = Accept C ((∅, ∅)).We still keep the general notation, with X r , to keep the setting as flexible as possible.Given a function f : K → J and an input I ∈ K, we denote by τ (f, I) the time needed to compute f (I).Given a dynamic core C, a graph G and a rooted tree decomposition D = (T, r, X ) we let: The n of τ n stands for node, and the g of τ g stands for global.Note that, for each Definition 2. Let C be a dynamic core, G be a graph in G, and D = (T, r, X ) be a rooted tree decom- The witness provided in Definition 2 can be seen as a proof of the correctness of the algorithms we can produce using a given dynamic core.
Definition 3. Let H be a class of graphs.We say that a dynamic core C solves H if for each graph G ∈ G, and each rooted tree decomposition D of G, G ∈ H if and only if a (C, G, D)-witness exists.
As explained by Baste et al. (2022) and summarized in Theorem 4, a dynamic core can be seen as an algorithm producer.Moreover the running time of the produced algorithms is directly connected to the definition of the associated dynamic core.
Theorem 4 (Baste et al. (2022)).Let H be a class of graphs and C be a dynamic core that solves H.

Some examples of dynamic core
In this section we provide a few examples of dynamic cores.We start by a trivial dynamic core that allows us to produce an algorithm that recognizes that a graph has no edge.This dynamic core solves I, the class of graphs with no edges.
Observation 5. I can be solved by a polynomial dynamic core C.
In this case, Σ C = {⊤} where ⊤ represents the fact that the already explored part does not contain any edge.Given G ∈ I and D = (T, r, X ) a rooted tree decomposition of G, a (C, G, D)-witness α is such that, for each t ∈ V (T ), α(t) = ⊤.
For the running time, note that given a graph G and a rooted tree decomposition We also provide a slightly more involved dynamic core that solves G p for some integer p, i.e., the class of graphs with at most p vertices.Observation 6.Let p be an integer.G p can be solved by a polynomial dynamic core C.
It is now an easy task to show that C solves G p .In this case, given a graph G ∈ G p and a rooted tree decomposition D = (T, r, X ), a possible (C, G, D)-witness α is such that, for each t ∈ V (T ), α(t) = |Z t \ X t |.Simply note that we only count the number of vertices in the part that has already been completely explored and forgotten and that X r = ∅.
For the running time, note that given a graph G and a rooted tree decomposition Observations 5 and 6 show how to construct a dynamic core for trivially solvable problems.We mostly provided these observations as pedagogical examples.One can then get the intuition that most of the dynamic programming algorithms parameterized by treewidth can be translated into dynamic cores.Indeed, such an algorithm creates a dynamic programming table for each node of the tree decomposition.Theses tables are updated depending of dynamic programming tables of the children of the node taken into consideration.Transposing how these updates are done into a consistent definition of Process C,0 , Process C,1 , or Process C,2 , depending on the number of children of the node taken in consideration, will then provide a dynamic core for the problem.
The rank-based approach, developed by Bodlaender et al. (2015), provides, in particular, a deterministic algorithm that solves FEEDBACK VERTEX SET in time 2 O(tw) • n O(1) , where n (resp.tw) stands for the size (resp.treewidth) of the input graph.From this algorithm, one can easily obtain a dynamic core for recognizing if a graph is a tree.We omit the proof of it as it requires to reintroduce several tools presented by Bodlaender et al. (2015) that are out of the scope of this paper.
Observation 7. The class T of trees can be solved by a dynamic core C such that, for each graph G, each rooted tree decomposition D = (T, r, X ) of G, and each t ∈ V (T ): Note in particular that the dynamic core provided in Observation 7 is not polynomial.

Union and intersection of dynamic core
In this section we provide some simple combinations of dynamic cores.More precisely, we show how to take the union and the intersection of two dynamic cores.This will allow us, in Theorems 10, 11, and 12, to consider the union (resp.intersection) of recognizable classes without having to prove each time that the considered union (resp.intersection) is recognizable.Let H 1 and H 2 be two graph classes and let C 1 (resp.C 2 ) be a dynamic core that solves H 1 (resp.H 2 ).We would like to stress that, in order to solve H 1 ∪ H 2 or H 1 ∩ H 2 , the naive procedure, consisting of using C 1 and then using C 2 , would be more efficient with regard to the running time but will not produce a dynamic core.As the main theorems of the paper, namely Theorems 10, 11, and 12, rely on the knowledge of a dynamic core, this naive procedure will not suit.
Lemma 8. Let ℓ be an integer, let H 1 , . . ., H ℓ be graph classes and let, for each i ∈ [1, ℓ], C i be a dynamic core that solves H i .There exists a dynamic core C that solves H = i∈[1,ℓ] H i such that, for each graph G, each rooted tree decomposition D = (T, r, X ) of G, and each t ∈ V (T ): We now prove that C solves H. First note that Let G be a graph and D = (T, r, X ) be a rooted tree decomposition of G.

Assume first that G ∈ H, then by definition of H, for each
Ci be a (C i , G, D)-witness.Note that it exists as C i solves H i and G ∈ H i .We define α : V (T ) → Σ * C such that for each t ∈ V (T ), α(t) = (α 1 (t), . . ., α ℓ (t)).By construction of C, α is a (C, G, D)-witness.
Assume now that there exists a (C, G, D)-witness α : Let us now analyze the needed running time for this algorithm.Let G be a graph and D = (T, r, X ) be a rooted tree decomposition of G.For each t ∈ V (T ), we have, by definition, In order to construct the data of C associated to (G, D), we need first to construct the data of C i associated to (G, D) for each i ∈ [1, ℓ] and then to combine them.Thus, we have Lemma 9. Let ℓ be an integer, let H 1 , . . ., H ℓ be graph classes and let, for each i ∈ [1, ℓ], C i be a dynamic core that solves H i .There exists a dynamic core C that solves H = i∈[1,ℓ] H i such that, for each graph G, each rooted tree decomposition D = (T, r, X ) of G, and each t ∈ V (T ): Proof: Let ⊥ be an unused letter.We define C such that for each G, G ′ , G ′′ ∈ G, We prove, using the same kind of argumentation as for Theorem 8, that C solves H.Note that in this case, the letter ⊥ is used, in particular, for each coordinate i such that G ∈ H i .

Main theorem
In this section we show, given two integers ℓ and p, ℓ graph classes H 1 , .We start by the graph partition problem, that is the most involved case.
Theorem 10.Let ℓ and p be two integers, let H 1 , . . ., H ℓ be graph classes and let, for each i ∈ [1, ℓ], C i be a dynamic core that solves H i .There exists a dynamic core C that solves H = GraphPart(H 1 , . . ., H ℓ , p) such that, for each graph G, each rooted tree decomposition D = (T, r, X ) of G, and each t ∈ V (T ): ), q ≤ p, and ), q ≤ p, and Let G be a graph and D = (T, r, X ) be a rooted tree decomposition of G.
Assume first that G ∈ H.Then, by definition, there exists By construction of C, α is a (C, G, D)-witness.
Assume now that there exists a (C, G, D)-witness α : Then by definition of C, for each t ∈ V (T ), α(t) is a (ℓ + 1)-tuple where the ℓ first coordinates are pairs with the shape (m, V ) where m ∈ Σ * C and V ⊆ V (G), and where α(t).(ℓ Note also that by definition of Accept C , Process C,0 , Process C,1 , and Process C,2 , the partition selected by α at step t ∈ V (T ) \ {r} is consistent with the one selected at step t ′ where t ′ is the parent of t.Combined with the definition of a tree decomposition, we obtain that (V 1 , . . ., V ℓ ) is a partition of V (G).Moreover, as α is a (C, G, D)-witness, we have that α(r).(ℓ+ 1) ≤ p, and so G ∈ H.
Let us now analyze the needed running time for this algorithm.Let G be a graph and D = (T, r, X ) be a rooted tree decomposition of G. Then for each partition V 1 , . . ., V ℓ of Y t , there is at most (p + 1) 2 ways to combine p ′ and p ′′ and so there are at most (p + 1) 2 • i∈[1,ℓ] Size(C i , G, D, t) ways to construct an element of Process C,G,D (t) consistent with the partition.Moreover, we have ℓ |Yt| possible partitions of the set In order to construct the data of C associated to (G, D), we first need, for each i ∈ [1, ℓ], to construct the data of and then, for each t ∈ V (T ) try every partition of Y t and combine the corresponding data accordingly.Thus, we have The theorem follows.
Coloring problems are graph partition problems where it is not needed to keep track of the number of transversal edges.Thus the dynamic cores we present for the coloring problems are simpler than the one providing for the graph partition problems.
Theorem 11.Let ℓ be an integer, let H 1 , . . ., H ℓ be graph classes and let, for each i ∈ [1, ℓ], C i be a dynamic core that solves H i .There exists a dynamic core C that solves H = VertPart(H 1 , . . ., H ℓ ) such that, for each graph G, each rooted tree decomposition D = (T, r, X ) of G, and each t ∈ V (T ): Proof: Using the same base as for Theorem 10, we define C such that for each G, G ′ , G ′′ ∈ G, The proof that C solves H = VertPart(H 1 , . . ., H ℓ ) is omitted as it is similar to the one provided for Theorem 10 at the difference that this time we do not keep track of the transversal edges.
Edge partitioning problems are really similar to coloring problem at the difference that the subgraphs we consider are induced by a set of edges instead of a set of vertices.
Theorem 12. Let ℓ be an integer, let H 1 , . . ., H ℓ be graph classes and let, for each i ∈ [1, ℓ], C i be a dynamic core that solves H i .There exists a dynamic core C that solves H = EdgePart(H 1 , . . ., H ℓ ) such that, for each graph G, each rooted tree decomposition D = (T, r, X ) of G, and each t ∈ V (T ): The proof that C solves H = EdgePart(H 1 , . . ., H ℓ ) is omitted as it is, again, similar to the one provided for Theorem 10 at the difference that this time we partition over the edges instead of the vertices and there are no transversal edges to consider.

Applications
In this section we show how our results lead to significant simplification when looking for algorithms parameterized by treewidth.We first confront our approach against well-known problems, namely VERTEX COVER and GRAPH q-COLORING, showing that we obtain comparable running time.We then show how this leads to quickly obtain algorithms for exotic problems, VertPart(T , T ) in our example, for which describing an algorithm in the usual way would have been long and tedious.VERTEX COVER, corresponding to VertPart(G k , I) for some integer k, is well known to be solvable in time 2 w • n O(1) when a tree decomposition of width w of the input graph is given, see for instance (Cygan et al., 2015, Theorem 7.9), while, as shown by Impagliazzo et al. (2001), no algorithm running in time 2 o(tw) • n O(1) can solve it unless ETH fails.Combining Observation 5, Observation 6, and Theorem 11, we obtain a dynamic core that solves VERTEX COVER.Moreover, combined with Theorem 4, we obtain an algorithm solving VERTEX COVER in time 2 w • n O(1) when a tree decomposition of width w of the input graph is given.
More generally, deletion problems are problems that attract a lot of attention and that can be considered as coloring problems.Indeed, given a graph class H, the H-DELETION corresponds to the problem VertPart(G k , H), for some integer k.Moreover, we show, in Observation 6 that G p -RECOGNITION, for some integer p, has a polynomial dynamic core.Combining Observation 6 with Theorem 11, we obtain that if there exists a dynamic core such that recognizing H can be done in time 2 f (tw) • n O(1) for some function f , then H-DELETION can be solved in time 2 O(tw+f (tw)) • n O(1) .
The most basic and well-known coloring problem is GRAPH q-COLORING.Again we obtain an asymptotically optimal algorithm, see for instance (Cygan et al., 2015, Theorem 14.6 and Theorem 14.41), by combining Observation 5 and Theorem 11.
Corollary 13.GRAPH q-COLORING can be solved in time q w • n O(1) when a tree decomposition of width w of the input graph is given.
Proof: Given a fixed integer q, the GRAPH q-COLORING problem corresponds to VertPart(H 1 , . . ., H q ) where for each i ∈ [1, q], H i = I.The result follows from the combination of Observation 5 and Theorem 11.
As discussed in the introduction, finding an algorithm for VertPart(T , T ) parameterized by the treewidth of the input graph is a question of interest in bioinformatics.By combining Observation 7, Theorem 11, and Theorem 4, we obtain an efficient algorithm solving VertPart(T , T ).
To the best of our knowledge, the only other algorithm parameterized by treewidth for VertPart(T , T ) was known using Courcelle's theorem and run in time 2 2 O(tw) • n O(1) .

Conclusion
In this paper, we provide a generic tool for solving graph partition problems, coloring problems, and edge partition problems parameterized by the treewidth of the input graph.In particular, the developed approach provides a way, different than Courcelle's theorem, to determine whether a problem is FPT parameterized by treewidth and also provides a first estimation of the expected running time of an algorithm solving the given problem.We would like to highlight the quality of these estimations as, for some well-known problems, they are asymptotically optimal.
In this conclusion we want to stress that when solving graph partition problems, we count the number of transversal edges.The illustrated technique allows, for instance, with some small modifications, to count separately transversal edges between different vertex sets of the partition.One can ask for instance for a partition of the vertex set of the input graph into three sets V 1 , V 2 , V 3 such that there are k 1,2 edges between V 1 and V 2 , at most k 2,3 edges edges between V 2 and V 3 , and no edge between V 1 and V 3 for some integers k 1,2 and k 2,3 .
This approach also allows us to work with balanced partition.In this case, we first need to obtain the size of the input graph before constructing the dynamic core.Indeed we will need to intersect each graph class we consider with the class of graph of size q (or q + 1 if needed) for some correctly calculated q.For normalized cuts, this trick will not work as the target graph classes are not fixed before the algorithm starts to run.
More generally, we believe that using the dynamic programming core model, one can easily compose dynamic programming tree-decomposition-based algorithms with several added constraints.Moreover we also believe that it is adapted to quickly study exotic problems parameterized by treewidth.