Finding All Solutions and Instances of Numberlink and Slitherlink by ZDDs

Abstract

Link puzzles involve finding paths or a cycle in a grid that satisfy given local and global properties. This paper proposes algorithms that enumerate solutions and instances of two link puzzles, Slitherlink and Numberlink, by zero-suppressed binary decision diagrams (ZDDs). A ZDD is a compact data structure for a family of sets provided with a rich family of set operations, by which, for example, one can easily extract a subfamily satisfying a desired property. Thanks to the nature of ZDDs, our algorithms offer a tool to assist users to design instances of those link puzzles.

1. Introduction

Link puzzles, for example Slitherlink, Numberlink, Masyu, etc., are logic puzzles that involve finding paths or a cycle in a grid that satisfy given local and global properties. This paper focuses on two simple link puzzles, Numberlink and Slitherlink, amongst others.

Numberlink is played on a grid where the rules are below [1].

• Connect pairs of the same numbers with a continuous line.
• Lines go through the center of the cells, horizontally, vertically, or changing direction, and never twice through the same cell.
• Lines cannot cross, branch off, or go through the cells with numbers.

 Figure 1 describes an instance of Numberlink. Numberlink is known to be NP-complete [2,3,4]. Numberlink is also studied as a model of VLSI layout design [5].

Figure 1. An instance of Numberlink and its solution.

Slitherlink is played on a grid of lattice dots where we draw a loop satisfying below [1].

• Connect adjacent dots with vertical or horizontal lines.
• A single loop is formed with no crossing or branches.
• The numbers indicate how many lines surround it, while empty cells may be surrounded by any number of lines.

We describe an instance of Slitherlink in  Figure 2. Slitherlink is known to be NP-complete [6,7].

Figure 2. An instance of Slitherlink and its solution.

Link puzzles have been popularized by a Japanese publisher Nikoli and many puzzle designers are trying to produce good and interesting instances. The least common criterion on instances to be good is to admit exactly one solution, but what should be good and interesting is quite a subjective issue to respective designers. The complexity barrier suggests difficulties in the instance design.

On the other hand, as is usually the case for logic puzzles, computer scientists and programmers have been proposed several automatic solvers targeting those link puzzles. Sugar [8] is a SAT based constraint solver which is provided with formulation of Numberlink and Slitherlink. While it is often the case that a solution for an instance of Numberlink is found just by inspiration, many local solution methods for Slitherlink are known. Most Slitherlink solvers employ such methods [9,10,11].

Moreover, there are some attempts to automatically generate instances of Slitherlink. Shirai’s algorithm [10] starts from a grid graph with no numbers, which admits many solutions, and repeatedly puts a random number into a random cell one by one until the obtained instance admits a unique solution. The opposite approached has been proposed by Shirai et al. [10] and Wan [11]. Their algorithm takes a cycle, which is a predetermined solution, as input and starts from a grid whose cells are all fulfilled by the numbers compatible with the solution. The algorithm then repeatedly removes the number in a random cell one by one until the obtained instance admits an unexpected solution. The algorithm outputs the instance obtained just before removing the last number.

Our contribution is located in this line of research. We propose solution and instance enumeration algorithms for Numberlink and Slitherlink. Unlike existing algorithms, ours output all the qualified solutions/instances at once in the form of a zero-suppressed binary decision diagram (ZDD). A ZDD is a compressed data structure for representing and manipulating families of sets [12]. Recently, Knuth [13, exercise 225] has proposed an algorithm, called Simpath, that constructs a ZDD representing all s-t paths on a given graph and two vertices s and t, where a path is identified with the set of edges constituting the path. If an instance of Numberlink has only one pair of numbers in a grid, Simpath gives all solutions to it. Knuth has also proposed a modification of Simpath that enumerates all single cycles on an input graph in the form of a ZDD. Recall that to be a cycle is a necessary condition to be a solution for Slitherlink. Our solvers for the link puzzles construct a ZDD representing solutions in the manner of Simpath with taking the constraints from the problem instance into account. By the nature of enumeration, one can immediately decide whether an instance admits exactly one solution.

ZDDs can represent families of sets in a small space, yet an even more important and widely appreciated virtue of ZDDs is that one can quite efficiently perform fundamental mathematical operations on families of sets over ZDDs, like union, intersection, etc. Our algorithms for generating instances of the link puzzles apply the virtue of ZDDs. Our method based on ZDDs offers users flexible means to design puzzle instances. For example, puzzle designers can extract some specific kind of instances from the whole which they think “interesting” by those set operations over ZDDs.

This paper is organized as follows. Formal definitions of ZDDs, Numberlink and Slitherlink are given in Section 2. Section 3 introduces a variant of Simpath that enumerates all path matchings over a graph, on which other algorithms of ours are based. Our Numberlink solver is presented in Section 4 and Numberlink instance enumeration algorithm is proposed in Section 5. On the other hand, our Slitherlink solver and instance enumeration algorithm are presented in Section 6 and Section 7, respectively. We also show experimental results on these algorithms in Section 8, where we compare the performance of known solving algorithms and ours. Moreover, we demonstrate how our method may help puzzle designers through presenting visually attractive instances of Slitherlink obtained by our algorithm. We then conclude the paper in Section 9.

2. Preliminaries

2.1. Zero-Suppressed Binary Decision Diagrams

A zero-suppressed binary decision diagram, ZDD for short, represents a family of sets over a universal set E whose elements are linearly ordered [12]. We index the elements of E as $e_1,\cdots ,e_{\left|E\right|}$ where we write $e_i\le e_j$ if and only if $i\le j$. A ZDD is defined to be a labeled directed acyclic graph that satisfies the following properties.

• There is only one node with indegree 0, called the root node.
• There are just two nodes $\mathbf{0}$ and $\mathbf{1}$ with outdegree 0, called the 0-terminal and 1-terminal.
• Each node except terminals has just 2 outgoing arcs, which are labeled by 0 and 1 and called the 0-arc and 1-arc, respectively. We call the node pointed by the j-arc of a node n the j-child of n.
• Each node n except for the terminals is labeled by an element of E.
• The label of a non-terminal node is strictly smaller than those of its children.

If a node n is the j-child of another node $n^{\prime }$, we call $n^{\prime }$ a j-parent of n for $j\in \{0,1\}$. We say that a path from the root node of a ZDD Z is valid if it ends in a node which is not $\mathbf{0}$. To each valid path $\pi$ we assign a set $Z\left(\pi \right)\subseteq E$ by

$$Z\left(\pi \right)=\{e_j\mid \mathrm{the}1\text{-}\mathrm{arc}\mathrm{of}\mathrm{a}\mathrm{node}\mathrm{labeled}\mathrm{with}{e}_j\mathrm{appears}\mathrm{in}\pi \}$$

By representing a path from the root node of a ZDD by a sequence of 0 and 1, which we call a $0,1$-sequence, we have an alternative inductive definition of the set:

$$\begin{array}{cc}\hfill Z(\pi ·0)& =Z\left(\pi \right)\hfill \\ \hfill Z(\pi ·1)& =Z\left(\pi \right)\cup \left\{e\right\}\hfill \end{array}$$

where e is the label of the node in which $\pi$ ends. Each node $n\ne \mathbf{0}$ is assigned a set $Z\left(n\right)\subseteq 2^E$ defined by

$$Z\left(n\right)=\left\{Z\right(\pi )\mid \mathrm{a}\mathrm{valid}\mathrm{path}\pi \mathrm{ends}\mathrm{in}n\}$$

An equivalent inductive definition is given by

$$\begin{array}{cc}\hfill Z\left(n\right)=& \{S\mid S\in Z\left(n^{\prime }\right)\mathrm{for}\mathrm{some}0\text{-}\mathrm{parent}{n}^{\prime }\mathrm{of}n\}\hfill \\ & \cup \{S\cup \left\{e\right\}\mid S\in Z\left(n^{\prime }\right)\mathrm{for}\mathrm{some}1\text{-}\mathrm{parent}{n}^{\prime }\mathrm{of}n\mathrm{such}\mathrm{that}{n}^{\prime }\mathrm{is}\mathrm{labeled}\mathrm{with}e\}\hfill \end{array}$$

The family of sets that a ZDD represents is defined to be $Z\left(\mathbf{1}\right)$. Figure 3 shows an example of a ZDD.

Figure 3. The reduced ZDD representing $Z\left(\mathbf{1}\right)=\left\{\right\{\mathtt{a}\},\{\mathtt{b}\},\{\mathtt{c}\},\{\mathtt{a},\mathtt{c}\},\{\mathtt{b},\mathtt{c}\left\}\right\}$. $E=\{\mathtt{a},\mathtt{b},\mathtt{c}\}$ where $\mathtt{a}<\mathtt{b}<\mathtt{c}$. Dotted lines represent 0-arcs and solid lines represent 1-arcs.

A ZDD is said to be reduced if

• there is no distinct nodes that have the same label, 0-child and 1-child,
• there is no node whose 1-child is $\mathbf{0}$.

It is known that every ZDD admits a unique reduced one that represents the same family of sets. Moreover the number of nodes of a ZDD is minimum amongst ZDDs representing the same family if and only if it is reduced. A linear-time algorithm that reduces a ZDD can be found in [13, pp. 84–85, algorithm R].

A (reduced) ZDD can represent a family of sets in a compact way by letting multiple sets in the family share some subgraphs of the ZDD. If sets in the family have some “regular” structures, the size of the ZDD can be logarithmically smaller than the sum of the cardinalities of the sets in it. An even more important and widely appreciated virtue of ZDDs is that one can efficiently perform fundamental mathematical operations on families of sets over ZDDs, like union, intersection, etc. The efficiency depends on the size of the ZDDs rather than the cardinality of the sets in the target families. Some packages of implementation of ZDDs are provided to users of different purposes, where for given two ZDDs representing families of sets A and B, it can compute the ZDD for $A\cup B$, $A\cap B$, $A\setminus B$, $A\oplus B$ and so on. For $e\in E$, it can compute the ZDD for $\{S\cup \{e\}\mid S\in A\}$, $\{S\setminus \{e\}\mid S\in A\mathrm{and}e\in S\}$, $\{S\mid S\in A\mathrm{and}e\notin S\}$ etc. Knuth [13] has discussed further operations for families of sets, which enable us to extract maximal elements $\{S\in A\mid \neg \exists T\in A,S⊊T\}$, minimal elements $\{S\in A\mid \neg \exists T\in A,T⊊S\}$ among others. For more details of ZDDs, readers are referred to [12,13], for example.

2.2. Undirected Graphs

The link puzzles concerned in this paper are played on undirected graphs. This paper uses ZDDs to represent subgraphs of graphs of puzzle instances. To avoid confusion among objects of those two kinds of graphs simultaneously in concern, we reserve words “nodes” and “arcs” for ZDDs, while we call the corresponding notions for graphs of puzzle instances “vertices” and “edges”.

An undirected graph is a pair $G=(V,E)$ where V is a set of vertices and $E\subseteq 2^V$ is a set of edges, which are sets of exactly two elements of V. An edge $e\in E$ is said to be incident to $v\in V$ if $v\in e$. The degree of a vertex v in G is defined by $\left|\right\{e\in E\mid v\in e\left\}\right|$, that is, the number of edges incident to v. For an edge set $E^{\prime }\subseteq E$, we also define the degree of v in $E^{\prime }$ by $\left|\right\{e\in E^{\prime }\mid v\in e\left\}\right|$. A vertex v is isolated if its degree is 0.

A nonempty edge set $P=\{e_1,\cdots ,e_{\left|P\right|}\}\subseteq E$ is called a simple path (or just a path) if there are pairwise distinct vertices $v_0,\cdots ,v_{\left|P\right|}\in V$ such that $e_i=\{v_{i-1},v_i\}$ for $i=1,\cdots ,\left|P\right|$. The path P is also called a $v_0$-$v_{\left|P\right|}$ path.

A nonempty edge set $C=\{e_1,\cdots ,e_{\left|C\right|}\}\subseteq E$ is called a (simple) cycle if $\left|C\right|\ge 3$ and there are pairwise distinct vertices $v_1,\cdots ,v_{\left|C\right|}\in V$ such that $e_1=\{v_1,v_{\left|C\right|}\}$ and $e_i=\{v_{i-1},v_i\}$ for $i=2,\cdots ,\left|C\right|$.

A possibly empty edge set $P\subseteq E$ is called a path matching if there are simple paths $P_1,\cdots ,P_k$ with $k\ge 0$ such that $P={\bigcup }_{1\le i\le k}{P}_i$ and $\bigcup P_i\cap \bigcup P_j=\varnothing$ for distinct $i,j\in \{1,\cdots ,k\}$ (For a family P of sets over a universal set V, we define $\bigcup P={\bigcup }_{e\in P}e=\{v\in V\mid v\in e\mathrm{for}\mathrm{some}e\in P\}$.). We remark that for a path matching P, a way of partitioning P into paths satisfying this definition is unique. We say that P contains a u-v path if one of such paths is a u-v path.

A family $T\subseteq 2^V$ of sets over V is called a pair matching if T consists of pairwise disjoint sets of size 2.

Lemma 1. 

For a graph $G=(V,E)$, an edge set $P\subseteq E$ is not a path matching if and only if there is a vertex $v\in \bigcup P$ of degree more than 2 in P or there is a subset $C\subseteq P$ that is a simple cycle.

2.3. Link Puzzles

Definition 2 

(Numberlink). An instance of the Numberlink problem is a pair of a graph (Usually the graph G in an instance is a rectangular grid as described in the introduction, but this paper targets the more general problem described here.) $G=(V,E)$ and a pair matching h on V. A path matching on G is said to be a solution of $(G,h)$ if and only if it contains $u\text{-}v$ paths for all $\{u,v\}\in h$ but no other.

An instance $(G,h)$ of the Numberlink problem is said to be good if $(G,h)$ admits exactly one solution P and moreover the unique solution P covers every vertex: i.e., $\bigcup P=V$.

Theorem 3. 

[2,3,5] For input G and h, deciding whether $(G,h)$ admits a solution is NP-complete.

Definition 4 

(Slitherlink). An instance of the Slitherlink problem is a pair of a graph $G=(V,E)$ and a partial mapping $h:2^E\rightharpoonup \mathbb{N}$ such that $h\left(E^{\prime }\right)\le \left|E^{\prime }\right|$ for all $E^{\prime }\in \mathrm{dom}\left(h\right)$, where $\mathrm{dom}\left(h\right)$ denotes the domain of h (Usually G is a grid graph and $h\left(E^{\prime }\right)$ is defined only when $E^{\prime }$ is a cycle consisting of just four edges.). We call h a hint assignment. A solution of $(G,h)$ is a cycle C over G such that $h\left(E^{\prime }\right)=|C\cap E^{\prime }|$ for all $E^{\prime }\in \mathrm{dom}\left(h\right)$. An instance $(G,h)$ of the Slitherlink problem is said to be good if $(G,h)$ admits exactly one solution.

Theorem 5. 

[14] For input G and h, deciding whether $(G,h)$ admits a solution is NP-complete. For input $(G,h)$ and a solution C, deciding whether $(G,h)$ admits another solution $C^{\prime }\ne C$ is NP-complete.

In this paper, we assume that G is connected on both puzzles.

3. ZDD for Path Matchings

Knuth has proposed an algorithm that constructs a ZDD representing all the s-t paths on a given graph G and two vertices s and t in G, as an answer to Exercise 225 in [13]. Based on Knuth’s algorithm, this section presents an algorithm that constructs in a topdown manner a ZDD $Z_G$ representing all the path matchings over a graph $G=(V,E)$. This algorithm prepares for our puzzle solvers.

Let $G=(V,E)$ be an undirected graph. The edge set $E=\{e_1,\cdots ,e_{\left|E\right|}\}$ is the universal set of $Z_G$, where we have $e_i\le e_j$ if and only if $i\le j$. We define $E^{\ge e_i}=\{e_j\in E\mid e_j\ge e_i\}$. The root node $n_{\mathrm{root}}$ of $Z_G$ is labeled with $e_1$ and if a node is labeled with $e_i$ then its children are labeled with $e_{i+1}$ unless they are terminal nodes, $\mathbf{0}$ or $\mathbf{1}$. By $N_i$ we denote the set of nodes with the label $e_i$ for $i=1,\cdots ,\left|E\right|$. Hence $N_1$ is the singleton of the root node $n_{\mathrm{root}}$ and $N_{i+1}$ consists of the children of nodes in $N_i$. Every valid path ending in $\mathbf{1}$ has length $\left|E\right|$ in $Z_G$. For a $0,1$-sequence $\pi$, we denote the length of $\pi$ by $\left|\pi \right|$. For $\pi$ with $\left|\pi \right|\le \left|E\right|$, we define

$$E\left(\pi \right)=\{e_i\in E\mid \mathrm{the}i\mathrm{th}\mathrm{number}\mathrm{of}\pi \mathrm{is}1\}$$

We then have $Z_G\left(\pi \right)=E\left(\pi \right)$ if $\pi$ is a valid path in $Z_G$. For a valid path $\pi$, we let $n\left(\pi \right)$ denote the node in which $\pi$ ends. We have $Z_G\left(n\right)=\{E\left(\pi \right)\mid n\left(\pi \right)=n\}$. The ZDD $Z_G$ will be constructed so that

$$E\left(\pi \right)\subseteq E\mathrm{is}\mathrm{a}\mathrm{path}\mathrm{matching}\mathrm{if}\mathrm{and}\mathrm{only}\mathrm{if}\pi \mathrm{is}\mathrm{valid}\mathrm{in}{Z}_G$$

(1)

Note that every subgraph of a path matching is a path matching.

Our algorithm constructs $Z_G$ in a top-down manner. The construction consists of $\left|E\right|$ phases, where we create nodes in $N_{i+1}$ as children of nodes in $N_i$ in the ith phase. Figure 4 illustrates an example of G and $Z_G$, which would help the reader understand our algorithm. We first initialize $N_i$ to be empty for all $i=2,\cdots ,\left|E\right|$ and $N_1$ to be the singleton of the root node $n_{\mathrm{root}}$. We create nodes in $N_i$ after the upper part of $Z_G$ consisting of the nodes in ${\bigcup }_{j<i}{N}_j$ and the arcs among them have been constructed for $i=2,\cdots ,\left|E\right|$.

Figure 4. An example of G and $Z_G$.

The algorithm stores some topological information of the path matching $E\left(\pi \right)$ at the node $n=n\left(\pi \right)$ reached by a valid path $\pi$. Let $\left|\pi \right|=i-1$, where we have $n\in N_i$ and n is labeled by $e_i$ unless $n=\mathbf{1}$. We assign the node n a function ${\mathrm{mate}}_n:V^{\ge e_i}\to V\cup \left\{0\right\}$, which we call a mate function, where $V^{\ge e_i}=\bigcup E^{\ge e_i}$ and $0\notin V$. It is determined so that

$${\mathrm{mate}}_n\left(v\right)=\left\{\begin{array}{cc}v\hfill & \mathrm{if}v\notin \bigcup E\left(\pi \right)\hfill \\ u\hfill & \mathrm{if}E\left(\pi \right)\mathrm{contains}\mathrm{a}u\text{-}v\mathrm{path}\hfill \\ 0\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(2)

for each $v\in V^{\ge e_i}$. In other words, ${\mathrm{mate}}_n\left(v\right)=v$ if v has degree 0 in $E\left(\pi \right)$, and ${\mathrm{mate}}_n\left(v\right)=0$ if v has degree 2 in $E\left(\pi \right)$. Particularly for the root node $n_{\mathrm{root}}$, we have ${\mathrm{mate}}_{n_{\mathrm{root}}}\left(v\right)=v$ for all $v\in V^{\ge e_1}$; the set $V^{\ge e_1}$ is identical to V, since G has no isolated vertices. The domain of a mate function ${\mathrm{mate}}_n$ is restricted to $V^{\ge e_i}$, which is the set of vertices to which at least one edge in $E^{\ge e_i}$ is incident. We are not interested in the topological information on vertices that we will not visit any more. Note that $V^{\ge e_i}=V^{\ge e_{i+1}}\cup e_i$. Hereafter we stipulate that $V^{\ge e_{\left|E\right|+1}}$ denotes the empty set.

In the example of Figure 4, we have $V=V^{\ge e_1}=V^{\ge e_2}=\{p,q,r,s\}$, $V^{\ge e_3}=e_3\cup e_4=\{q,r,s\}$ and $V^{\ge e_4}=e_4=\{q,s\}$. For $\pi =1·1$, $E\left(\pi \right)=\{e_1,e_2\}$ is a path matching consisting solely of a q-r path. The domain of the mate function ${\mathrm{mate}}_{n\left(\pi \right)}$ is $V^{\ge e_3}=\{q,r,s\}$ and ${\mathrm{mate}}_{n\left(\pi \right)}\left(q\right)=r$, ${\mathrm{mate}}_{n\left(\pi \right)}\left(r\right)=q$ and ${\mathrm{mate}}_{n\left(\pi \right)}\left(s\right)=s$.

Let us consider the ith phase of our algorithm, where we already have constructed an incomplete ZDD until the nodes in $N_i$. We determine the children of a node $n\left(\pi \right)\in N_i$ for a valid path $\pi$. The arcs given in this phase correspond to the choice whether or not we pick $e_i$ in a path matching. Let $n=n\left(\pi \right)$.

Giving a 0-child to n involves no difficulty. By assumption $E\left(\pi \right)$ is a path matching and by definition $E(\pi ·0)=E\left(\pi \right)$. We create a node $n^{\prime }$ in $N_{i+1}$ as the 0-child of n and label $n^{\prime }$ by $e_{i+1}$. That is, $n(\pi ·0)=n^{\prime }$. The mate function ${\mathrm{mate}}_{n^{\prime }}$ of $n^{\prime }$ should be identical to ${\mathrm{mate}}_n$ except that the domain $\mathrm{dom}\left({\mathrm{mate}}_{n^{\prime }}\right)=V^{\ge e_{i+1}}$ may be smaller than $\mathrm{dom}\left({\mathrm{mate}}_n\right)=V^{\ge e_i}$. In the case where $i=\left|E\right|$, the 0-child of n is $\mathbf{1}$.

On the other hand, $E(\pi ·1)\ne E\left(\pi \right)$ and it is not always the case that $E(\pi ·1)$ is a path matching. If $E(\pi ·1)$ is not a path matching, the 1-child of n should be $\mathbf{0}$. Otherwise, we give a node $n^{\prime \prime }$ with an appropriate mate function as the 1-child of n. We must decide whether $E\left(\pi \right)\cup \left\{e_i\right\}$ is still a path matching or not. Let $e_i=\{u,v\}$. We note that u and v are in the domain $V^{\ge e_i}$ of ${\mathrm{mate}}_n$. There exist several cases depending on the topology of $E\left(\pi \right)$. Recall that an edge set $P\subseteq E$ is a path matching if and only if the degree of every node in P is at most 2 and no subset $P^{\prime }\subseteq P$ is a cycle. In the case where ${\mathrm{mate}}_n\left(u\right)=0$, the degree of u in $E\left(\pi \right)$ is 2, so the degree of u will be 3 in $E\left(\pi \right)\cup \left\{e_i\right\}$, which is therefore not a path matching. The same holds when ${\mathrm{mate}}_n\left(v\right)=0$. Moreover, if ${\mathrm{mate}}_n\left(u\right)=v$ (equivalently ${\mathrm{mate}}_n\left(v\right)=u$), which means that $E\left(\pi \right)$ contains a u-v path $P_{u,v}\subseteq E\left(\pi \right)$, then $E\left(\pi \right)\cup \left\{e_i\right\}$ contains a simple cycle $P_{u,v}\cup \left\{e_i\right\}$. We say that a mate function m rejects an edge $\{u,v\}$ if $m\left(u\right)\in \{0,v\}$ or $m\left(v\right)\in \{0,u\}$. If ${\mathrm{mate}}_n$ rejects $e_i$, then $E(\pi ·1)$ is not a path matching, hence the 1-child of n should be $\mathbf{0}$. On the other hand, if ${\mathrm{mate}}_n$ does not reject $e_i$, $E\left(\pi \right)\cup \left\{e_i\right\}$ is a path matching. So we need to give a node as the 1-child of n. Particularly in the case where $i=\left|E\right|$, the 1-child of n will be $\mathbf{1}$. If $i<\left|E\right|$, we create a node $n^{\prime \prime }$ in $N_{i+1}$ as the 1-child of n (i.e., $n^{\prime \prime }=n(\pi ·1)$) and assign a function ${\mathrm{mate}}_{n^{\prime \prime }}$ that is consistent with the requirement of Equation (2). Actually one can compute ${\mathrm{mate}}_{n^{\prime \prime }}$ from ${\mathrm{mate}}_n$ and $e_i=\{u,v\}$ by

$${\mathrm{mate}}_{n^{\prime \prime }}\left(w\right)=\left\{\begin{array}{cc}0\hfill & \mathrm{if}w\in e_i=\{u,v\}\mathrm{and}{\mathrm{mate}}_n\left(w\right)\ne w\hfill \\ {\mathrm{mate}}_n\left(v\right)\hfill & \mathrm{if}{\mathrm{mate}}_n\left(w\right)=u\hfill \\ {\mathrm{mate}}_n\left(u\right)\hfill & \mathrm{if}{\mathrm{mate}}_n\left(w\right)=v\hfill \\ {\mathrm{mate}}_n\left(w\right)\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(3)

for $w\in \mathrm{dom}\left({\mathrm{mate}}_{n^{\prime \prime }}\right)=V^{\ge e_{i+1}}$.

We explain why this is correct. The first case means that w has degree 1 in $E\left(\pi \right)$. Hence, the degree of $w\in e_i$ will be 2 in $E\left(\pi \right)\cup \left\{e_i\right\}$ (Figure 5(a)). In the second case, ${\mathrm{mate}}_n\left(w\right)=u$ means either that $E\left(\pi \right)$ has a w-u path or that $w=u$ and w is isolated in $E\left(\pi \right)$. It is convenient for explanation to regard an isolated vertex t as a t-t path. According to this terminology, $E\left(\pi \right)$ contains a w-u path and a v-${\mathrm{mate}}_n\left(v\right)$ path. Then the edge $e_i=\{u,v\}$ will bridge those paths: $E\left(\pi \right)\cup \left\{e_i\right\}$ contains a w-${\mathrm{mate}}_n\left(v\right)$ path (Figure 5(b)). The third case is similar to the second case. If none of those three cases apply, adding $e_i$ does not matter for the vertex w. We note that by the assumption, the first three cases are mutually exclusive.

Figure 5. updating mate.

Summarizing the above, by observing ${\mathrm{mate}}_n$, one can determine whether $E(\pi ·1)$ is a path matching or not. Moreover one can compute both ${\mathrm{mate}}_{n^{\prime }}$ and ${\mathrm{mate}}_{n^{\prime \prime }}$ for the 0-child $n^{\prime }$ and 1-child $n^{\prime \prime }$ of n, respectively, unless they are $\mathbf{0}$ or $\mathbf{1}$. Consequently, if two nodes $n_1$ and $n_2$ with the same label have the same mate function, their descendants will constitute subgraphs of exactly the same shape in $Z_G$. This means that such equivalent nodes $n_1$ and $n_2$ should be merged before generating children.

Our actual algorithm, shown as Algorithm 1, maintains each node set $N_i$ not to contain distinct nodes assigned the same mate function. This is realized by a procedure named $\mathrm{GN}$ (short for “getting a node”) which takes two arguments: an edge index $i\in \{1,\cdots ,|E\left|\right\}$ and a mate function m. $\mathrm{GN}(i,m)$ returns a node labeled $e_i$ and assigned m. If such a node has already been created in $N_i$, that node is returned. Otherwise, we create one in $N_i$ and return it. It is conveniently assumed that $\mathrm{GN}\left(\right|E|+1,m)$ gives the terminal node $\mathbf{1}$. Note that this procedure may update $N_i$.

Algorithm 1: Enumeration of path matchings

For a node labeled $e_i$ and assigned a mate function m which does not reject $e_i$, the mate function of its 1-child is given by $\mathrm{MU}(m,e_i){|}_{V^{\ge e_{i+1}}}$ in Algorithm 1, which is determined in the way described in Equation (3). That is, $\mathrm{MU}$ (short for “mate update”) takes a mate function m and an edge $e_i$ and returns a mate function defined by

$$\mathrm{MU}(m,e_i)\left(w\right)=\left\{\begin{array}{cc}0\hfill & \mathrm{if}w\in e_i\mathrm{and}m\left(w\right)\ne w\hfill \\ m\left(v\right)\hfill & \mathrm{if}{e}_i=\{v,m\left(w\right)\}\hfill \\ m\left(w\right)\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

for each $w\in \mathrm{dom}\left(m\right)$. The domain of $\mathrm{MU}(m,e_i)$ is the same as that of m. By $\mathrm{MU}(m,e_i){|}_{V^{\ge e_{i+1}}}$ we denote the subfunction of $\mathrm{MU}(m,e_i)$ whose domain is restricted to $V^{\ge e_{i+1}}$.

We prove the correctness of Algorithm 1 in Appendix A.

4. Numberlink Solver

This section presents a Numberlink solver, which constructs a ZDD that represents all the solutions for a given instance $(G,h)$ of Numberlink. Recall that a solution for an instance $(G,h)$ of Numberlink is a path matching that satisfies a property represented by the pair matching h. It is in fact rather easy to modify Algorithm 1 to obtain a Numberlink solver.

Let us consider when we should connect an arc of a node to $\mathbf{0}$ in addition to the cases we have discussed in Section 3. Suppose that we have chosen edges from $\{e_1,\cdots ,e_i\}$ and by picking up other edges from $E^{\ge e_{i+1}}$, we would like to form a solution. Let $\pi$ be a $0,1$-sequence of length i that represents the choice. It is easy to see that if one of the following conditions holds, $E\left(\pi \right)\cup P$ cannot be a solution of $(G,h)$ for any edge set $P\subseteq E^{\ge e_{i+1}}$.

• $E\left(\pi \right)$ is not a path matching,
• there is $v\in \bigcup h$ of degree 2 in $E\left(\pi \right)$,
• there is $v\in \bigcup h\setminus V^{\ge e_{i+1}}$ of degree 0 in $E\left(\pi \right)$,
• there are $u,v\in \bigcup h$ such that $E\left(\pi \right)$ contains a u-v path and $\{u,v\}\notin h$,
• there is a vertex $v\notin \bigcup h\cup V^{\ge e_{i+1}}$ of degree 1 in $E\left(\pi \right)$.

Our Numberlink solver, shown as Algorithm 2, constructs a ZDD so that if a path $\pi$ of length i satisfies one of the above, then (a prefix of) $\pi$ leads to $\mathbf{0}$. While Algorithm 1 connects no 0-arcs to $\mathbf{0}$, our Numberlink solver sometimes connects 0-arcs to $\mathbf{0}$ according to the above conditions. This judgement is realized by observing the mate functions. For a mate function $m:V^{\ge e_i}\to V\cup \left\{0\right\}$ and an edge index i, we say that $(m,i,0)$ is incompatible with h if for some$v\in e_i\setminus V^{\ge e_{i+1}}$, one of the following conditions holds.

• $v\in \bigcup h$ and $m\left(v\right)=v$,
• $v\notin \bigcup h$ and $m\left(v\right)\notin \{0,v\}$.

When $({\mathrm{mate}}_n,i,0)$ is incompatible with h for $n\in N_i$, the 0-arc of n should be connected to $\mathbf{0}$, since $P=E(\pi ·0)\cup E^{\prime }$ cannot be a solution for any $E^{\prime }\subseteq E^{\ge e_{i+1}}$. In the first case, the degree of $v\in \bigcup h$ is 0 in P. In the second case, the degree of $v\notin \bigcup h$ is 1 in P.

Algorithm 2: Numberlink solver

We prove the correctness of Algorithm 2 in Appendix B.     

We say that $(m,i,1)$ is incompatible with h if for $e_i=\{u,v\}$, one of the following conditions holds.

• m rejects $e_i$, i.e., $m\left(v\right)\in \{0,u\}$,
• $v\in \bigcup h$ and $m\left(v\right)\ne v$,
• $m\left(u\right),m\left(v\right)\in \bigcup h\cup (V\setminus V^{\ge e_{i+1}})$ and $\left\{m\right(u),m(v\left)\right\}\notin h$.

When $({\mathrm{mate}}_n,i,1)$ is incompatible with h for $n\in N_i$, the 1-arc of n should be connected to $\mathbf{0}$, since $P=E(\pi ·1)\cup E^{\prime }$ cannot be a solution for any $E^{\prime }\subseteq E^{\ge e_{i+1}}$. In the first case, P is not a path matching. In the second case, v has degree more than 1 in P. In the third case, either P contains a ${\mathrm{mate}}_n\left(u\right)$-${\mathrm{mate}}_n\left(v\right)$ path or the degree of ${\mathrm{mate}}_n\left(u\right)\in \bigcup h$ or ${\mathrm{mate}}_n\left(v\right)\in \bigcup h$ is more than 1 in P.

Remark 6. 

It is obvious that no proper superset of a solution for $(G,h)$ can be another solution. One can modify Algorithm 2 so that a path $\pi$ directly leads to $\mathbf{1}$ if $E\left(\pi \right)$ is a solution. Replace $\mathrm{GN}$ by ${\mathrm{GN}}_h$ where

$${\mathrm{GN}}_h(i,m)=\left\{\begin{array}{cc}\mathbf{1}\hfill & \mathrm{if}\mathrm{for}\mathrm{any}u\in \mathrm{dom}\left(m\right)\mathrm{and}v\in V,\mathrm{we}\mathrm{have}\left(\right\{u,v\}\in h\mathrm{iff}m(u)=v\ne u)\hfill \\ \mathrm{GN}(i,m)\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

Remark 7. 

An alternative definition of Numberlink requires a solution to cover all the vertices. This constraint drastically shrinks the search space. It is easy to modify our algorithm to obtain only such strict solutions. We say that $(m,i,0)$ is incompatible with h if it is incompatible in the above sense or there is $v\in V^{\ge e_i}\setminus V^{\ge e_{i+1}}$ such that $m\left(v\right)=v$, which means that v is not covered.

5. Numberlink Instance Enumeration

This section presents an algorithm that enumerates all pair matchings h that give a good instance $(G,h)$ of the Numberlink problem for a given graph G. Fixing G, we say that a pair matching h is good if $(G,h)$ is a good instance. Let us first consider an easier task, which enumerates all the instances that admit at least one solution. A solution for an instance of the Numberlink problem is a path matching and conversely every path matching P on G consisting of $u_i$-$v_i$ simple paths for all $i=1,\cdots ,k$ is a solution for $(G,h_P)$ where $h_P$ consists of $\{u_i,v_i\}$ for all$i=1,\cdots ,k$. Our instance enumeration algorithm, shown as Algorithm 3, is again based on Algorithm 1, but now what we should enumerate is not edge sets but rather pair matchings. The ZDD $Z_G$ output by Algorithm 1 will be a part of the input of Algorithm 3.

For a valid path $\pi$ in $Z_G$, the corresponding path matching $E\left(\pi \right)$ consists of two kinds of simple paths: fixed paths and unfixed paths. Fixed paths are u-v paths where $u,v\notin V^{\ge e_{\left|\pi \right|+1}}=\mathrm{dom}\left({\mathrm{mate}}_{n\left(\pi \right)}\right)$. In other words, every fixed path in $E\left(\pi \right)$ will be a constituent of any path matching represented as $E(\pi ·\rho )$ (We note that whether a simple path in a path matching $E\left(\pi \right)$ is fixed or unfixed depends on $\pi$ rather than $E\left(\pi \right)$ itself. Yet we prefer a concise phrasing relying on the reader’s flexibility and assume that the vertex set in concern is understood.). We note that by definition ${\mathrm{mate}}_{n\left(\pi \right)}$ does not tell us whether $E\left(\pi \right)$ contains a fixed u-v path. On the other hand, the presence of an unfixed u-v path is observed in the mate function. If a u-v path is unfixed, at least one of $u,v$ is in $V^{\ge e_{\left|\pi \right|+1}}=\mathrm{dom}\left({\mathrm{mate}}_{n\left(\pi \right)}\right)$. Without loss of generality, we assume $u\in \mathrm{dom}\left({\mathrm{mate}}_{n\left(\pi \right)}\right)$, where we have ${\mathrm{mate}}_{n\left(\pi \right)}\left(u\right)=v$. Since u has an incident edge in $E^{\ge e_{\left|\pi \right|+1}}$, the path may be extended so that u has degree 2.

Algorithm 3: Numberlink Generator

We prove the correctness of Algorithm 3 in Appendix C.     

Let $T\left(\pi \right)$ denote the pair matching corresponding to the ends of fixed paths:

$$T\left(\pi \right)=\{\{u,v\}\subseteq V\mid E\left(\pi \right)\mathrm{contains}\mathrm{a}u\text{-}v\mathrm{path}\mathrm{with}u,v\notin V^{\ge e_{\left|\pi \right|+1}}\}$$

Note that $T\left(\pi \right)\subseteq T(\pi ·\rho )$ for any $\pi$ and $\rho$ as long as $E(\pi ·\rho )$ is a path matching. We decorate each node n of the ZDD $Z_G$ with the family

$$S_n=\{T\left(\pi \right)\mid n\left(\pi \right)=n\}$$

When a path $\pi$ ends in $\mathbf{1}$ in $Z_G$, all the simple paths constituting $E\left(\pi \right)$ are fixed. By definition, $S_{\mathbf{1}}$ will be the family of pair matchings h such that $(G,h)$ admits a solution. For different valid paths $\pi$ and $\rho$ ending in the same node $n=n\left(\pi \right)=n\left(\rho \right)$, $E\left(\pi \right)$ and $E\left(\rho \right)$ may have different fixed paths, but they share the same unfixed paths. We present an example of $T\left(\pi \right)$ and $S_n$ in Appendix F.

Let us think about how to compute the family $S_n$ of a node n from the pair matching families $S_{n^{\prime }}$ assigned to its parents $n^{\prime }$. By definition, it is not hard to see that

$$\begin{array}{cc}\hfill T(\pi ·0)\setminus T\left(\pi \right)& =\{\{u,v\}\subseteq V\mid E(\pi ·0)\mathrm{contains}\mathrm{a}u\text{-}v\mathrm{path}\mathrm{with}u\in e_i\mathrm{and}u,v\notin V^{\ge e_{i+1}}\}\hfill \\ \hfill T(\pi ·1)\setminus T\left(\pi \right)& =\{\{u,v\}\subseteq V\mid E(\pi ·1)\mathrm{contains}\mathrm{a}u\text{-}v\mathrm{path}P\mathrm{with}{e}_i\in P\mathrm{and}u,v\notin V^{\ge e_{i+1}}\}\hfill \end{array}$$

where $i=\left|\pi \right|+1$. Define

$$\begin{array}{cc}\hfill \mathrm{Fix}(m,i,0)& =\{\{u,m\left(u\right)\}\mid u\in e_i,m\left(u\right)\notin \{u,0\}\mathrm{and}u,m\left(u\right)\notin V^{\ge e_{i+1}}\}\hfill \\ \hfill \mathrm{Fix}(m,i,1)& =\{\{m\left(u\right),m\left(v\right)\}\mid \{u,v\}=e_i\mathrm{and}m\left(u\right),m\left(v\right)\notin V^{\ge e_{i+1}}\}\hfill \end{array}$$

We now have

$$\begin{array}{cc}\hfill T(\pi ·b)& =T\left(\pi \right)\cup \mathrm{Fix}({\mathrm{mate}}_{n\left(\pi \right)},|\pi |+1,b)\hfill \end{array}$$

for both $b=0,1$. Therefore, for $n\in N_{i+1}$,

$$\begin{array}{cc}\hfill S_n=\bigcup \{& S_{n^{\prime },b}\mid n^{\prime }\mathrm{is}\mathrm{a}b\text{-}\mathrm{parent}\mathrm{of}n\mathrm{for}b\in \{0,1\}\}\hfill \\ \hfill \mathrm{where}& S_{n^{\prime },b}=\{T\cup \mathrm{Fix}({\mathrm{mate}}_{n^{\prime }},i,b)\mid T\in S_{n^{\prime }}\}\hfill \end{array}$$

In this way, one can recursively compute $S_n$ for all nodes except $\mathbf{0}$ of $Z_G$.

We would like to extract good ones from $S_{\mathbf{1}}$. In addition to $S_n$, we assign each node n another family $B_n\subseteq S_n$ such that no pair matching $T\in B_n$ will be expanded to a good one. We construct $B_n$ so that

$$\begin{array}{cc}\hfill B_n=\{T\left({\pi }_1\right)\in S_n& \mid \mathrm{there}\mathrm{are}\mathrm{distinct}\mathrm{valid}\mathrm{paths}{\pi }_1,{\pi }_2\mathrm{ending}\mathrm{in}n\mathrm{with}T\left({\pi }_1\right)=T\left({\pi }_2\right)\}\hfill \end{array}$$

(4)

$$\begin{array}{cc}\hfill \cup \{T\left(\pi \right)\in S_n& \mid \mathrm{there}\mathrm{is}\mathrm{a}\mathrm{valid}\mathrm{path}\pi \mathrm{ending}\mathrm{in}n\mathrm{with}\bigcup E\left(\pi \right)\cup V^{\ge e_{\left|\pi \right|+1}}\ne V\}\hfill \end{array}$$

(5)

This definition is explained as follows. For the first line Equation (4), suppose that there are distinct valid paths ${\pi }_1$ and ${\pi }_2$ ending in the same node $n=n\left({\pi }_1\right)=n\left({\pi }_2\right)$ such that $T\left({\pi }_1\right)=T\left({\pi }_2\right)$. Then, $E({\pi }_1·\rho )$ is a path matching if and only if so is $E({\pi }_2·\rho )$ for any $\rho$. Moreover, $E({\pi }_1·\rho )$ consists of $u_i$-$v_i$ paths for $i=1,\cdots ,k$ for some k if and only if so does $E({\pi }_2·\rho )$. That is, the instance $(G,\{\{u_i,v_i\}\mid i=1,\cdots ,k\})$ has two distinct solutions $E({\pi }_1·\rho )$ and $E({\pi }_2·\rho )$. The second part Equation (5) of the definition of $B_n$ is easier. If $E\left(\pi \right)\cup V^{\ge e_{\left|\pi \right|+1}}\ne V$, then there is a vertex $v\notin V\setminus V^{\ge e_{i+1}}$ which has degree 0 in $E\left(\pi \right)$ and thus in $E(\pi ·\rho )$ for any $\rho$. If $E(\pi ·\rho )$ is a path matching consisting of $u_i$-$v_i$ paths for $i=1,\cdots ,k$ for some k, the instance $(G,\{\{u_i,v_i\}\mid i=1,\cdots ,k\})$ has a solution that does not cover all the vertices.

We can compute the family $B_n$ of a node n from the pair matching families assigned to its parents according to the definition of $B_n$:

$$\begin{array}{cc}\hfill B_n=& \bigcup \{S_{n_1,b_1}\cap S_{n_2,b_2}\mid n_j\mathrm{is}\mathrm{a}{b}_j\text{-}\mathrm{parent}\mathrm{of}n\mathrm{for}j=1,2\mathrm{and}{n}_1\ne n_2\}\hfill \end{array}$$

(6)

$$\begin{array}{cc}\hfill & \cup \bigcup \{S_{n^{\prime },0}\mid n^{\prime }\mathrm{is}\mathrm{a}0\text{-}\mathrm{parent}\mathrm{of}n\mathrm{such}\mathrm{that}{\mathrm{mate}}_{n^{\prime }}\left(u\right)=u\mathrm{for}\mathrm{some}u\in e_i\setminus V^{\ge e_{i+1}}\}\hfill \end{array}$$

(7)

$$\begin{array}{cc}\hfill & \cup \bigcup \{B_{n^{\prime },b}\mid n^{\prime }\mathrm{is}\mathrm{a}b\text{-}\mathrm{parent}\mathrm{of}n\},\hfill \end{array}$$

(8)

where $B_{n,b}=\{T\cup \mathrm{Fix}({\mathrm{mate}}_n,i,b)\mid T\in B_n\}$ for $b\in \{0,1\}$. The lines Equations (6) and (7) come from Equations (4) and (5), respectively. Suppose that $T\left(\pi \right)\in B_{n\left(\pi \right)}$. Then regardless of whether it is due to Equation (4) or Equation (5), we have $T(\pi ·\rho )\in B_{n(\pi ·\rho )}$ for any $\rho$ as long as $\pi ·\rho$ is valid. Those pair matchings are captured by Equation (8).

6. Slitherlink Solver

The goal of this section is to give a Slitherlink solver, which constructs a ZDD that represents all the solutions for a given instance $(G,h)$ of Slitherlink. Recall that a solution is a simple cycle that satisfies a property represented by the hint assignment $h:2^E\rightharpoonup \mathbb{N}$. As a preparation, we present an algorithm that constructs a ZDD representing all the simple cycles on a given graph G. Actually this algorithm is an answer to Exercise 226 of [13].

Based on the fact that any proper subgraph of a cycle is actually a path matching, it is easy to modify Algorithm 1 so that simple cycles shall be enumerated. We allow vertices to have degree 1 temporarily during the construction, but when we have determined which of the edges incident to a vertex v shall be used, the degree of v must be 0 or 2. In addition, we allow to add an edge $e=\{u,v\}$ to a path matching $E\left(\pi \right)$ if $E\left(\pi \right)$ consists solely of a single u-v path: it completes a cycle.

Both conditions are judged by observing the mate functions. We say that a mate function m and an edge $e_i$ form a cycle if for any v in the domain of m,

$$m\left(v\right)=\left\{\begin{array}{cc}u\hfill & \mathrm{if}{e}_i=\{u,v\}\hfill \\ v\mathrm{or}0\hfill & \mathrm{if}v\notin e_i\hfill \end{array}\right.$$

If ${\mathrm{mate}}_n$ and $e_i$ form a cycle for $n\in N_i$, the 1-child of n should be $\mathbf{1}$.

We say that $(m,i)$ has a fixed end if

$$m\left(v\right)\notin \{0,v\}\mathrm{for}\mathrm{some}v\in e_i\setminus V^{\ge e_{i+1}}$$

For a valid path $\pi$ in $Z_G$, if $({\mathrm{mate}}_{n\left(\pi \right)},|\pi \left|\right)$ has a fixed end, $E\left(\pi \right)\cup E^{\prime }$ has a vertex of degree 1 for any $E^{\prime }\subseteq E^{\ge e_{i+1}}$. We say that mdeclines$e_i$ if either m rejects $e_i$ or $(\mathrm{MU}(m,e_i),i)$ has a fixed end. If ${\mathrm{mate}}_n$ declines $e_i$ for $n\in N_i$, the 1-child of n should be $\mathbf{0}$.

In addition, since the empty edge set is not a cycle, the corresponding path in our ZDD should end in $\mathbf{0}$.

Algorithm 4 constructs a ZDD for representing all the simple cycles on a graph G. We prove the correctness of Algorithm 4 in Appendix D.

Algorithm 4: Enumeration of simple cycles

     We are now ready to give our Slitherlink solver, shown as Algorithm 5, based on Algorithm 4.

Algorithm 5: Slitherlink solver

Let $(G,h)$ be a Slitherlink instance. To ensure that the computed cycle is compatible with the hint assignment h, we assign another function ${\mathrm{count}}_n:\mathrm{dom}\left(h\right)\to \mathbb{N}$ to each node n in addition to ${\mathrm{mate}}_n$. The function counts the number of picked edges in D in the domain of h. That is, for a valid path $\pi$, we shall have ${\mathrm{count}}_{n\left(\pi \right)}\left(D\right)=|E\left(\pi \right)\cap D|$ for each $D\in \mathrm{dom}\left(h\right)$. Especially ${\mathrm{count}}_{n_{\mathrm{root}}}\left(D\right)=0$ for each $D\in \mathrm{dom}\left(h\right)$. Updating the counter is very easy. For a mapping $c:\mathrm{dom}\left(h\right)\to \mathbb{N}$ and an edge $e\in E$, we define $\mathrm{CU}(c,e):\mathrm{dom}\left(h\right)\to \mathbb{N}$ (it stands for “counter update”) by

$$\mathrm{CU}(c,e)\left(D\right)=\left\{\begin{array}{cc}c\left(D\right)\hfill & \mathrm{if}e\notin D\hfill \\ c\left(D\right)+1\hfill & \mathrm{if}e\in D\hfill \end{array}\right.$$

for every $D\in \mathrm{dom}\left(h\right)$.

For $\pi$ of length i, when it is clear that there is no $P^{\prime }\subseteq E^{\ge e_{i+1}}$ such that $E\left(\pi \right)\cup P^{\prime }$ is compatible with h, the path $\pi$ should end in $\mathbf{0}$. We say that $(c,i)$ is incompatible with h if there is $D\in \mathrm{dom}\left(h\right)$ such that either

• $c\left(D\right)>h\left(D\right)$ or
• $c\left(D\right)+|D\cap E^{\ge e_{i+1}}|<h\left(D\right)$.

We say that cmatches h if $c\left(D\right)=h\left(D\right)$ for all $D\in \mathrm{dom}\left(h\right)$.

The function $\mathrm{GN}$ is modified so that it handles a counter function in addition to a mate function. It takes an edge index $i\in \{1,\cdots ,|E\left|\right\}$, a mate function m and a counter function c. $\mathrm{GN}(i,m,c)$ returns a node labeled $e_i$ and assigned m and c. If such a node has already been created in $N_i$, that node is returned. Otherwise, we create one in $N_i$ and return it. Note that this procedure may update $N_i$.

We give a formal proof for the correctness of Algorithm 5 in Appendix E.

7. Slitherlink Instance Enumeration

In this section, we discuss instance enumeration for the Slitherlink problem, assuming that a graph $G=(V,E)$, a solution cycle C over G, and the maximum domain $\mathcal{E}\subseteq 2^E$ of hint assignments are given. Let $h:\mathcal{E}\to \mathbb{N}$ be a hint assignment such that $h\left(E^{\prime }\right)=|C\cap E^{\prime }|$ for all $E^{\prime }\in \mathcal{E}$. The objective is to enumerate every ${\mathcal{E}}^{\prime }\subseteq \mathcal{E}$ that leads to a good instance $(G,h^{\prime })$ of the Slitherlink problem such that $\mathrm{dom}\left(h^{\prime }\right)={\mathcal{E}}^{\prime }$ and $h^{\prime }\left(E^{\prime }\right)=h\left(E^{\prime }\right)$ for all $E^{\prime }\in {\mathcal{E}}^{\prime }$. A good instance $(G,h^{\prime })$ must not have any compatible cycles other than C. Therefore, the instance enumeration problem is solved by computing

$$H=\left\{{\mathcal{E}}^{\prime }\subseteq \mathcal{E}\left|\underset{E^{\prime }\in \mathcal{E}}{\bigvee }\left(E^{\prime }\in {\mathcal{E}}^{\prime }\wedge h\left(E^{\prime }\right)\ne |C^{\prime }\cap E^{\prime }|\right)\mathrm{for}\mathrm{all}{C}^{\prime }\in \mathcal{C}\setminus \left\{C\right\}\right.\right\}$$

(9)

where $\mathcal{C}$ is the set of all cycles on G. We use Algorithm 4 to construct a ZDD for $\mathcal{C}$. For this sake, we invoke the dynamic virtue of ZDDs that allows us to perform mathematical set operations quite easily.

A ZDD for the family $\mathcal{C}$ can be regarded as a function $\mathcal{C}\left(x\right):{\{0,1\}}^{\left|E\right|}\to \{0,1\}$ such that

$$\mathcal{C}\left(x\right)=\left\{\begin{array}{cc}1\hfill & \mathrm{if}\{e\mid x_e=1\}\in \mathcal{C}\hfill \\ 0\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

where $x=(x_{e_1},\dots ,x_{e_{\left|E\right|}})$ is a vector of binary variables representing if each edge is taken. A ZDD for $\left\{C\right\}$ can also be regarded as a function $C\left(x\right):{\{0,1\}}^{\left|E\right|}\to \{0,1\}$ such that

$$C\left(x\right)=\left\{\begin{array}{cc}1\hfill & \mathrm{if}\{e\mid x_e=1\}=C\hfill \\ 0\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

Let $y=(y_{E_1^{\prime }},\dots ,y_{E_{\left|\mathcal{E}\right|}^{\prime }})$ be a vector of binary variables representing if the ith element $E_i^{\prime }$ of $\mathcal{E}$ is included in ${\mathcal{E}}^{\prime }$. Now we can rewrite Equation (9) in terms of x and y as follows, which can be computed by conventional operations on ZDDs:

$$H\left(y\right)=\forall x.\left(\neg \mathcal{C}\left(x\right)\vee C\left(x\right)\vee \underset{E^{\prime }\in \mathcal{E}}{\bigvee }\left(y_{E^{\prime }}\wedge h\left(E^{\prime }\right)\ne \sum _{e\in E^{\prime }}{x}_e\right)\right)$$

Once $H\left(y\right)$ is computed, ZDD operations enable us to restrict it easily to some interesting subset, such as instances with the minimum or minimal hints, and to output all instances explicitly.

8. Experiments

The following experiments for the Numberlink solvers, the Slitherlink solvers and the Slitherlink generators are performed on AMD Opteron Processor${}^{\mathrm{TM}}$ 8393, 3.09 GHz with 512 GB memory running SuSE 10, and those for the Numberlink generators are performed on AMD Opteron Processor${}^{\mathrm{TM}}$ 6136, 2.40 GHz with 256 GB memory running SuSE 10.

8.1. Solvers for Numberlink and Slitherlink

In this subsection, we discuss our experimental results on the comparison of our algorithm for solving Numberlink and Slitherlink with existing methods which are based on CPLEX 12.3 and Sugar. We implemented Algorithm 2 for Numberlink solver and Algorithm 5 for Slitherlink solver in C$++$ and compiled them by G$++$ 4.6 with -O3 optimization option. In our implementation, a variable order (an edge order) is lexicographical on sets of two vertices where vertices are labeled such as  Figure 6.

Figure 6. Grid graph $G_{b,a}$ and its vertex labels.

We prepared the benchmark programs. We formulated solving Numberlink [15] and Slitherlink [16] as integer programs and solve them by CPLEX, which is an integer programming solver. Sugar is a SAT based constraint solver [8]. Sugar provides the formulation of Numberlink [17] and Slitherlink [18]. We also compared them with a heuristic solver slink [9] specialized for Slitherlink, which is published as a C source code.

Table 1 shows the running times of these methods for solving Numberlink. In the table, BNx denotes the xth instance in [19]. C88 is the Vol. 88 instance in Puzzle Championships 2010 [20]. Let $G_{\alpha ,\beta }$ denote the $\alpha \times \beta$ grid graph. In Table 2, we show the running times of these methods with the restriction that requires solutions to cover all vertices (see Remark 7).

Table 1. Running time in seconds for solving Numberlink. Our algorithm could not solve C88 due to insufficient memory.

Instance	Graph	Time CPLEX	Time Sugar	Time Algorithm 2	Memory Algorithm 2 (MB)
BN1	$G_{8,8}$	0.02	1.179	0.008	2
BN15	$G_{8,8}$	13.95	1.336	0.004	2
BN30	$G_{10,10}$	88.32	1.896	0.016	5
BN43	$G_{10,10}$	6,410.67	1.924	0.072	18
BN52	$G_{10,10}$	0.45	1.520	0.012	3
BN64	$G_{10,10}$	108.07	1.704	0.136	11
BN72	$G_{10,10}$	276.07	1.388	0.012	4
BN79	$G_{10,10}$	15,117.47	1.496	0.220	37
BN85	$G_{20,15}$	>100,000	7,213.079	862.518	43,846
BN99	$G_{20,15}$	>100,000	14.097	1,658.772	67,094
C88	$G_{20,36}$	>100,000	>100,000	$-$	$-$

Table 2. Running time in seconds for solving Numberlink with restriction that requires solutions to cover all vertices.

Instance	Graph	Time CPLEX	Time Sugar	Time Algorithm 2	Memory Algorithm 2 (MB)
BN1	$G_{8,8}$	0.01	1.148	0.004	2
BN15	$G_{8,8}$	0.40	0.964	0.000	2
BN30	$G_{10,10}$	0.82	1.576	0.024	3
BN43	$G_{10,10}$	21.97	1.552	0.012	5
BN52	$G_{10,10}$	0.10	1.296	0.004	2
BN64	$G_{10,10}$	18.40	1.368	0.012	5
BN72	$G_{10,10}$	1.50	1.648	0.012	2
BN79	$G_{10,10}$	26.74	1.452	0.048	10
BN85	$G_{20,15}$	>100,000	5,431.991	185.264	8,761
BN99	$G_{20,15}$	>100,000	12.585	175.147	9,727

Table 3 describes the running time of these methods as Slitherlink solvers. BSx denotes the xth instance in [21]. S10 is a large sample problem on [22]. C95 is the Vol. 95 instance in Puzzle Championships 2010 [20].

Table 3. Running time in seconds for solving Slitherlink. Our algorithm could not solve C95 due to insufficient memory.

Instance	Graph	Time CPLEX	Time Sugar	Time slink	Time Algorithm 5	Memory Algorithm 5 (MB)
BS1	$G_{11,11}$	0.07	5.460	0.001	0.116	34
BS12	$G_{11,11}$	0.28	4.696	0.004	0.384	41
BS25	$G_{11,11}$	0.12	6.496	0.001	0.060	34
BS37	$G_{11,11}$	0.14	8.773	0.004	0.044	34
BS43	$G_{19,11}$	0.17	8.349	0.001	0.060	36
BS54	$G_{19,11}$	0.40	7.380	0.008	0.304	37
BS68	$G_{25,15}$	0.39	12.433	0.004	0.384	39
BS77	$G_{25,15}$	0.90	13.281	0.004	0.376	42
BS89	$G_{37,21}$	1.56	48.035	0.016	9.329	407
BS96	$G_{37,21}$	3.07	186.612	0.104	26.286	904
S10	$G_{21,37}$	41.43	1,411.944	0.036	4,569.330	138,053
C95	$G_{32,46}$	95.93	1,076.839	0.088	$-$	$-$

This table shows that slink is by far the fastest. A reason is that slink is a heuristic solver for Slitherlink which uses information specialized for Slitherlink. For example, when two adjacent cells are assigned “0” and “3” respectively, 12 of the surrounding edges are immediately determined to be or not to be in any solution (see Figure 7).

Figure 7. An example of information used by a heuristic Slitherlink solver.

8.2. Numberlink Generator

In this subsection, we show experimental results for enumerating all Numberlink instances for grid graphs by a variant of Algorithm 3. Our actual implementation is purely top-down, which is different from Algorithm 3. By interweaving the idea of Algorithm 3 into Algorithm 1, we construct $Z_G$ assigning nodes mate functions as well as pair matching families representing the ends of fixed paths simultaneously. In our algorithm, $S_n$ and $B_n$ are calculated by set operations such as union and intersection. We implemented these sets by ZDDs whose variables are unordered pairs $\{v,v^{\prime }\}$ of vertices $v,v^{\prime }\in V$. For efficiency, our implementation maintains $⟨W_n,B_n⟩$ instead of $⟨S_n,B_n⟩$ for each node n in $Z_G$, where $W_n=S_n\setminus B_n$.

Table 4, Table 5 and Table 6 show the running time of our algorithm, the number of good instances and that of nodes of $S_{\mathbf{1}}\setminus B_{\mathbf{1}}$ for $G_{\alpha ,\beta }$.

Table 4. Running time of Numberlink generator for $G_{\alpha ,\beta }$.

$\mathit{\alpha }\setminus \mathit{\beta }$	2	3	4	5	6	7
2	<0.01	<0.01	<0.01	<0.01	0.01	0.02
3	$-$	<0.01	0.01	0.08	0.48	2.67
4	$-$	$-$	0.21	3.56	44.13	488.12
5	$-$	$-$	$-$	107.99	3,553.29	>100,000
6	$-$	$-$	$-$	$-$	>100,000	>100,000
7	$-$	$-$	$-$	$-$	$-$	>100,000

Table 5. The number of good instances of Numberlink for $G_{\alpha ,\beta }$.

$\mathit{\alpha }\setminus \mathit{\beta }$	2	3	4	5	6	7
2	2	10	36	126	454	1,632
3	–	86	807	6,690	58,422	499,733
4	–	–	16,410	338,460	6,901,105	141,123,690
5	–	–	–	16,027,290	784,030,205	Time Out
6	–	–	–	–	Time Out	Time Out
7	–	–	–	–	–	Time Out

Table 6. The number of ZDD nodes of $W_{\mathbf{1}}$ in Numberlink generator for $G_{\alpha ,\beta }$.

$\mathit{\alpha }\setminus \mathit{\beta }$	2	3	4	5	6	7
2	4	18	50	117	235	419
3	–	99	491	1,686	4,918	12,255
4	–	–	3,499	22,599	108,954	439,506
5	–	–	–	226,800	1,977,335	Time Out
6	–	–	–	–	Time Out	Time Out
7	–	–	–	–	–	Time Out

For $G_{6,6}$, the computation did not finish within one week. We tried to compute the number of instances with restricting the number of pairs to at most ℓ. Table 7 shows the result of this computation for $G_{6,6}$ and $G_{7,7}$. Let $W_{n,i}=\{T\in W_n\mid \left|T\right|=i\}$ and $B_{n,i}=\{T\in B_n\mid \left|T\right|=i\}$. We maintain $⟨W_{n,0},\dots ,W_{n,\ell },B_{n,0},\dots ,B_{n,\ell }⟩$ instead of $⟨W_n,B_n⟩$ in each node n. We omit the method of computing $W_{n,i}$ and $B_{n,i}$. Then, we obtain that the number of minimum pairs with which $G_{6,6}$ gives a good instance is 3 from this result. We give the complete list of those instances on the graph $G_{6,6}$ with 3 pairs of vertices in Appendix G.

Table 7. Running time, the number of good instances with at most ℓ pairs of numbers, and that of ZDD nodes of $W_{\mathbf{1}}=S_{\mathbf{1}}\setminus B_{\mathbf{1}}$.

Graph	ℓ	Time	Good instances	$|{\mathit{W}}_{\mathit{n},\mathit{\ell }}|$
$G_{6,6}$	0	39.63	0	1
$G_{6,6}$	1	141.13	0	1
$G_{6,6}$	2	1,329.35	0	1
$G_{6,6}$	3	12,161.5	304	472
$G_{6,6}$	4	>1,000,000	$-$	$-$
$G_{7,7}$	0	2,732.86	0	1
$G_{7,7}$	1	14,226	0	1
$G_{7,7}$	2	>1,000,000	$-$	$-$

8.3. Slitherlink Generator

For the Slitherlink generator, we tried to generate some interesting examples of Slitherlink instances in order to confirm the usefulness of our tool. Our tool generates Slitherlink instances based on three kinds of input: a graph, a solution cycle, and the maximum domain of hint assignments. In usual cases where instances are made with grid graphs, a domain of hint assignments is represented by a set of rectangular cells.

Figure 8 shows an example of Slitherlink generation. We drew a solution cycle on a $5\times 7$ grid of cells and marked all 35 cells as the maximum set of hint cells. When they were given as the input, our tool successfully constructed a ZDD for a family of sets of hint cells in 8 s, from which we can obtain all the 2,912,556,380 good Slitherlink instances that have the given solution cycle. The tool can optionally restrict generated instances to minimal ones (instances such that any hint cannot be removed without making the solution not unique). It took 0.1 s for this example and the number of instances was reduced to 32,639. The output example shown in Figure 8 is the one selected automatically by our tool as the most difficult instance among them in our criteria, in which the difficulty is evaluated by smallness of the number of cells with hint values “4”, “0”, “3”, “1”, and “2” in this order of precedence. Another output example was shown already in Figure 2, which is one of the 81 good instances that consist of minimum hints.

Figure 8. Input and output of Slitherlink generation; example #1.

Figure 9 shows another input example, in which the solution cycle is drawn on a 8 × 8 grid of cells. Unfortunately, the computation could not be finished even in a day when all 64 cells are marked as candidates of hint locations. Our tool, however, was still able to assist making instances of the Slitherlink problem according to the designer’s intent. We reduced the candidate locations to 36 cells (the right picture of Figure 9) and got 1,669,424 instances, 1,850 minimal instances, and 4 minimum instances (Figure 10) in 2 s. It is also interesting that the same mechanism can be used to modify existing instances. We found that hand-made instances often include many redundant hints (e.g., 12 out of 40) and our tool can be used to make them more difficult to solve.

Figure 9. Input of Slitherlink generation; example #2.

Figure 10. Output of Slitherlink generation; example #2.

Finally, we introduce an enjoyable application of our tool, which can make a puzzle containing a secret message. Unlike the original Slitherlink, we allow multiple cycles as its solution in order to embed multiple letters into the puzzle. The algorithm of Slitherlink instance generation is modified by replacing computation of “all cycles on G” with “all combinations of disjoint cycles on G”, which is actually not difficult to be computed by using conditions on degree of the graph vertices. Figure 11 is our message to readers.

Figure 11. An example of message puzzle instance.

9. Conclusions

This paper has proposed algorithms that enumerate solutions and instances for two link puzzles, Numberlink and Slitherlink, based on Knuth’s path enumeration algorithm Simpath.

Our Numberlink solver (Algorithm 2) is faster than Sugar and CPLEX. In Slitherlink, our solution enumeration algorithm (Algorithm 5) shows better performance than Sugar. CPLEX is sometimes faster than our algorithm. Slink runs much faster than our algorithm and CPLEX to find a solution for Slitherlink instances. The result looks rather reasonable, since Sugar and CPLEX are designed for quite general purposes and find only one solution, while Slink is specially designed to solve Slitherlink problems. Our algorithms are located in between. The core of our algorithms is specialized to enumerate path matchings on a general graph, to which we have plugged mechanisms that decide whether the currently obtained path matchings can be expanded to a solution. It is not difficult to accelerate our algorithms by employing known local solution methods for the link puzzles on grid graphs. Yet we have largely ignored such detailed improvements. Rather we emphasize the generality of our approach that should be valid to design solution enumeration algorithms for various link puzzles including Masyu, Yajirin and others. To build a ZDD representing solutions, what we need to do is to assign each node an appropriate configuration like $\mathrm{mate}$ and $\mathrm{count}$ which can be locally updated and which tells whether the currently obtained path matchings may be grown up to solutions.

Another point we would like to emphasize is that our algorithms give all the solutions at once as a ZDD unlike existing solvers. Our instance enumeration algorithms rely much on this feature of our approach. We benefit from the virtue of ZDDs as a set manipulation system. As we have demonstrated in Section 8.3, we have flexible means on ZDDs to extract instances with several properties from the whole set of good instances, like non-redundant ones, the hardest ones, ones that use specific cells, and so on. The authors believe manipulating puzzle instances on a ZDD is quite beneficial to puzzle designers. It is future work to develop an assistant tool for puzzle designers that equips several convenient functions with a friendly interface.