A Space-efficient Parameterized Algorithm for the Hamiltonian Cycle Problem by Dynamic Algebraziation

TL;DR

This paper introduces space-efficient algorithms for Hamiltonian Cycle and Traveling Salesman problems using dynamic algebraization, significantly reducing space complexity with only a slight increase in time complexity.

Contribution

It presents novel polynomial space algorithms for these problems based on dynamic algebraization, improving over traditional exponential space methods.

Findings

Hamiltonian cycle solved in polynomial space with near-linear time complexity

Traveling Salesman problem addressed with polynomial space and efficient time complexity

Algorithm can count the number of Hamiltonian Cycles in the given graph

Abstract

An NP-hard graph problem may be intractable for general graphs but it could be efficiently solvable using dynamic programming for graphs with bounded width (or depth or some other structural parameter). Dynamic programming is a well-known approach used for finding exact solutions for NP-hard graph problems based on tree decompositions. It has been shown that there exist algorithms using linear time in the number of vertices and single exponential time in the width (depth or other parameters) of a given tree decomposition for many connectivity problems. Employing dynamic programming on a tree decomposition usually uses exponential space. In 2010, Lokshtanov and Nederlof introduced an elegant framework to avoid exponential space by algebraization. Later, F\"urer and Yu modified the framework in a way that even works when the underlying set is dynamic, thus applying it to tree decompositions. In this work, we design space-efficient algorithms to solve the Hamiltonian Cycle and the Traveling Salesman problems, using polynomial space while the time complexity is only slightly increased. This might be inevitable since we are reducing the space usage from an exponential amount (in dynamic programming solution) to polynomial. We give an algorithm to solve Hamiltonian cycle in time $\mathcal{O}((4w)^d\, nM(n\log{n}))$ using $\mathcal{O}(dn\log{n})$ space, where $M(r)$ is the time complexity to multiply two integers, each of which being represented by at most $r$ bits. Then, we solve the more general Traveling Salesman problem in time $\mathcal{O}((4w)^d poly(n))$ using space $\mathcal{O}(\mathcal{W}dn\log{n})$, where $w$ and $d$ are the width and the depth of the given tree decomposition and $\mathcal{W}$ is the sum of weights. Furthermore, this algorithm counts the number of Hamiltonian Cycles.

Figures

Equations

$$f^i[X]=\{\begin{array}{ll}0& \text{if }i<|X|,\\ f[X]& \text{if }i=|X|,\\ \text{arbitrary value}& \text{if }i>|X|.\end{array}$$

$$\zeta f[X]=\sum _{Y\subseteq X}f[Y].$$

$$\mu f[X]=\sum _{Y\subseteq X}(-1{)}^{|X\setminus Y|}f[Y].$$

$$\mu (\zeta f[X])=\zeta (\mu f[X])=f[X].$$

$$(f{\ast }_{R}g)[X]=\sum _{X_1\subseteq X}f(X_1)g(X\setminus X_1).$$

$$(f{\ast }_{u}g)[X]=\sum _{X_1\cup X_2=X}f(X_1)g(X_2).$$

$$\zeta (f{\ast }_{u}g)[X]=(\zeta f)\odot (\zeta g)[X].$$

$$f_x[X]=\{\begin{array}{ll}1& \text{if }X=\varnothing ,\\ 0& \text{otherwise}.\end{array}$$

$$f_x[X]=\sum _{⟨u,w⟩\in X}\sum _{Q\subseteq \{⟨u,v⟩,⟨v,w⟩\}}{d}_Q{f}_c[X\setminus \{⟨u,w⟩\}\cup Q],$$

$$f_x[X]=\{\begin{array}{ll}{f}_c[X]& \text{if }v\notin S_X,\\ 0& \text{otherwise}.\end{array}$$

$$f_x[X]=\sum _{X^{\prime }\subseteq X}{f}_{c_1}[X^{\prime }]f_{c_2}[X\setminus X^{\prime }]=(f_{c_1}{\ast }_R{f}_{c_2})[X].$$

$$(\zeta f_x^i)[X]=1,\text{ for all }i\text{ and }X.$$

$$f_x^i[X]=\sum _{⟨u,w⟩\in X}\sum _{Q\subseteq \{⟨u,v⟩,⟨v,w⟩\}}{d}_Q{f}_c^{i^{\prime }}[X\setminus \{⟨u,w⟩\}\cup Q],$$

$$(\zeta f_x^i)[X]=\sum _{Y\subseteq X}{f}_x^i[Y]$$

$$E_Q=\sum _{Y\subseteq X^{\prime }}{f}_c^{i-1}[Y]=\zeta f^{i-1}[X^{\prime }].$$

$$E_Q=\sum _{Y\subseteq X^{\prime }}{f}_c^i[Y\cup Q]=\zeta f_c^i[X^{\prime }\cup Q]-\zeta f_c^i[X^{\prime }].$$

$$E_Q$$

$$(\zeta f_x^i)[X]$$

$$f_x^i[X]=\{\begin{array}{ll}{f}_c^i[X]& \text{if }v\notin S_X,\\ 0& \text{otherwise}.\end{array}$$

$$(\zeta f_x^i)[X]=\sum _{Y\subseteq X}{f}_x^i[Y]=\sum _{Y\subseteq (X\setminus X_v)}{f}_c^i[Y]=(\zeta f_c^i)[X\setminus X_v].$$

$$(\zeta f_x^i)[X]=\sum _{j=0}^i(\zeta f_{c_1}^j)[X]\cdot (\zeta f_{c_2}^{i-j})[X],\text{ for }0\le i\le w,$$

$$P_x(y)[X]=\{\begin{array}{ll}1& \text{if }X=\varnothing ,\\ 0& \text{otherwise}.\end{array}$$

$$P_x(y)[X]=\sum _{⟨u,w⟩\in X}\sum _{Q\subseteq \{⟨u,v⟩,⟨v,w⟩\}}{d}_Q(P_c(y))[X\setminus \{⟨u,w⟩\}\cup Q],$$

$$P_x(y)[X]=\{\begin{array}{ll}{P}_c(y)[X]& \text{if }v\notin S_X,\\ 0& \text{otherwise}.\end{array}$$

$$f_x[X]=\sum _{X^{\prime }\subseteq X}{P}_{c_1}(y)[X^{\prime }]P_{c_2}(y)[X\setminus X^{\prime }].$$

Full text

In this work, we design space-efficient algorithms to solve the Hamiltonian Cycle and the Traveling Salesman problems, using polynomial space while the time complexity is only slightly increased. This might be inevitable since we are reducing the space usage from an exponential amount (in dynamic programming solution) to polynomial. We give an algorithm to solve Hamiltonian cycle in time $\mathcal{O}((4w)^{d}\,nM(n\log{n}))$ using $\mathcal{O}(dn\log{n})$ space, where $M(r)$ is the time complexity to multiply two integers, each of which being represented by at most $r$ bits. Then, we solve the more general Traveling Salesman problem in time $\mathcal{O}((4w)^{d}poly(n))$ using space $\mathcal{O}(\mathcal{W}dn\log{n})$, where $w$ and $d$ are the width and the depth of the given tree decomposition and $\mathcal{W}$ is the sum of weights. Furthermore, this algorithm counts the number of Hamiltonian Cycles.

1 Introduction

Dynamic programming (DP) is largely used to avoid recomputing subproblems. It may decrease the time complexity, but it uses auxiliary space to store the intermediate values. This auxiliary space may go up to exponential in the size of the input. This means both the running time and the space complexity are exponential for some algorithms solving those NP-complete problems. Space complexity is a crucial aspect of algorithm design, because we typically run out of space before running out of time. To fix this issue, Lokshtanov and Nederlof [16] introduced a framework which works on a static underlying set. The problems they considered were Subset Sum, Knapsack, Traveling Salesman (in time $\mathcal{O}(2^{n}w)$ using polynomial space),Weighted Steiner Tree, and Weighted Set Cover. They use DFTs, zeta transforms and Möbius transforms [19, 20], taking advantage of the fact that working on zeta (or discrete Fourier) transformed values is significantly easier since the subset convolution operation converts to pointwise multiplication operation. In all their settings, the input is a set or a graph which means the underlying set for the subproblems is static. Fürer and Yu [12] changed this approach modifying a dynamic programming algorithm applied to a tree decomposition (instead of the graph itself). The resulting algorithm uses only polynomial space and the running time does not increase drastically. By working with tree decompositions, they obtain parametrized algorithms which are exponential in the tree-depth and linear in the number of vertices. If the tree decomposition has a bounded width, then the algorithm is both fast and space-efficient. In this setting, the underlying set is not static anymore, because they are working with different bags of nodes. They show that using algebraization helps to save space even if the underlying set is dynamic. They consider perfect matchings in their paper. In recent years, there have been several results in this field where algebraic tools are used to save space when DP algorithms are applied to NP-hard problems. In 2018, Pilipczuk and Wrochna [18] applied a similar approach to solve the Minimum Dominating Set problem. Although they have not directly used these algebraic tools but it is a similar approach (in time $\mathcal{O}(3^{d}poly(n))$ using $poly(n)$ space).

We have to mention that there is no general method to automatically transform dynamic programming solutions to polynomial space solutions while increasing the tree-width parameter to the tree-depth in the running time.

One of the interesting NP-hard problems in graph theory is Hamiltonian Cycle. It seems harder than many other graph problems. We are given a graph and we want to find a cycle visiting each vertex exactly once. The naive deterministic algorithm for the Hamiltonian Cycle problem and the more general the Traveling Salesman problem runs in time $\mathcal{O}(n!)$ using polynomial space. Later, deterministic DP and inclusion-exclusion algorithms for these two problems running in time $\mathcal{O}^{*}(2^{n})$111$\mathcal{O}^{*}$ notation hides the polynomial factors of the expression. using exponential space were given in [13, 15, 2]. The existence of a deterministic algorithm for Hamiltonian cycle running in time $\mathcal{O}((2-\epsilon)^{n})$, for a fixed $\epsilon>0$ is still an open problem. There are some randomized algorithms which run in time $\mathcal{O}((2-\epsilon)^{n})$, for a fixed $\epsilon>0$ like the one given in [4]. Although, there is no improvement in deterministic running time, there are some results on parametrized algorithms. In 2011, Cygan et al. [11] designed a parametrized algorithm for the Hamiltonian Cycle problem, which runs in time $4^{tw}|V|^{\mathcal{O}(1)}$. They also presented a randomized algorithm for planar graphs running in time $\mathcal{O}(2^{6.366\sqrt{n}})$. In 2015, Bodlaender et al. [6] introduced two deterministic single exponential time algorithm for Hamiltonian Cycle: One based on pathwidth running in time $\tilde{\mathcal{O}}(6^{pw}pw^{\mathcal{O}(1)}n^{2})$222$\tilde{\mathcal{O}}$ notation hides the logarithmic factors of the expression. and the other is based on treewidth running in time $\tilde{\mathcal{O}}(15^{tw}tw^{\mathcal{O}(1)}n^{2})$, where $pw$ and $tw$ are the pathwidth and the treewidth respectively. The authors also solve the Traveling Salesman problem in time $\mathcal{O}(n(2+2^{\omega})^{pw}pw^{\mathcal{O}(1)})$ if a path decomposition of width $pw$ of $G$ is given, and in time $\mathcal{O}(n(7+2^{\omega+1})^{tw}tw^{\mathcal{O}(1)})$, where $\omega$ denotes the matrix multiplication exponent. One of the best known upper bound for $\omega$ [21] is $2.3727$. They do not consider the space complexity of their algorithm and as far as we checked it uses exponential space.

Recently, Curticapean et al. [10] showed that there is no positive $\epsilon$ such that the problem of counting the number of Hamiltonian cycles can be solved in $\mathcal{O}^{*}((6-\epsilon)^{pw})$ time assuming SETH. Here $pw$ is the width of the given path decomposition of the graph. They show this tight lower bound via matrix rank.

2 Preliminaries

In this section we review notations that we use later.

2.1 Tree Decomposition

A tree decomposition of a graph $G=(V,E)$, of $G$ is a tree $\mathcal{T}=(V_{\mathcal{T}},E_{\mathcal{T}})$ such that each node $x$ in $V_{\mathcal{T}}$ is associated with a set $B_{x}$ (called the bag of $x$) of vertices in $G$, and $\mathcal{T}$ has the following properties:

• •

The union of all bags is equal to $V$. In other words, for each $v\in V$, there exists at least one node $x\in V_{\mathcal{T}}$ with $B_{x}$ containing $v$.

• •

For every edge $\{u,v\}\in E$, there exists a node $x$ such that $u,v\in B_{x}.$

• •

For any nodes $x,y\in V_{\mathcal{T}}$, and any node $z\in V_{\mathcal{T}}$ belonging to the path connecting $x$ and $y$ in $\mathcal{T}$, $B_{x}\cap B_{y}\subseteq B_{z}.$

The width of a tree decomposition is the size of its largest bag minus one. The treewidth of a graph $G$ is the minimum width over all tree decompositions of $G$ called $tw(G)$. In the following, we use the letter $k$ for the treewidth. Arnborg et al. [1] showed that constructing a tree decomposition with the minimum treewidth is an NP-hard problem but there are some approximation algorithms for finding near-optimal tree decompositions [7, 9, 5]. In 1996, Bodlaender [5] introduced a linear time algorithm to find the minimum treewidth if the treewidth is bounded by a constant.

To simplify many application algorithms, the notion of a nice tree decomposition has been introduced which has the following properties. The tree is rooted and every node in a nice tree decomposition has at most two children. Any node $x$ in a nice tree decomposition $\tau$ is of one of the following types (let $c$ be the only child of $x$ or let $c_{1}$ and $c_{2}$ be the two children of $x$):

• •

Leaf node, a leaf of $\tau$ without any children.

• •

Forget node (forgetting vertex $v$), where $v\in B_{c}$ and $B_{x}=B_{c}\setminus\{v\}$,

• •

Introduce vertex node (introducing vertex $v$), where $v\notin B_{c}$ and $B_{x}=B_{c}\cup\{v\}$ ,

• •

Join node, where $x$ has two children with the same bag as $x$, i.e. $B_{x}=B_{c_{1}}=B_{c_{2}}$.

We should mention that in some papers like [12], for the sake of simplicity an introduce edge node is defined which is not a part of the standard definition of the nice tree decomposition. Here introduce edge nodes are not needed and we can handle the problem easier without such nodes. In fact, we add edges to the bags as soon as the endpoints are introduced.

It has been shown that any given tree decomposition can be converted to a nice tree decomposition with the same treewidth in polynomial time [14].

Definition 1

The depth of a tree decomposition is the maximum number of distinct vertices in the union of all bags on a path from the root to the leaf. We use $d$ to denote the depth of a given tree decomposition.

We have to mention that this is different from the depth of a tree. This is the depth of a tree decompisition as defined above.

Definition 2

The tree-depth of a graph $G$, is the minimum over the depths of all tree decompositions of $G$. We use $td$ to denote the tree-depth of a graph.

After defining the treewidth and the tree-depth, now we have to talk about the relationship between these parameters in a given graph $G$:

Lemma 1

(see [17, Corollary 2.5] and [8])

For any connected graph $G$, $td(G)\geq tw(G)+1\geq\frac{td(G)}{\log_{2}{|V(G)|}}$.

Example: The path $P_{n}$ with $n$ vertices, has treewidth $1$ and tree-depth of $\log_{2}(n+1)$.

One should note that finding the treewidth and the tree-depth of a given graph $G$ are known to be an NP-hard problem. A question which arises here, is whether there exists a tree decomposition such that its width is the treewidth and its depth is the tree-depth of the original graph? In other words, is it possible to construct a tree decomposition of a given graph which minimizes both the depth and the width? If the answer is yes, how to gain such a tree decomposition. Although we are not focusing on this question here, but it seems an interesting problem to think about.

2.2 Algebraic tools to save space

When we use dynamic programming to solve a graph problem on a tree decomposition, it usually uses exponential space. Lokshtanov and Nederlof converted some algorithms using subset convolution or union product into transformed version in order to reduce the space complexity. Later, Fürer and Yu [12] also used this approach in a dynamic setting, based on tree decompositions for the Perfect Matching problem. In this work, we introduce algorithms to solve the Hamiltonian cycle and the Traveling Salesman problems. First, let us recall some definitions.

Let $\mathcal{R}[2^{\mathcal{V}}]$ be the set of all functions from the power set of the universe $\mathcal{V}$ to the ring $\mathcal{R}$. The operator $\oplus$ is the pointwise addition and the operator $\odot$ is the pointwise multiplication.

Definition 3

A relaxation of a function $f\in\mathcal{R}[2^{\mathcal{V}}]$ is a sequence of functions $\{f^{i}:f^{i}\in\mathcal{R}[2^{\mathcal{V}}],0\leq i\leq|\mathcal{V}|\}$, where $\forall\text{ }0\leq i\leq|\mathcal{V}|$ and $\forall X\subseteq\mathcal{V}$, $f^{i}[X]$ is defined as:

[TABLE]

Definition 4

The zeta transform of a function $f\in\mathcal{R}[2^{\mathcal{V}}]$ is defined as:

[TABLE]

Definition 5

The Möbius transform of a function $f\in\mathcal{R}[2^{\mathcal{V}}]$ is defined as:

[TABLE]

Lemma 2

The Möbius transform is the inversion of the zeta transform and vice versa, i.e.

[TABLE]

See [19, 20] for the proof.

Instead of storing exponentially many intermediate results, we store the zeta transformed values. We can assume that instead of working on the original nice tree decomposition, we are working on a mirrored nice tree decomposition to which the zeta transform has been applied. We work on zeta transformed values and finally to recover the original values, we use Equation 4. The zeta transform converts the \sayhard union product operation ($*_{u}$) to the \sayeasier pointwise multiplication operation ($\odot$) which results in saving space.

Definition 6

Given $f,g\in\mathcal{R}[2^{\mathcal{V}}]$ and $X\in 2^{\mathcal{V}}$, the Subset Convolution of $f$ and $g$ denoted $(f*_{R}g)$ is defined as:

[TABLE]

Definition 7

Given $f,g\in\mathcal{R}[2^{\mathcal{V}}]$ and $X\in 2^{\mathcal{V}}$, the Union Product of $f$ and $g$ denoted $(f*_{u}g)$ is defined as:

[TABLE]

Theorem 2.1

([3]) Applying the zeta transform to a union product operation, results in the pointwise multiplication of zeta transforms of the outputs, i.e., given $f,g\in\mathcal{R}[2^{\mathcal{V}}]$ and $X\in 2^{\mathcal{V}}$,

[TABLE]

All of the previous works which used either DFT or the zeta transform on a given tree decomposition (such as [12], and [16]), have one common central property that the recursion in the join nodes, can be presented by a formula using a union product operation. The union product and the subset convolution are complicated operations in comparison with pointwise multiplication or pointwise addition. That is why taking the zeta transform of a formula having union products makes the computation easier. As noted earlier in Theorem 2.1, taking the zeta transform of such a term, will result in a term having pointwise multiplication which is much easier to handle than the union product. After doing a computation over the zeta transformed values, we can apply the Möbius transform on the outcome to get the main result (based on Theorem 2). In other words, the direct computation has a mirror image using the zeta transforms of the intermediate values instead of the original ones. While the direct computation keeps track of exponentially many intermediate values, the computation over the zeta transformed values partitions into exponentially many branches, and they can be executed one after another. Later, we show that this approach improves the space complexity using only polynomial space instead of exponential space.

3 Counting the number of Hamiltonian cycles

We are given a connected graph $G=(V,E)$ and a nice tree decomposition $\tau$ of $G$ of width $w$. If $H$ is a Hamiltonian cycle, then the induced subgraph of $H$ on $\tau_{x}$ (called $H[V_{x}]$, where $V_{x}$ is the union of all bags in $\tau_{x}$) is a set of disjoint paths with endpoints in $B_{x}$ (see Figure 1).

Definition 8

A pseudo-edge is a pair of endpoints of a path of length $\geq 2$ in $H[V_{x}]$. We use the $\langle,\rangle$ notation for the pseudo-edges. E.g., in Figure 1, $p=\langle u,v\rangle$ is a pseudo-edge (it does not imply that there is an edge between $u$ and $v$, it just says that there is a path of length at least two in $H[V_{x}]$ where $u$ and $v$ are its endpoints). The $\langle,\rangle$ notation is a symmetrical notation since our paths are undirected, i.e., $\langle u,v\rangle=\langle v,u\rangle$. Each path is associated with a pseudo-edge.

Lemma 3

The degree of all vertices in $H[V_{x}]$ is at most 2.

Proof

$H[V_{x}]$ is a subgraph of the cycle $H$.

Let $T_{x}$ be the vertices contained in the bags associated with nodes in the subtree $\tau_{x}$ rooted at $x$ which are not in $B_{x}$. Remember that vertices in pseudo-edges are vertices in $B_{x}$. Let $X$ be the union of pseudo-edges (in $B_{x}$). Let $[B_{x}]^{2}$ be the set of two-element subsets of $B_{x}$, and let $X\subseteq[B_{x}]^{2}$. Let $S_{X}$ be the union of vertices involved in $X$. Then, $S_{X}$ is a subset of $B_{x}$. For any $X$, define $Y_{X}$ to be the union of $S_{X}$ and $T_{x}$. Let $F_{x}$ be the vertices of $G$ which are introduced through $T_{x}$ and are not present in the bag of the parent of $x$. Define $f_{x}[X]$ to be the number of sets of disjoint paths (except in their endpoints where they can share a vertex) whose pseudo-edge set is $X$ (remember $S_{X}$ is the union of vertices involved in $X$) visiting vertices of $F_{x}$ exactly once (it can also visit vertices which are not in $F_{x}$ but we require them to visit at least vertices in $F_{x}$ since they are not present in the proper ancestors of $x$). Computing $f_{r}[\emptyset]$ gives us the number of possible Hamiltonian cycles in $G$. Now, we show how to compute the values of $f_{x}$ for all types of nodes.

3.1 Computing $f_{x}[X]$

In two rounds we will compute $f_{x}[X]$ efficiently. In the first round we will introduce the recursive formulas for any kind of nodes (when space usage is still exponential) and in the second round we will explain how to compute the zeta transformed values (in the next section, when the space usage drops to polynomial):

• •

Leaf node: Assume $x$ is a leaf node.

[TABLE]

Since $x$ is a leaf node, there is no path through $T_{x}$, so for all non-empty sets $X$ of pseudo-edges, $f_{x}[X]$ is zero and for $X=\emptyset$, there is only one set of paths, which is empty.

• •

Forget node: Assume $x$ is a forget node (forgetting vertex $v$) with a child $c$, where $B_{x}=B_{c}\setminus\{v\}$. Any pseudo-edge $\langle u,w\rangle\in X\subseteq[B_{x}]^{2}$ can define a path starting from $u$, going to $v$ possibly through $T_{c}$ and then going to $w$ possibly through $T_{c}$. Here, either or both pieces of the path (from $u$ to $v$, and/or from $v$ to $w$) can consist of single edges.

[TABLE]

where $d_{Q}=\begin{cases}1&\text{ if }\langle u,v\rangle\in Q\cup E\text{ and }\langle v,w\rangle\in Q\cup E\\ 0&\text{ otherwise}.\end{cases}$

• •

Introduce vertex node: Assume $x$ is an introduce vertex node (introducing vertex $v$) with a child $c$, where $B_{x}=B_{c}\cup\{v\}$. The vertex $v$ cannot be an endpoint of a pseudo-edge because paths have length at least two.

[TABLE]

• •

Join node: Assume $x$ is a join node with two children $c_{1}$ and $c_{2}$, where $B_{x}=B_{c_{1}}=B_{c_{2}}$. For any given $X\subseteq B_{x}\times B_{x}$, $X$ can be partitioned in two sets $X^{\prime}$ and $X\setminus X^{\prime}$ and each of them can be the set of pseudo-edges for one of the children.

The number of such paths associated with $X$ through $T_{x}$ is equal to the sum of the products of the number of corresponding paths associated with $X^{\prime}$ and $X\setminus X^{\prime}$ through $T_{c_{1}}$ and $T_{c_{2}}$ respectively.

[TABLE]

Here we get subset convolution and we have to convert it to union product to be able to use zeta transfrom. We do this conversion in the next subsection.

3.2 Computing $\zeta f_{x}[X]$

In this subsection (the second round of computation), first we compute the relaxations of $f_{x}[X]$ for all kinds of nodes and then we apply the zeta transform to the relaxations. In the following section let $\{f^{i}_{x}\}_{0\leq i\leq k}$ be a relaxation of $f_{x}$.

• •

Leaf node: Assume $x$ is a leaf node. Since $f_{x}[\emptyset]=1$ and for any $X\neq\emptyset:f_{x}[X]=0$, we can choose $f_{x}^{i}[X]=f_{x}[X]$ for all $i$ and $X$. Then

[TABLE]

• •

Forget node: Assume $x$ is a forget node (forgetting vertex $v$) with a child $c$, where $B_{x}=B_{c}\setminus\{v\}$. Thus,

[TABLE]

where $i^{\prime}(Q)=i-1+|Q|$, i.e., $i^{\prime}(Q)$ is the number of pseudo-edges in $X\setminus\{\langle u,w\rangle\}\cup Q$. Now we apply zeta transform:

[TABLE]

We now express $E_{Q}=\sum_{Y\subseteq(X\setminus\{\langle u,w\rangle\})}f_{c}^{i^{\prime}(Q)}[Y\cup Q]$ by $\zeta$-transforms, depending on the size of $Q$. We use the abbreviation $X^{\prime}=X\setminus\{\langle u,w\rangle\}$

If $Q=\emptyset$, then

[TABLE]

If $Q=\{\langle u,v\rangle\}$ or $Q=\{\langle v,w\rangle\}$, then

[TABLE]

If $Q=\{\langle u,v\rangle,\langle v,w\rangle\}$, then

[TABLE]

With these sums computed, we can now express $\zeta f_{x}^{i})[X]$ more concisely.

[TABLE]

Note that $d_{\emptyset}=1$ if $\{\langle u,v\rangle,\langle v,w\rangle\}\subseteq E$, $d_{\{\langle u,v\rangle\}}=1$ if $\langle v,w\rangle\in E$, $d_{\{\langle v,w\rangle\}}=1$ if $\langle u,v\rangle\in E$, and $d_{\{\langle u,v\rangle,\langle v,w\rangle\}}$ is always 1, while otherwise $d_{Q}=0$. This implies that for every $\langle u,w\rangle$ in the previous equation at least one of the 4 coefficients is 0. Therefore, in each forget node, we have at most a $3|X|$ fold branching.

• •

Introduce vertex node: Assume $x$ is an introduce vertex node (introducing vertex $v$) with a child $c$, where $B_{x}=B_{c}\cup\{v\}$. Let $X_{v}$ be the set of pseudo-edges having $v$ as one their endpoints. Therefore,

[TABLE]

[TABLE]

• •

Join node: Assume $x$ is a join node with two children $c_{1}$ and $c_{2}$, where $B_{x}=B_{c_{1}}=B_{c_{2}}$. To compute $f_{x}$ on a join node, we can use Equation 11. In order to convert the subset convolution operation to pointwise multiplication, first we need to convert the subset convolution to union product and then we are able to use Theorem 2.1. To convert subset convolution to union product we introduce a relaxation of $f_{x}$. Let $f^{i}_{x}[X]=\sum_{j=0}^{i}(f_{c_{1}}^{j}*_{u}f_{c_{2}}^{i-j})[X]$ be a relaxation of $f_{x}$.

[TABLE]

where $w$ is the treewidth of $\tau$.

To summerize, we present the following algorithm for the Hamiltonian Cycle problem where a tree decomposition $\tau$ is given.

Theorem 3.1

Given a graph $G=(V,E)$ and a tree decomposition $\tau$ of $G$, we can compute the total number of the Hamiltonian Cycles of $G$ in time $\mathcal{O}((4w)^{d}nM(n\log{n}))$ and in space $\mathcal{O}(wdn\log{n})$ by using Algorithm 1, where $w$ and $d$ are the width and the depth of $\tau$ respectively, and $M(n)$ is the time complexity to multiply two numbers which can be encoded by at most $n$ bits.

Proof can be found in appendix.

4 The traveling Salesman problem

In the previous section, we showed how to count the total number of possible Hamiltonian cycles of a given graph. In this section, we discuss a harder problem. We know that the Hamiltonian Cycle problem is reducible to the traveling Salesman problem by setting all cost of edges to be 1. We could have just explained how to solve Traveling Salesman problem but we chose to first explain the easier one to help understanding the process. Now, we have most of the notations. First, we recap the formal definition of the traveling Salesman problem.

Definition 9

Traveling Salesman. Given an undirected graph $G=(V,E)$ with weighted edges, where for all $\{u,v\}\in E$, $c_{u,v}$ is the weight (= cost) of $\{u,v\}$ (nonnegative integer). In the traveling Salesman problem we are asked to find a cycle (if there is any) that visits all of the vertices exactly once (it is a Hamiltonian cycle) with minimum cost.

As mentioned, the output should be a minimum cost Hamiltonian cycle. We have the same notations as before. Thus, we are ready to explain our algorithmic framework:

The difference between counting the number of Hamiltonian cycles and finding the minimum cost of a Hamiltonian cycle (answer to the Traveling salesman problem), is that we should work with lengths instead of the numbers of solutions. In order to solve this problem, we work with the ring of polynomials $\mathbb{Z}[x]$, where $x$ is a variable. Our algorithm computes the polynomial $P_{x}(y)[X]=\sum_{i=0}^{\mathcal{W}}a_{i}^{x}[X]y^{i}$, where $a_{i}^{x}[X]$ is the number of solutions in $\tau_{x}$ associated with $X$ with cost $i$, and $\mathcal{W}$ is the sum of the weights of all edges. The edge lengths have to be nonnegative integers as mentioned above.

4.1 Computing the Hamiltonian Cycles of All Costs

To find the answer to the traveling salesman problem, we have find the first nonzero coefficient of $P_{r}(x)$, where $r$ is the root of the given nice tree decomposition. As we did for the Hamiltonian cycle problem, we show how compute this polynomial recursively for all kinds of node.

• •

Leaf node: Assume $x$ is a leaf node. Since we require leaf nodes to have empty bags, then

[TABLE]

• •

Forget node: Assume $x$ is a forget node (forgetting vertex $v$) with a child $c$, where $B_{x}=B_{c}\setminus\{v\}$.

[TABLE]

where $d_{Q}=\begin{cases}1&\text{ if }\langle u,v\rangle\in Q\cup E\text{ and }\langle v,w\rangle\in Q\cup E\\ 0&\text{ otherwise}.\end{cases}$

• •

Introduce vertex node: Assume $x$ is an introduce vertex node (introducing vertex $v$) with a child $c$, where $B_{x}=B_{c}\cup\{v\}$.

[TABLE]

• •

Join node: Assume $x$ is a join node with two children $c_{1}$ and $c_{2}$, where $B_{x}=B_{c_{1}}=B_{c_{2}}$.

[TABLE]

We skip the zeta transform part because it is similar to the Hamiltonian Cycle case.

Theorem 4.1

Given a graph $G=(V,E)$ and a tree decomposition $\tau$ of $G$, we can solve the Traveling Salesman problem for $G$ in time $\mathcal{O}(4w)^{d}\cdot poly(n)$ and in space $\mathcal{O}(\mathcal{W}dwn\log{n})$ where $\mathcal{W}$ is the sum of the weights, $w$ and $d$ are the width and the depth of the tree decomposition $\tau$ respectively.

You can find the proof in appendix.

4.2 Conclusion

In this work, we solved Hamiltonian Cycle and Traveling Salesman problems with polynomial space complexity where the running time is polynomial in size of the given graph and exponential in tree-depth. Our algorithms for both problems rely on modifying a DP approach such that instead of storing all possible intermediate values, we keep track of zeta transformed values which was first introduced in [16], and then in [12] for dynamic underlying sets.

Appendix 0.A Appendix

Here is the proof of Theorem 3.1.

Proof

The correctness of the algorithm is shown in Section 3.1 and Section 3.2. Now, we show the running time and the space complexity of our algorithm.

Running time: The only case that branching happens in where we are handling a forget node. We have at most $w$ branches in forget nodes since the number of pseudo-edges in each bag is bounded by $w+1$ because of Lemma 3. Furthermore, based on the formula for forget node, the two unordered pairs of $(u,v)$ and $(v,w)$ can contribute as an edge or a pseudo-edge (four possible cases). On the other hand the number of forget nodes in a path from the root to one leaf is bounded by the $d$ (the depth of tree decomposition $\tau$). Also, the number of vertices is $n$ and we work with numbers of size at most $n!$ (number of paths) which can be represented by at most $n\log{n}$ bits. We handle multiplication of these numbers which happens in $\mathcal{O}(M(n\log{n}))$. All being said, the total running time is $\mathcal{O}((4w)^{d}nM(n\log{n}))$.

Space complexity: We keep the results for each strand at a time. The number of nodes in a path from the root to a leaf is bounded by the depth of the tree decomposition ($d$). Along the path, we keep track of bags (of size $w$) and number of disjoint paths (at most $n!$ paths exist which can be shown by at most $n\log{n}$ bits). Therefore, the total space complexity is $\mathcal{O}(wdn\log{n})$.

And here is the proof of Theorem 4.1.

Proof

The correctness of the algorithm is shown in Section 3.1 and Section 3.2. Now, we show the running time and the space complexity of our algorithm.

Running time: The running time analysis is very similar to the analysis done for Hamiltonian Cycle.

Space complexity: The space complexity analysis is also similar to the analysis done for Hamiltonian Cycle except here we have to keep track of the sum of the wights which at most is $\mathcal{W}$. So there is a factor of $\mathcal{W}$ in the space complexity here.