# A Linearly-growing Conversion from the Set Splitting Problem to the Directed Hamiltonian Cycle Problem

We consider a direct conversion of the, classical, set splitting problem to the directed Hamiltonian cycle problem. A constructive procedure for such a conversion is given, and it is shown that the input size of the converted instance is a linear function of the input size of the original instance. A proof that the two instances are equivalent is given, and a procedure for identifying a solution to the original instance from a solution of the converted instance is also provided. We conclude with two examples of set splitting problem instances, one with solutions and one without, and display the corresponding instances of the directed Hamiltonian cycle problem, along with a solution in the first example.

## Authors

• 8 publications
• 1 publication
• ### FHCP Challenge Set: The First Set of Structurally Difficult Instances of the Hamiltonian Cycle Problem

The FHCP Challenge Set, comprising of 1001 instances of Hamiltonian cycl...
02/27/2019 ∙ by Michael Haythorpe, et al. ∙ 0

• ### A new benchmark set for Traveling salesman problem and Hamiltonian cycle problem

We present a benchmark set for Traveling salesman problem (TSP) with cha...
06/25/2018 ∙ by Pouya Baniasadi, et al. ∙ 0

• ### Encoding Selection for Solving Hamiltonian Cycle Problems with ASP

It is common for search and optimization problems to have alternative eq...
09/18/2019 ∙ by Liu Liu, et al. ∙ 0

• ### Exact and Approximate Algorithms for Computing a Second Hamiltonian Cycle

In this paper we consider the following total functional problem: Given ...
04/13/2020 ∙ by Argyrios Deligkas, et al. ∙ 0

• ### Find Subtrees of Specified Weight and Cycles of Specified Length in Linear Time

We introduce a variant of DFS which finds subtrees of specified weight i...
02/18/2019 ∙ by On-Hei Solomon Lo, et al. ∙ 0

• ### An Asymptotically Fast Polynomial Space Algorithm for Hamiltonicity Detection in Sparse Directed Graphs

We present a polynomial space Monte Carlo algorithm that given a directe...
09/24/2020 ∙ by Andreas Björklund, et al. ∙ 0

• ### Evolving test instances of the Hamiltonian completion problem

Predicting and comparing algorithm performance on graph instances is cha...
10/05/2020 ∙ by Thibault Lechien, et al. ∙ 0

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

The set splitting problem (SSP) is a famous decision problem that can be simply stated: given a finite universe set , and a family of subsets of , decide whether there exists a partition of into two, disjoint, non-empty subsets and such that every subset is split by this partition. That is, for each subset , we have and . If such a partition exists, we call it a solution of the SSP instance, and say that the decision of the instance is YES. Similarly, if no such partition exists, then the decision of the instance is NO.

This problem has been studied by such distinguished mathematicians as P. Erdős erdos and E.W. Miller miller since the 1930s. Since then, it has been studied by many authors in the mathematics, computer science, and engineering communities. It has acquired a theoretical interest by virtue of its relationship to hypergraph colourability problems (e.g. see Radhakrishnan and Srinivasan radhakrishnan ). In addition, it has applicability in modern lines of research such as DNA computing (e.g. see Chang et al chang ), and several recent algorithms for solving SSP have been developed (e.g. see Dehne et al dehne , Chen and Lu chen , Lokshtanov and Saurabh lokshtanov ).

SSP is known to be NP-complete gareyjohnson . One key feature of NP-complete problems is that an instance of any one NP-complete problem can be converted to an instance of any other NP-complete problem, in such a way that the two instances have the same answer, and the cardinalities of the variables sets in the second instance are polynomial functions of the size of input data for the original instance. The study of NP-complete problems originated with Cook cook , who proved that an instance of any problem in the set of NP decision problems can be converted to an equivalent instance of the boolean satisfiability problem (SAT). Therefore, SAT was the first problem proven to be NP-complete. Then, if any NP-complete problem can be converted to another problem , the second problem is also proved to be NP-complete. This is because any instance of can be converted to an instance of SAT (via Cook’s theorem), and from there converted (possibly through multiple other problems) to an instance of .

Cook’s breakthrough approach provided the template for NP-complete conversions, and subsequently it has become commonplace for problems to be converted to SAT. A recent study of this may be seen in Kugele kugele . However, there is nothing inherently special about SAT to set it apart from other fundamental NP-complete problems. Motivated by this line of thinking, in this chapter we investigate the conversion of SSP to another fundamental NP-complete problem, namely the directed Hamiltonian cycle problem (HCP). Directed HCP can be described simply: given a graph containing a set of vertices , such that , and a set of directed edges , decide whether there exists a simple cycle of length in the graph , or not. Directed HCP was one of the earliest known NP-complete problems karp and is a classical graph theory problem which has been the subject of investigation for well over a century. Indeed, a famous instance of HCP - the so-called “Knight’s tour” problem - was solved by Euler in the 1750s, and it remains an area of active research (e.g. see Eppstein eppstein , Borkar et al borkar , and Baniasadi et al baniasadi ).

Arguably, it is interesting to consider what might be called “linear orbits” of famous NP-complete problems, such as directed HCP. By this, we mean the set of other NP-complete problems which may be converted to, say, directed HCP in such a way that the input size of the resultant HCP instance is a linear function of the input size of the original problem instance. We refer to such a conversion as a linearly-growing conversion. Although conversions between NP-complete problems have been extensively explored since 1971, less attention has been paid to the input sizes of the resultant instances after such conversions, and yet input sizes that grow quadratically or higher are likely to produce intractable instances.

In this chapter, we provide a linearly-growing conversion procedure that accepts any instance of SSP as input, and produces an equivalent instance of directed HCP as output. The equivalence is in the sense that a Hamiltonian in the output graph instance supplies a solution to the original SSP instance, and non-Hamiltonicity in the output instance implies infeasibility of the original SSP instance.

## 2 Simplifying the SSP instance

Consider an instance of SSP, containing the universe set and the family of subsets of . Before we begin solving the problem, we can attempt to simplify it, to obtain a smaller instance that must still have the same answer as the original. The following steps may be performed:

1. If any contains only a single entry, then the decision of the SSP instance is NO, as this set cannot be split. In this case there is no need to solve the SSP.

2. If any element is not contained in any , then it may be removed from . This is because could be placed in either partition without affecting the solution, so it is inconsequential to the problem.

3. If any is equal to , then it may be disregarded, as any partitioning of into non-empty subsets will split .

4. If any is a subset of some other , then may be disregarded, as any partitioning of that splits necessarily splits as well.

Once the instance has been simplified in this manner, we say it is in simple form, and we are ready to begin converting it to an instance of directed HCP.

## 3 Algorithm for converting an SSP instance to an instance of directed HCP

For a given instance of SSP we shall construct an instance of HCP possessing the property that any Hamiltonian cycle corresponds, in a natural way, to a solution of the original instance of SSP. Additionally, in the case the constructed graph does not possess a Hamiltonian cycle, neither does the original instance of SSP have a solution.

The algorithm for constructing from has three main steps in which three sets of vertices and edges are constructed. Collectively, these will comprise the vertex and edge sets of .

Suppose that we have an instance of SSP in simple form. Let denote the universe set, and assume that each contains entries in ascending order. Denote by the number of subsets remaining after the simplification process, and also define to be the total number of elements over all subsets . Note that , where the case , trivially, has the answer YES. Then we may define an instance of HCP in the form of a graph containing vertices and directed edges , such that the HCP instance is equivalent to the SSP instance, as follows.

The vertex set can be partitioned into three mutually disjoint subsets of vertices , and . That is, . The subset will contain vertices corresponding to each element of the universe set . The subset will contain vertices corresponding to each subset . The subset will contain two additional “connecting” vertices, that will link the and parts to form a cycle.

Likewise, the edge set can be partitioned into three mutually disjoint subsets of edges , and . That is, . The subset will contain edges whose endpoints lie entirely within . Similarly, the subset will contain edges whose endpoints lie entirely within . Finally, will contain many “connecting” edges, which connect vertices from any of the three partitions to other vertices, possibly in different partitions.

### Step 1:

We will first consider the vertex subset and edge subset . These sets can be further partitioned into subsets, one for each element in the universe set. That is, and . Then, for each element , we can describe and directly:

 VU,i = {vU,i1,vU,i2,vU,i3,vU,i4} EU,i = {(vU,i1,vU,i2),(vU,i1,vU,i3),(vU,i2,vU,i3),(vU,i3,vU,i2)}

Note that at this stage of the construction, is an isolated vertex. Each subgraph may be visualised as in Figure 1. The thick bold undirected edge between vertices and represents directed edges in both directions between the two vertices.

### Step 2:

We will next consider the vertex subset and edge subset . These sets can be further partitioned into subsets, one for each subset . That is, and . Then, for each subset , we must first determine . For neatness, when no confusion is possible we define , taking care to remember that the value of depends on . Then, the number of vertices in is chosen to be , each of which will be denoted by . The edge set is the union of the following three groups of edges:

Group I:

 (vS,i1,vS,i6),(vS,i1,vS,i6+3k),(vS,i5+3k,vS,i2), (1) (vS,i5+6k,vS,i2),(vS,i3,vS,i4),(vS,i4,vS,i3),(vS,i4,vS,i5),(vS,i5,vS,i4),

Group II: for all (for neatness, we define , and ):

 (vS,iaj,vS,ibj),(vS,ibj,vS,iaj),(vS,ibj,vS,icj),(vS,icj,vS,ibj), (2) (vS,iaj+3k,vS,ibj+3k),(vS,ibj+3k,vS,iaj+3k),(vS,ibj+3k,vS,icj+3k),(vS,icj+3k,vS,ibj+3k),

Group III: for all (retaining the definitions of , and from above):

 (vS,icj,vS,icj+1),(vS,icj,vS,icj+1+3k),(vS,icj+3k,vS,icj+1),(vS,icj+3k,vS,icj+1+3k), (3) (vS,icj,vS,i3),(vS,i3,vS,icj+1),(vS,icj+3k,vS,i5),(vS,i5,vS,icj+3k+1).

Each subgraph has a characteristic visualisation. In Figure 2 we display such a subgraph for the case where . The thick bold undirected edges represent directed edges in both directions between two vertices. Note that in Figure 2, the Group I edges are the two directed edges emanating from each of vertex and , as well as the undirected edges between vertices , and . The Group II edges are the undirected edges on the top and bottom of the figure. The Group III edges are all of the directed edges in the interior of the figure.

### Step 3:

Finally, we consider the vertex subset and edge subset . There are only two vertices in , namely and . However, there are many edges in , and a procedure must be undertaken to identify them all. First, we include the following edges in :

 (vU,u4,vC1),(vC1,vS,11),(vS,s5+6|Ss|,vC2),(vC2,vU,11), (4)

as well as the following edges for each :

 (vU,i4,vU,i+11), (5)

and also the following edges for each :

 (vS,j5+6|Sj|,vS,j+11). (6)

The edges in (4)–(6) link the various components of the graph together. Specifically, the first group of edges links the component to the component, the second group links each component with the component that follows it, and the third group links each component with the component that follows it. At this stage of construction, the graph can be visualised as in Figure 3.

However, the above edges do not comprise all of . Additional edges need to be added, as follows. For each , we undertake the following procedure to insert additional edges in . First we identify all subsets in which contain the element , and store their indices in a set . We also record a set , which contains the positions of element in each subset . For example, suppose that the subsets are , , and . Then , and . Similarly, , and . For the sake of neatness, when no confusion is possible, we will define , taking care to remember that depends on the value of .

For each , we define , and , and insert the following edges:

 (vU,i2,vS,Fi12+ei1),(vS,Fifeif,vU,i4),(vU,i3,vS,Fi12+di1),(vS,Fifdif,vU,i4), (7)

into . Finally for , and each (retaining the definitions of , and from above), we insert pairs of edges:

 (vS,Fijeij,vS,Fij+12+ei,j+1),(vS,Fijdij,vS,Fij+12+di,j+1), (8)

into . The edges in (7) and (8) have the effect of creating two paths, that each travel from one of the vertices in (either or ), through three vertices in each , and finally return to , specifically to the vertex . Two such paths are illustrated in Figure 4, for . In the example shown in Figure 4, we assume , , and . The completed graph would have six more paths, two for each of , and , creating a connected graph. The latter have been omitted for the sake of visual clarity.

This completes the construction of from . We shall now calculate the cardinalities of and .

### Dimensionality of the constructed graph

The final graph will contain 4 vertices for each , 5 vertices for each , 6 vertices for each entry , and two additional vertices and . Therefore the total number of vertices in the graph is .

Counting the number of edges takes a bit more work. There are 4 edges (counting undirected edges as two, directed, edges) in each . So contributes edges.

Then for each , there are 8 edges that will always be present (two from , two going to , and four between , and . Then for each element there are 16 additional edges, except for the final element for which there are eight edges. So contributes edges.

Finally, for , there are connecting edges for the components, and connecting edges for the components. There are two more connecting edges emerging from and . Finally, for each element , there are connecting edges forming the two paths, where is the number of subsets containing element . So contributes .

Therefore, the total number of directed edges in the graph is . It should be noted that both the cardinality of the vertex set and edge set are linear functions of the cardinalities of the input sets for the original problem. For this reason, we refer to the conversion described above as a linearly-growing conversion from SSP to directed HCP.

## 4 The intended interpretation of the converted graph

Once the conversion is complete, the graph contains many components and corresponding to elements in and subsets , respectively. We now consider in some detail the intended interpretation of any Hamiltonian cycle traversing those components.

For each element , there are four vertices in . As will be proved later, any Hamiltonian cycle in visits and in succession (in either order). If is visited last, it corresponds to placing the element in the first partition. If vertex is visited last, it corresponds to placing the element in the second partition.

For each , and , by construction, there are vertices in . Now, consider a particular element , that is, the -th entry of . Naturally, . Then, corresponding to this element being chosen in the first partition, there are vertices , and . Similarly, corresponding to this element being chosen in the second partition, there are vertices , and .

Now, suppose there is an element that we have chosen to be in . That is, the cycle visits after . Consider all subsets that contain , that is for some . Then, immediately after visiting , the cycle will begin to travel to each such component , and in each of them it will traverse the three vertices corresponding to selecting in (not ). In this way, only those vertices corresponding to this element being chosen in the correct partition will remain to be traversed later. Once all such vertices in all relevant components have been visited, the cycle returns to the component in order to proceed to make a choice of partition for the next element in .

The process until this point will be called “stage 1”. Once a choice of partition has been made for all elements in , the cycle travels through , and on to , whereby “stage 2” begins.

The intention is that, upon reaching vertex for each , the cycle will recognise which partition is in, because the vertices corresponding to the alternative partition will have already been visited during stage 1. The cycle will then proceed through the three vertices corresponding to the correct choice of partition. Then, the cycle will again recognise which partition is in, traverse the three vertices corresponding to that choice, and so on. Once the vertices corresponding to all elements, in their partitions, of are traversed, the cycle will reach vertex and proceed to the next component . Specifically, it will travel from to .

During this process, however, the option to visit one of or will present itself each time the the three vertices for an element and partition are traversed. Specifically, after traversing through vertices corresponding to an element being in , it will be possible to visit . Alternatively, after traversing through vertices corresponding to an element being in , it will be possible to visit . If the cycle chooses to visit one of these two vertices, it will continue through and out to the other of the two vertices. At this point the cycle will continue to traverse the three vertices corresponding to the next element in the set, but it will be forced to choose vertices corresponding to the opposite partition to that of the previous element. For example, suppose the cycle traverses the three vertices corresponding to being chosen in the first partition, and then visits . It will subsequently visit and , and then proceed to visit the three vertices corresponding to being chosen in the second partition.

The above paragraph describes the essence of why the conversion works. Vertices , and must be traversed at some point during stage 2, but after they are traversed, the element that is subsequently considered must be in a different partition to the previous element. This will be possible in all if and only if the partition choices made in stage 1 split all of the subsets. Therefore, as will be shown rigorously below), Hamiltonian cycles will only exist if it is possible to solve the original instance of SSP.

The formal proof of the validity of the above description is presented next.

## 5 Proof of conversion

In this section we will prove that, for an instance of SSP, the conversion given in Section 3 produces a graph that possesses the desired properties; that is, the graph is Hamiltonian if and only if the original instance of SSP has solutions, that all Hamiltonian cycles correspond to solutions of the instance of SSP, and that all such solutions can be recovered from the Hamiltonian cycles in polynomial time. Throughout the proof we will take advantage of the structure produced the graph construction. We now outline the primary such advantages, before continuing with the main result.

While attempting to construct a Hamiltonian cycle in the converted graph, we will regularly take advantage of forced choices. These fall into three categories. If a vertex is arrived at, and only one outgoing edge exists that leads to an as-of-yet unvisited vertex, the cycle will be forced to proceed along the edge . In such a case, we say there is only one remaining outgoing edge. Alternatively, if a vertex is arrived at, and there is an outgoing edge that leads to another vertex, for which no other incoming edges from as-of-yet unvisited vertices exist, the cycle will be forced to proceed along the edge . In such a case, we say there is only one remaining incoming edge. Finally, if a vertex is arrived at, and there is an outgoing edge that leads to an as-of-yet unvisited vertex which has degree 2, the cycle will be forced to proceed along edge . By degree 2, we mean that has exactly two outgoing edges that lead to vertices and , and exactly two incoming edges that also come from vertices and . Note that this is a slightly non-standard, but convenient, use of the word “degree” in a directed graph.

Suppose that, during in the process of constructing a Hamiltonian cycle, we arrive at a vertex . There are two possible choices of which vertex to visit next: and . Whichever choice is made, we are forced to visit the other immediately afterwards, as there will only be one remaining incoming edge. At this point, regardless of which vertex we have arrived at, there will only be one remaining outgoing edge, which will lead to a vertex in one of the components, specifically a vertex for some positive integers and , where . We will refer to this situation as a type 1 forced path.

Also, suppose that, during the process of constructing a Hamiltonian cycle, we travel from a vertex in any component other than , to a vertex for some positive integers and . Note that this vertex is adjacent to a degree 2 vertex . Since the vertex was not visited immediately before , we are forced to visit it immediately, and then proceed along the one remaining outgoing edge to the vertex . At this point, there will also be only one remaining outgoing edge, which will either lead to a vertex of the form for some positive integers and , where and , or it will lead to the vertex . Note that in the former case, we arrive in the same type of situation that we started with at the beginning of this paragraph. In the latter case, however, we arrive at and are then forced to proceed either to (if ), or to (if ). We will refer to this situation as a type 2 forced path.

We now pose the main result of this chapter.

###### Proposition 1

Consider an instance of SSP with universe set and a family of subsets , and the graph constructed as in Section 3. Then the following three properties hold:

1. If no partition of exists that splits all , then is non-Hamiltonian.

2. If a partition of exists that does split all , a corresponding Hamiltonian cycle exists in .

3. From any Hamiltonian cycle in we can, in polynomial time, identify a corresponding partition of that constitutes a solution of the original instance of SSP.

### Stage 1:

Suppose now that we attempt to construct a Hamiltonian cycle in . Since we may begin at any vertex, we choose to begin at the vertex . As described above, we undergo a type 1 forced path, and eventually depart from either or and arrive at the vertex for some and . Then, since we have arrived from a component other than , we will undergo a type 2 forced path. Then, we may (or may not) arrive at another vertex for which a type 2 forced path is applicable. Inductively, the process continues until we do not arrive at such a vertex111In fact, due to the nature of the construction, if the element appears in subsets, then exactly type 2 forced paths must occur here.. Throughout the process, we visit all of the vertices that correspond to placing element 1 into a particular member of the partition. The construction is such that visiting after forces us to visit the vertices corresponding to the element 1 being in . Similarly, visiting after forces us to visit the vertices corresponding to the element 1 being in . Once all of these vertices are visited, we travel to the vertex and proceed to the vertex . Note that at this point, all vertices in the component have been visited.

The above process is then repeated for all components . The only choice that is made in each component is whether to traverse through , or to traverse through . After this choice has been made, the path that is taken - through all vertices corresponding to the element in the opposite member of the partition, in all components corresponding to the subsets in which element appears - is forced until the next component is reached. Eventually, after the entirety of has been traversed, vertex is reached, and we are forced to proceed to the vertex .

### Stage 2:

There are two outgoing edges from , leading to vertices and respectively, where . However, exactly one of these must have been visited already in stage 1. If element 1 was placed in , then vertex will have already been visited, or similarly, if element 1 was placed in , then vertex will have already been visited. So the choice at this stage is forced. Then, both vertices and are adjacent to degree 2 vertices, so the next two steps are forced as well. This means we visit all three vertices corresponding to the element being placed in the member of the partition that was chosen during stage 1.

At this point, there are two choices. We may either continue onto the vertices corresponding to the element , or we may visit one of or (depending on whether was placed in or , respectively). If we make the former choice, we repeat the above process for the element , and end up again having to choose whether to visit the vertices corresponding to the element , or visit one of or . Suppose that we make the former choice for the first elements of , and then choose the latter for the -th element. Without loss of generality, suppose the element was chosen, during stage 1, to be in . So, after traversing the vertices corresponding to , we then choose to visit . Then there is an adjacent degree 2 vertex, , so we are forced to travel there next, and then to .

At this point, our choice is forced as the first of the vertices corresponding to choosing in has at most one remaining incoming edge, from . Therefore this choice must be made, if possible. If it is not possible (because element was chosen in during stage 1), then the Hamiltonian cycle cannot be completed at this point. In such a case, choosing to visit vertex after traversing the vertices corresponding to the first elements was an incorrect choice. It is then clear that this choice may only be made if was chosen in during stage 1.

An equivalent argument to that in the above paragraph can be made if element was chosen to be in . Then we can see that we may only choose to visit (or ) when elements and are in opposite members of the partition.

After we have visited vertices , and once, they cannot be visited again, and so the remaining path through is forced until we finally reach and are forced to continue to . The same process then continues for all components . Finally, the vertex is visited, and we travel back to the vertex to complete the Hamiltonian cycle.

The only way in which the above process might fail to produce a Hamiltonian cycle is if there is a component for which we are unable to find a such that and are in opposite members of the partition. In this case, following the above argument, vertices , and cannot possibly be visited in a Hamiltonian cycle. This situation arises only when all entries in are contained in a single member of the partition. In such a situation, the partitioning choices in stage 1 do not form a solution to the original set splitting problem. So making partition choices in stage 1 that do not solve the instance of SSP will always make it impossible to complete stage 2. Clearly then, if there is no solution to the set splitting problem, it will be impossible to find any Hamiltonian cycle. Therefore part (i) holds.

If there are solutions to the original set splitting problem, then for any such solution we can make the corresponding choices in stage 1. Then, in stage 2 there will be an opportunity in each component to visit the vertices , and , and continue afterwards. Therefore, for any such solution, a Hamiltonian cycle exists, and hence part (ii) holds.

Finally, identifying the solution to the original instance of SSP is as easy as looking at and for each to see which vertex was visited last on the Hamiltonian cycle. If vertex was visited last, element should be placed in . If vertex was visited last, element should be placed in . This process can obviously be performed in polynomial time, and therefore part (iii) holds.

Proposition 1 ensures that the conversion given in Section 3 produces a graph which is Hamiltonian if and only if the original set splitting problem has solutions, and each Hamiltonian cycle specifies one such solution. Since the number of vertices and edges in the resultant graph are linear functions of the original problem variables, this process constitutes a linearly-growing NP-complete conversion.

## 6 Examples

We now conclude with two small examples of SSP instances and their corresponding directed HCP instances. In the first example we provide a Hamiltonian cycle in the graph, and hence deduce a solution to the original SSP instance. In the second example, the corresponding graph is non-Hamiltonian, and we deduce that the original SSP instance has no solutions and hence the decision of the instance is NO.

###### Example 1

Consider the SSP instance with and a family of subsets where and .

Following the construction given in Section 3, we obtain an instance of directed HCP, which is displayed in Figure 5. A Hamiltonian cycle in is also displayed in Figure 5, with the edges in the Hamiltonian cycle designated by dashed or dotted edges. The dashed edges correspond to edges which are chosen in stage 1, while the dotted edges correspond to edges which are chosen in stage 2.

Consider the Hamiltonian cycle indicated in Figure 5, and traverse it from the starting vertex as marked on the figure. Then, to determine the solution of the instance of SSP, we simply need to look at which of vertices and were visited last, for each , on the Hamiltonian cycle. In Figure 5 vertex is drawn above vertex in each case. It can be easily checked that vertices , , and are the last visited vertices in each case. This corresponds to a solution of the instance of SSP where elements and are placed in , and elements and are placed in . Clearly, this choice provides a splitting of and .

We now check that an incorrect choice of partitioning will make it impossible to complete a Hamiltonian cycle. Suppose we assign elements and to , and elements and to . Note that this is not a solution of the original instance of SSP, as the subset is not split. In Figure 6 we use dashed edges to denote the edges visited in stage 1 (corresponding to our incorrect choice of partitioning), and dotted edges to denote the edges subsequently visited in stage 2. However, the three middle vertices in the component are unable to be visited, and hence this choice of partitioning can not lead to a Hamiltonian cycle.

Finally, we consider an SSP instance with no solutions, and the corresponding instance of directed HCP.

###### Example 2

Consider the SSP instance with and a family of subsets where , and . It is clear that this instance has no solution since, without loss of generality, if element is placed in the first partition, elements 2 and 3 must be placed in the second partition (to split the first two subsets), and then the third subset is not split.

Following the construction given in Section 3, we obtain an instance of directed HCP, which is displayed in Figure 7. Although it is not obvious at first glance, the HCP instance is, indeed, non-Hamiltonian. We have confirmed its non-Hamiltonicity using the Concorde TSP Solver concorde .

Since is non-Hamiltonian, by Proposition 1(i) there is no partition which splits all . Suppose we naively tried to create such a splitting by assigning, for example, element 1 to the first partition, and elements 2 and 3 to the second partition. This would correspond to attempting to find a Hamiltonian cycle in containing the six highlighted edges in Figure 7. Then it is straightforward to verify that it is impossible to complete a Hamiltonian cycle. This is a similar feature to that exhibited in Figure 6, with the important exception that in the latter there were alternative, correct, choices of partitioning which do permit Hamiltonian cycles, such as the one illustrated in Figure 5.

###### Acknowledgements.
The authors gratefully acknowledge useful conversations with Dr. Richard Taylor that helped in the development of this chapter.

## Bibliography

• (1) Applegate D, Bixby RE, Chvátal V, Cook WJ. Concorde TSP Solver. http://www.tsp.gatech.edu/concorde/.Cited30April2013
• (2)

Baniasadi P, Ejov V, Filar JA, Haythorpe M, Rossomakhine S. Deterministic “Snakes and Ladders” Heuristic for the Hamiltonian Cycle Problem. Math Program Comput, submitted 2012.

• (3)

Borkar VS, Ejov V, Filar JA, Nguyen GT (2012) Hamiltonian Cycle Problem and Markov Chains. Springer, New York

• (4) Chang W-L, Guo M, Ho M (2004) Towards solutions of the set-splitting problem on gel-based DNA computing. Future Gener Comput Syst 20(5):875–885
• (5) Chen J, Lu S (2007) Improved algorithms for weighted and unweighted set splitting problems. In: COCOON, vol 4598 of Lecture Notes in Computer Science, pp. 537–547
• (6) Cook S (1971) The complexity of theorem proving procedures. Proc Third Annu ACM Symp Theory Comput pp. 151–158
• (7) Dehne FKHA, Fellows MR, Rosamond FA (2003) An FPT algorithm for set splitting. In: WG, vol 2880 of Lecture Notes in Computer Science, pp. 180–191
• (8) Eppstein D (2007) The traveling salesman problem for cubic graphs. J Graph Algorithms Appl 11(1):61–81
• (9) Erdős P, Hajnal A (1961) On a property of families of sets. Acta Math Hung 12(1-2):87–123
• (10) Garey MR, Johnson DS (1979) Computers and intractiability: A Guide to the Theory of NP-Completeness. W. H. Freeman
• (11) Karp R (1972) Reducibility Among Combinatorial Problems. In: Raymond E. Miller and James W. Thatcher (editors). Complexity of Computer Computations. New York: Plenum. pp. 85–103
• (12) Kugele S (2006) Efficient Solving of Combinatorial Problems using SAT-Solvers. Ph.D Thesis, Technische Universität München
• (13) Lokshtanov D, Saurabh S (2009) Even Faster Algorithm for Set Splitting!. In: Parameterized and Exact Computation: 4th International Workshop, IWPEC 2009, Copenhagen, Denmark, September 2009, pp. 288-299
• (14) Miller EW (1937) On a property of families of sets. Comptes Rendus Vars 30:31–38
• (15) Radhakrishnan J, Srinivasan A (2000) Improved bounds and algorithms for hypergraph 2-coloring. Random Struct Algorithms 16(1):4–32