敷き詰めパズルの解をアルゴリズム「DLX」で探索

以前にアルゴリズム問題として敷き詰めパズルを[社内のSlackで出題した](a806377b3093e8944dc0#敷き詰めパズル)のですが、軽く解説できるものではなかったので、記事に纏めることにしました。

> 地図の空き領域に、その下に列挙したピースを全て収めてください。ピースは回転させてもいいですが、裏返してはいけません。
>
> <details><summary>snippet: puzzle#42</summary><div>

```text:puzzle#42
###########
###.....###
##.###...##
#..#......#
#.........#
##.......##
###.....###
####...####
#####.#####
###########

.......
.#####.
.......
.#.....
.####..
.......
.##....
..###..
.......
.###...
..##...
.......
.#.....
.##....
..##...
.......
.#.....
.###...
..#....
.......
.##....
.##....
.......
.###...
..#....
.......
.##....
..##...
.......
```

</div></details></blockquote>

※問題の出典：ニンテンドー3DS内蔵ソフト『すれちがいMii広場』 > 追加コンテンツ『[すれちがい迷宮](https://www.nintendo.co.jp/hardware/3dsseries/miiplaza/meikyu/)』 > ミニゲーム「パズルボックス」 > No.42

---

この手の問題を解くのに有用なアルゴリズム「DLX」について、日本語でのわかりやすい解説は既にいくつかあります（→[参考リスト](#参考)）。本記事の特徴は以下くらいですが、理解の足しになれば幸いです。

* 「1次元の問題」で解法を手を動かして確認します
	* 単純な深さ優先探索
	* Algorithm X
* DLXの実装をミスしにくいように工夫します
* 最後に、冒頭の形式の問題を解くコードを添付します

## 1次元の場合で勉強
いきなり冒頭の問題を解くのはきついので、まずは簡略化した1次元の問題で解法を確認します（ピースの回転も不要とします）。

```text:puzzle-1D
#.#.........#..#

#..#.##
#.#..##
##...##
```

この解のひとつは以下の通りです。**どの列にも `#` がひとつだけある**（重複も抜け落ちも無い）ことが確認できます。最下行は各ピースを異なる英文字で表したもので、コンパクトなため以降ではこの表記にします。

<details><summary>puzzle-1D-solution</summary><div>

```text:puzzle-1D-solution
#.#.........#..# // 設問
: :         :  :
: :     #..#.##: // ピースaを置く位置
:#.#..##    :  : // ピースbを置く位置
: : ##...## :  : // ピースcを置く位置
: :         :  :
#b#bccbbacca#aa# // 各ピースを英文字で表した場合
```

</div></details>

## 単純な深さ優先探索
愚直に探索するならピースを片っ端から入れてみる方法があります。ピースがひとつ収まれば、空き領域と残りのピースが少なくなるため、**より小さな敷き詰めパズル**として捉えられます。これを**再帰的**に繰り返して全ピースが埋まれば解が得られます。

探索の様子を以下に示します。ピースを収められなくなったら前のピースをずらしてまた試す、という繰り返しです。

```text:search&#x20;tree
#.#.........#..#
├── #a#.a.aa....#..#
│   ├── #a#babaabb..#..#
│   └── #a#.a.aab.b.#bb#
├── #.#a..a.aa..#..#
│   └── #.#a.babaabb#..#
├── #.#.a..a.aa.#..#
├── #.#..a..a.aa#..#
│   └── #b#b.abba.aa#..#
└── #.#.....a..a#aa#
    ├── #b#b..bba..a#aa#
    │   └── #b#bccbbacca#aa#
    │       └── // solution
    └── #.#.b.b.abba#aa#
```

ピースが収まる位置を見つけると言うと難しく感じるかもしれませんが、実際は「左端から全て試す」だけで十分でしょう。それも含めた図を以下に示します。 `*` で表したところはピースが重なっているため解にならず、次のピースを試すのをスキップすることになります。

<details><summary>深さ優先探索の全容（122行）</summary><div>

```text:search&#x20;tree&#x20;(all)
#.#.........#..#
├── *.#a.aa.....#..#
├── #a#.a.aa....#..#
│   ├── *a*.ab*a....#..#
│   ├── #*#ba.**....#..#
│   ├── #a*.*.a*b...#..#
│   ├── #a#babaabb..#..#
│   │   ├── **#ba**abb..#..#
│   │   ├── #**bab**bb..#..#
│   │   ├── #a**aba**b..#..#
│   │   ├── #a#**baa**..#..#
│   │   ├── #a#b**aab*c.#..#
│   │   ├── #a#ba**abbcc#..#
│   │   ├── #a#bab**bb.c*..#
│   │   ├── #a#baba**b..*c.#
│   │   ├── #a#babaa**..#cc#
│   │   └── #a#babaab*c.#.c*
│   ├── #a#.*.*a.bb.#..#
│   ├── #a#.aba*..bb#..#
│   ├── #a#.a.*ab..b*..#
│   ├── #a#.a.a*.b..*b.#
│   ├── #a#.a.aab.b.#bb#
│   │   ├── **#.ac*ab.b.#bb#
│   │   ├── #**.a.**b.b.#bb#
│   │   ├── #a*ca.a**.b.#bb#
│   │   ├── #a#c*.aa*cb.#bb#
│   │   ├── #a#.*caabc*.#bb#
│   │   ├── #a#.ac*ab.*c#bb#
│   │   ├── #a#.a.**b.bc*bb#
│   │   ├── #a#.a.a**.b.**b#
│   │   ├── #a#.a.aa*cb.#**#
│   │   └── #a#.a.aabc*.#b**
│   └── #a#.a.aa.b.b#.b*
├── #.*..a.aa...#..#
├── #.#a..a.aa..#..#
│   ├── *.*a.b*.aa..#..#
│   ├── #b#*..*baa..#..#
│   ├── #.*ab.ab*a..#..#
│   ├── #.#*.ba.**..#..#
│   ├── #.#ab.*.a*b.#..#
│   ├── #.#a.babaabb#..#
│   │   ├── *c#a.**baabb#..#
│   │   ├── #c*a.b**aabb#..#
│   │   ├── #.**.ba**abb#..#
│   │   ├── #.#*cbab**bb#..#
│   │   ├── #.#ac*aba**b#..#
│   │   ├── #.#a.**baa**#..#
│   │   ├── #.#a.b**aab**..#
│   │   ├── #.#a.ba**abb*c.#
│   │   ├── #.#a.bab**bb#cc#
│   │   └── #.#a.baba**b#.c*
│   ├── #.#a..*.*a.b*..#
│   ├── #.#a..aba*..*b.#
│   ├── #.#a..a.*ab.#bb#
│   └── #.#a..a.a*.b#.b*
├── #.#.a..a.aa.#..#
│   ├── *.*.abba.aa.#..#
│   ├── #b#ba.b*.aa.#..#
│   ├── #.*.*..*baa.#..#
│   ├── #.#bab.ab*a.#..#
│   ├── #.#.*.ba.**.#..#
│   ├── #.#.ab.*.a*b#..#
│   ├── #.#.a.babaab*..#
│   ├── #.#.a..*.*a.*b.#
│   ├── #.#.a..aba*.#bb#
│   └── #.#.a..a.*ab#.b*
├── #.#..a..a.aa#..#
│   ├── *.*..*b.a.aa#..#
│   ├── #b#b.abba.aa#..#
│   │   ├── **#b.**ba.aa#..#
│   │   ├── #**b.a**a.aa#..#
│   │   ├── #b**.ab**.aa#..#
│   │   ├── #b#*cabb*caa#..#
│   │   ├── #b#bc*bbac*a#..#
│   │   ├── #b#b.**ba.**#..#
│   │   ├── #b#b.a**a.a**..#
│   │   ├── #b#b.ab**.aa*c.#
│   │   ├── #b#b.abb*caa#cc#
│   │   └── #b#b.abbac*a#.c*
│   ├── #.*.ba.b*.aa#..#
│   ├── #.#b.*..*baa#..#
│   ├── #.#.bab.ab*a#..#
│   ├── #.#..*.ba.**#..#
│   ├── #.#..ab.*.a**..#
│   ├── #.#..a.babaa*b.#
│   ├── #.#..a..*.*a#bb#
│   └── #.#..a..aba*#.b*
├── #.#...a..a.a*..#
├── #.#....a..a.*a.#
├── #.#.....a..a#aa#
│   ├── *.*..bb.a..a#aa#
│   ├── #b#b..bba..a#aa#
│   │   ├── **#b.c*ba..a#aa#
│   │   ├── #**b..**a..a#aa#
│   │   ├── #b**..b**..a#aa#
│   │   ├── #b#*c.bb*c.a#aa#
│   │   ├── #b#bccbbacca#aa#
│   │   │   └── // solution
│   │   ├── #b#b.c*ba.c*#aa#
│   │   ├── #b#b..**a..**aa#
│   │   ├── #b#b..b**..a**a#
│   │   ├── #b#b..bb*c.a#**#
│   │   └── #b#b..bbacca#a**
│   ├── #.*.b..b*..a#aa#
│   ├── #.#b.b..*b.a#aa#
│   ├── #.#.b.b.abba#aa#
│   │   ├── *c#.bc*.abba#aa#
│   │   ├── #c*.b.*cabba#aa#
│   │   ├── #.*cb.bc*bba#aa#
│   │   ├── #.#c*.b.**ba#aa#
│   │   ├── #.#.*cb.a**a#aa#
│   │   ├── #.#.bc*.ab**#aa#
│   │   ├── #.#.b.*cabb**aa#
│   │   ├── #.#.b.bc*bba**a#
│   │   ├── #.#.b.b.**ba#**#
│   │   └── #.#.b.b.a**a#a**
│   ├── #.#..b.ba.b*#aa#
│   ├── #.#...b.*..**aa#
│   ├── #.#....bab.a**a#
│   ├── #.#.....*.ba#**#
│   └── #.#.....ab.*#a**
└── #.#......a..*.a*
```

</div></details>

### コード
この探索をRubyで実装してみます。新しいピースが収まるか判定するためには、既に埋まっている位置を記録するデータ構造が必要です。位置と添字を対応させたboolean配列や整数（＝ビット配列）という手もありますが、今回は埋まっている位置の番号を要素とする[集合クラス](https://docs.ruby-lang.org/ja/latest/class/Set.html)[^set-class]で行きます。 `Solver#each_solution` が再帰の部分で、再帰呼び出し前は問題を小さくするよう操作し、呼び出し後は復元操作をしています。

```ruby
require "set"

class Solver
	def initialize(field)
		@field = field
		@filled_set = @field.set
		@pieces = []
		@selected_list = []
	end

	def add_piece(piece)
		@pieces << piece
		self
	end

	def each_solution(&block)
		return to_enum(__method__) unless block

		if @pieces.empty?
			block.call(@selected_list)
			return self
		end

		piece = @pieces.shift
		(0..(@field.width - piece.width)).each do |offset|
			piece_set = piece.set.to_set { |x| x + offset }
			next unless (@filled_set & piece_set).empty?

			@selected_list.push([piece, offset])
			@filled_set += piece_set
			each_solution(&block)
			@filled_set -= piece_set
			@selected_list.pop
		end
		@pieces.unshift(piece)

		self
	end
end

class MapData
	attr_reader :set, :width

	def initialize(str, char = "#")
		@set = str.each_char.with_index.select { |c, i| c == "#" }.to_set { |c, i| i }
		@char = char
		@width = str.length
	end

	def write(base = nil, offset = 0)
		base ||= "." * @width
		@set.each { |i| base[i + offset] = @char }
		base
	end
end

field = MapData.new("#.#.........#..#")
Solver.new(field)
		.add_piece(MapData.new("#..#.##", "a"))
		.add_piece(MapData.new("#.#..##", "b"))
		.add_piece(MapData.new("##...##", "c"))
		.each_solution do |selected_list|
			str = field.write
			selected_list.each { |piece, offset| piece.write(str, offset) }
			puts str
		end
```

[^set-class]: 要素の重複が無いことを保証したリストです。とはいえ今回は普通の配列でも事足ります。

### 効率
1次元の問題だとあまり気になりませんが、いきなりピースを中央に置いてみるというのは人間なら絶対にしない方法です。「ピースを順番に試す」というのは初期の分岐が増えてしまい、結果として探索木も大きくなりがちです。

<!--
真逆の取り組み方としては、「マス目を左から順番に埋めてみる」という方法があります。こちらは割と早く探索完了します。ただし、ピースの種類が増えたり2次元になったりすると、やはり初期の分岐が増えてしまいます。

```text:search&#x20;tree
#_#.........#..#
├── #a#_a.aa....#..#
│   ├── #a#babaabb_.#..#
│   └── #a#c*.aacc..#..#
├── #b#b_.bb....#..#
│   ├── #b#ba.b*.aa.#..#
│   └── #b#bccbb_cc.#..#
│       └── #b#bccbbacca#aa#
│           └── // solution
└── #c*...cc....#..#
```
-->

もっと賢く、それでいてアルゴリズム（＝コンピューターに指示する手順）としても複雑ではない解法を次で見ていきます。

## Algorithm X
計算機科学の分野で有名な[クヌース先生](https://ja.wikipedia.org/wiki/ドナルド・クヌース)が論文の中で述べた、厳密被覆問題の全ての解を探索するアルゴリズムです。名前は「他にいいのが思いつかなかった」[^x]らしいです。

[^x]: "I will call algorithm X for lack of a better name"

### 厳密被覆問題への変換
[厳密被覆（exact cover）](https://en.wikipedia.org/wiki/exact_cover)は数学の集合（set）の用語です。専門用語だらけで翻訳に自信はありませんが、Wikipedia英語版には以下のように書いてあります。

> In mathematics, given a collection S of subsets of a set X, an exact cover is a subcollection S\* of S such that each element in X is contained in exactly one subset in S\*. One says that each element in X is covered by exactly one subset in S\*. An exact cover is a kind of cover.
> > 数学において、集合 X の部分集合の族 S が与えられるとき、厳密被覆とは次の性質を満たす S の部分集合族 S\* のことである： X の各要素は S\* の1つの部分集合にのみ含まれる。 X の各要素は S\* の厳密に1つの部分集合で被覆されると言う。厳密被覆は[被覆](https://ja.wikipedia.org/wiki/集合の被覆)の一種である。

わかりやすく配列で例を作れば、全体集合 `x = [1, 2, 3]` およびその部分集合のリスト `s = [[1, 2], [1, 3], [2], [2, 3]]` があるとき、リストから抽出した `s_star = [[1, 3], [2]]` は `x` の要素をちょうどひとつずつ含んでいるため `x` の厳密被覆です。（厳密被覆になる選び方は1通りとは限りません）

敷き詰めパズルを厳密被覆問題と捉えるには、**マス目の位置を要素とする集合**に対し、候補となる部分集合として**ピースの全配置**を用意します。ただし、ピースは1回のみ使うという制約があるため、**ピースの種類も集合の要素に追加**します。

百聞は一見に如かずということで、実際に例題を変換したものを以下に示します。 `|` で分けた左16列 `[A-P]` はマス目、中3列 `[a-c]` はピースの種類、右1列 `[z]` は設問であることを表します。（設問を「置き方が1通りのみのピース」と捉えることで、問題サイズが大きくなる代わりに変換を楽にしています）

```text:exact_cover_problem
ABCDEFGHIJKLMNOP|abc|z
______________________
#.#.........#..#|...|# 00 // selected
#..#.##.........|#..|. 10
.#..#.##........|#..|. 11
..#..#.##.......|#..|. 12
...#..#.##......|#..|. 13
....#..#.##.....|#..|. 14
.....#..#.##....|#..|. 15
......#..#.##...|#..|. 16
.......#..#.##..|#..|. 17
........#..#.##.|#..|. 18 // selected
.........#..#.##|#..|. 19
#.#..##.........|.#.|. 20
.#.#..##........|.#.|. 21 // selected
..#.#..##.......|.#.|. 22
...#.#..##......|.#.|. 23
....#.#..##.....|.#.|. 24
.....#.#..##....|.#.|. 25
......#.#..##...|.#.|. 26
.......#.#..##..|.#.|. 27
........#.#..##.|.#.|. 28
.........#.#..##|.#.|. 29
##...##.........|..#|. 30
.##...##........|..#|. 31
..##...##.......|..#|. 32
...##...##......|..#|. 33
....##...##.....|..#|. 34 // selected
.....##...##....|..#|. 35
......##...##...|..#|. 36
.......##...##..|..#|. 37
........##...##.|..#|. 38
.........##...##|..#|. 39
```

 `selected` と書かれた行のリスト `[00, 18, 21, 34]` は、全20列をぴったり埋めて互いに重ならないので厳密被覆であり、従って例題の解です。

### 解法
まずは適当に列を選び、 `#` を持つ行＝解の候補を抜き取ります。どの列を選んでも全ての解を見つけられますが、 `#` の個数が少ない列から考えると楽です。
列 `z` が `#` 1個なのでこの列にします。抜き出した行は以下の通りです。

```text:x-depth1-step1
ABCDEFGHIJKLMNOP|abc|z
______________________
#.#.........#..#|...|# 00
```

行は `00` 一択なので、これを解の候補に選びます。
候補を選んだら、 `#` が被っている他の行は解にならないので消します。すると以下のようになります。（選んだ列 `z` は行を抜き出した時点で役目が終わるので先に消しています。）

```text:x-depth1-step2.1
ABCDEFGHIJKLMNOP|abc
____________________
#.#.........#..#|... 00
____________________
.#..#.##........|#.. 11
...#..#.##......|#.. 13
....#..#.##.....|#.. 14
.....#..#.##....|#.. 15
........#..#.##.|#.. 18
.#.#..##........|.#. 21
...#.#..##......|.#. 23
....#.#..##.....|.#. 24
.....#.#..##....|.#. 25
........#.#..##.|.#. 28
...##...##......|..# 33
....##...##.....|..# 34
.....##...##....|..# 35
........##...##.|..# 38
```

そして候補に `#` がある列 `[ACMP]` 自体も消します。すると**より小さな問題の形になります**。

```text:x-depth1-step3.1
BDEFGHIJKLNO|abc
________________
#.#.##......|#.. 11
.#..#.##....|#.. 13
..#..#.##...|#.. 14
...#..#.##..|#.. 15
......#..###|#.. 18
##..##......|.#. 21
.#.#..##....|.#. 23
..#.#..##...|.#. 24
...#.#..##..|.#. 25
......#.#.##|.#. 28
.##...##....|..# 33
..##...##...|..# 34
...##...##..|..# 35
......##..##|..# 38
```

今度は列 `B` に注目すると解の候補が `11` と `21` の2つあるので、ひとつずつ試す必要があります。

```text:x-depth2-step1
BDEFGHIJKLNO|abc
________________
#.#.##......|#.. 11
##..##......|.#. 21
```

まずは `11` を候補に選んでみて、同様に `#` の被る行を消し、 `#` の列も消します。

```text:x-depth2-step2.1
DEFGHIJKLNO|abc
_______________
.#.##......|#.. 11
_______________
#.#..##....|.#. 23
.....#.#.##|.#. 28
.....##..##|..# 38
```

```text:x-depth2-step3.1
DFIJKLNO|bc
___________
####....|#. 23
..#.#.##|#. 28
..##..##|.# 38
```

すると **`#` の無い列が現れました**。これは**もうどの行を選んでも解にならない**ということで、探索失敗です。「その列に注目すると解の候補が0個見つかる」と考えてもいいです。

問題を遡り、今度は `21` を候補に選んでみます。

```text:x-depth2-step2.2
DEFGHIJKLNO|abc
_______________
#..##......|.#. 21
_______________
..#..#.##..|#.. 15
.....#..###|#.. 18
.##...##...|..# 34
.....##..##|..# 38
```

```text:x-depth2-step3.2
EFIJKLNO|ac
___________
.##.##..|#. 15
..#..###|#. 18
##.##...|.# 34
..##..##|.# 38
```

列 `E` が `#` 1個なので、これをもとに行 `34` を選びます。

```text:x-depth3-step1
EFIJKLNO|ac
___________
##.##...|.# 34
```

```text:x-depth3-step2.1
FIJKLNO|ac
__________
#.##...|.# 34
__________
.#..###|#. 18
```

```text:x-depth3-step3.1
ILNO|a
______
####|# 18
```

もう目視では答えが見えていますが、きちんと最後まで同じアルゴリズムを適用します。列 `I` をもとに行 `18` を選びます。

```text:x-depth4-step1
ILNO|a
______
####|# 18
```

```text:x-depth4-step2.1
LNO|a
_____
###|# 18
_____
```

```text:x-depth4-step3.1
```

**列が無くなった**ため集合をぴったり埋められたことになり、選択した行 `[00, 21, 34, 18]` は解です（順不同）。他にも解があるか探すなら、探索を遡って他の候補を選び直せばいいです。今回は候補を選び尽くしたので、解はこの1個のみとわかります。

### コード
実装は次節の「DLX」に回します。

### 効率
探索の順序を図にすると以下のようになります。候補の少ない列（ `_` で表現）から攻めることで非常に短く済んでいます。（「単純な深さ優先探索」のときは、列をピースの `a` → `b` → `c` と順序固定で選んでいたことになります）

```text:search&#x20;tree
................|...|_
└── #_#.........#..#|...|#
    ├── #a#.a.aa..._#..#|a..|#
    └── #b#b_.bb....#..#|.b.|#
        └── #b#bccbb_cc.#..#|.bc|#
            └── #b#bccbbacca#aa#|abc|#
                └── // solution
```

表や図ではマス目とピースを区切っていますが、**厳密被覆問題としては両者に区別はありません**。これによって、「このマス目を埋められるピースはこれらだけ」と「このピースを置ける場所はここらだけ」という2通りの絞り込み方が自然とアルゴリズムに入っています。

## DLX
見てきたAlgorithm Xは、表を作るのに `0/1` や `true/false` といった2値を記録できる2次元配列があれば済みます。ただ、深さ優先探索をする場合は**探索を遡る方法が必要**で、再帰呼び出しの度に現在の表を保存したり新しい表を作ったりすると、かなりメモリを消費してしまいます。

そこで別のデータ構造を使うことが多いです。要となるのは**dancing links**と呼ばれる手法で、組み合わせて**DLX**と呼ばれます。Excelやスプレッドシートにある、行や列の「非表示／再表示」機能を思い浮かべるといいですが、**表の一部を隠して小さくした後にまた元に戻すことができる**ため、新しい表を作る必要がありません。さらに表の2値のうち片方だけ記録すれば済み、今回のようにまばらな表なら効果的です。

### dancing links
dancing linksは[双方向連結リスト](https://ja.wikipedia.org/wiki/連結リスト)の少し変わった使い方です。双方向連結リストからあるノード（要素）を取り除くときは両隣の参照先を変えるわけですが、取り除いたノードは両隣の参照を持っているため**再び同じ位置に戻せます**。ふつうは取り除いたノードは破棄するはずで、安全のため参照をnullなどにすることもあり、dancing linksの使い方は単純ながら意外です。

DLXでは表を再現するように**縦横2次元の双方向連結リスト**になっていて、さらにリスト終端が無いほうが何かと便利なので循環リストにもなっています。連結リストは配列と異なり間をスキップしてもいいため、Algorithm Xで作った**表の `#` 部分だけをノード化して互いに接続する**ことで、メモリ効率も走査効率も良くなります。表のセル部だけだと扱いにくいので、列を管理するヘッダーノードとそれらを管理するマスターヘッダーノードもあります（行を管理するノードはありません）。図で見ると理解が速いので、[参考リスト](#参考)にある元論文か日本語での解説を参照してください。

ノードを取り除いた連結リストはもちろん正常ですので、何段階でもノードの削除・復元ができます。注意事項として、基本的にノードの復元は削除と**完全に逆順**に行わなければなりません。これを間違えると連結リストの整合性が崩れてしまいます。当たり前のことを言っているようですが、DLXでは「縦横2次元の連結リストで」「ループによる走査を頻繁に行う」ため、1ヶ所でも間違えると原因の特定に苦労します。

### コード
`DLX::Client` クラスから厳密被覆問題の表を操作することにします。単純な深さ優先探索のときの `Solver` クラスと似た構造です。

* 表の列は 0 〜 N-1 の番号で区別し、 `add_row` メソッドの引数に `#` のある列番号のリストを与えて行を追加することにします
* `each_solution` メソッドが**再帰**になっています
	* 基本ケースは表に列が無いときです
	* 選んだ列にある候補行毎に、その候補を抜いた小問題を作って解きます

処理速度よりも安全性・可読性を優先させるため、 `Node` クラスでは以下の工夫をしています。

* データの削除と復元が逆順になることを保証するために、それぞれを別のメソッドとして定義するのではなく、同じメソッドにフラグを与えます
* 併せて双方向連結リストのリンクも、各方向毎にメンバー変数を用意するのではなく配列に纏めることで、簡単に方向を切り替えられるようにします
	* わかりやすく横/縦と順/逆の2次元配列にします → `@links = [[right, left], [down, up]]`
* 各ノードは役割毎にクラスを分け、アルゴリズムの実装ミスに気付きやすくします

```ruby:dlx.rb
module DLX
	class Client
		def initialize(column_size)
			@root = RootNode.new
			@columns = Array.new(column_size) { ColumnNode.new(@root) }
			@selected_cells = []
		end

		def add_row(column_indices, data = nil)
			first_cell = nil
			column_indices.each do |i|
				cell = CellNode.new(first_cell, @columns[i], data)
				first_cell ||= cell
			end
			self
		end

		def each_solution(&block)
			return to_enum(__method__) unless block

			# find a column with the fewest cells
			column = @root.each_column.min_by do |column|
				column.size.nonzero? or break column
			end

			# no columns --> a solution is found
			unless column
				block.call(@selected_cells.map(&:data))
				return self
			end

			# depth-first search (recursive) when column.size > 0
			column.cover_rows(true)
			column.each_cell do |cell|
				@selected_cells.push(cell)
				cell.cover_other_columns_and_rows(true)
				each_solution(&block)
				cell.cover_other_columns_and_rows(false)
				@selected_cells.pop
			end
			column.cover_rows(false)

			self
		end
	end

	module Direction
		HORIZONTAL, VERTICAL = 0, 1
		FORWARD, BACKWARD = 0, 1

		def direction(forward)
			forward ? FORWARD : BACKWARD
		end
	end

	class Node
		include Direction

		attr_reader :links, :column  # links :: [[right, left], [down, up]]
		protected   :links, :column  # column != nil iff self is a cell node

		def initialize(row = nil, column = nil)
			@links = Array.new(2) { Array.new(2, self) }
			@column = column

			Array.new(2).tap do |headers|
				headers[HORIZONTAL] = row
				headers[VERTICAL] = column
			end.each_with_index do |header, dir_hv|
				next unless header
				@links[dir_hv][FORWARD] = header
				@links[dir_hv][BACKWARD] = header.links[dir_hv][BACKWARD]
				cover(false, dir_hv)
			end
		end

		def each(dir_hv, dir_fb, &block)
			return to_enum(__method__, dir_hv, dir_fb) unless block

			node = self
			block.call(node) until (node = node.links[dir_hv][dir_fb]).equal?(self)
			self
		end

		def cover(bool, dir_hv)
			column.update_size(bool) if dir_hv == VERTICAL

			node0, node1 = @links[dir_hv]
			node0.links[dir_hv][1] = bool ? node1 : self
			node1.links[dir_hv][0] = bool ? node0 : self
			self
		end
	end

	class CellNode < Node
		attr_reader :data

		def initialize(row, column, data = nil)
			super(row, column)
			@data = data
		end

		def cover_this_row(bool)
			each(HORIZONTAL, direction(bool)) { |cell| cell.cover(bool, VERTICAL) }
		end

		def cover_other_columns_and_rows(bool)
			each(HORIZONTAL, direction(bool)) { |cell| cell.column.cover_rows(bool) }
		end
	end

	class ColumnNode < Node
		attr_reader :size

		def initialize(root)
			super(root)
			@size = 0
		end

		def each_cell(&block)
			each(VERTICAL, FORWARD, &block)
		end

		def cover_rows(bool)
			cover(bool, HORIZONTAL)
			each(VERTICAL, direction(bool)) { |cell| cell.cover_this_row(bool) }
		end

		def update_size(bool)
			bool ? @size -= 1 : @size += 1
		end
	end

	class RootNode < Node
		def each_column(&block)
			each(HORIZONTAL, FORWARD, &block)
		end
	end

	private_constant :Direction, :Node, :CellNode, :ColumnNode, :RootNode
end
```

## 2次元の敷き詰めパズルに適用
2次元でも解き方は同じです。全てのマス目とピース種別（＋設問）を要素とする集合を表の列として用意し、各ピースが可能な配置を表の行としてひたすら列挙します。配置はフィールドの左上から右下まで、加えて回転した場合も必要です。

冒頭の形式の入力をパースして解を列挙するプログラムを示します。（1次元にも回転ありで対応しています）

```ruby:puzzle_box.rb
require './dlx.rb'

class MapData
	attr_reader :width, :height, :size

	def initialize(lines, char = "#")
		@cells = lines.map { |str| str.chomp.each_char.map { |c| c == "#" } }
		@char = char

		trim_cells
		@width = @cells[0].size
		@height = @cells.size
		@size = @width * @height
	end

	def each_position(field, &block)
		return to_enum(__method__) unless block

		cells, width, height = @cells, @width, @height
		4.times do |rot|
			ary = []
			cells.each_with_index do |row, j|
				row.each_with_index do |cell, i|
					ary.push(i + j * field.width) if cell
				end
			end

			(0..(field.height - height)).each do |j|
				(0..(field.width - width)).each do |i|
					offset = i + j * field.width
					block.call(ary.map { |idx| idx + offset }, [i, j, rot])
				end
			end

			cells, width, height = rotate(cells), height, width
			break if cells == @cells
		end

		self
	end

	def write(*)
		raise NotImplementedError
	end

	private

	def rotate(cells)
		raise NotImplementedError
	end

	def trim_cells
		raise NotImplementedError
	end
end

class FieldData < MapData
	def write
		@cells.map do |row|
			row.map { |cell| cell ? @char : "." }.join
		end
	end

	private

	def rotate(cells)
		cells
	end

	def trim_cells
	end
end

class PieceData < MapData
	def write(base, left, top, rot)
		cells = rot.times.inject(@cells) { |c, _| rotate(c) }
		cells.each.with_index(top) do |row, j|
			row.each.with_index(left) do |cell, i|
				base[j][i] = @char if cell
			end
		end

		base
	end

	private

	def rotate(cells)
		cells.transpose.reverse!
	end

	def trim_cells
		4.times { @cells = rotate(@cells).drop_while(&:none?) }
	end
end


if $0 == __FILE__
	stream = $stdin.each_line
	field = FieldData.new(stream.take_while { |line| !line.start_with?("\n", "\r") })

	chunk_key = field.height > 1 || :_alone  # 2-D mode / 1-D mode
	pieces = stream.chunk { |line| line.include?("#") ? chunk_key : :_separator }
			.zip("a".."z")
			.map { |(_, sub_lines), char| PieceData.new(sub_lines, char) }
	pieces.push(field)

	dlx = DLX::Client.new(field.size + pieces.size)
	pieces.each.with_index(field.size) do |piece, idx|
		piece.each_position(field) do |cell_indices, pos|
			dlx.add_row(cell_indices.push(idx), [piece, pos])
		end
	end

	cnt = 0
	dlx.each_solution do |ary_data|
		cnt += 1
		basemap = field.write
		ary_data.each do |piece, pos|
			piece.write(basemap, *pos) if piece.is_a?(PieceData)
		end
		puts basemap
		puts
	end
	puts "#{cnt} solution#{"s" if cnt != 1} found."
end
```

## 参考

* 元論文
	* Knuth, Donald E. (2000), "Dancing links", Millenial Perspectives in Computer Science, pp. 187-214. （[arXiv:cs/0011047](https://arxiv.org/abs/cs/0011047) [cs.DS]）
* Wikipedia英語版
	* [Exact cover](https://en.wikipedia.org/wiki/Exact_cover)
	* [Knuth's Algorithm X](https://en.wikipedia.org/wiki/Knuth's_Algorithm_X)
	* [Dancing Links](https://en.wikipedia.org/wiki/Dancing_Links)
* 日本語での解説
	* [Knuth's Algorithm XとDancing Linksの解説 - TopCoderとJ言語と時々F#](https://japlj.hatenadiary.org/entry/20090902/1251901464)
	* [ポリオミノの敷き詰め問題をDancing LinksとKnuth's Algorithm Xを使って解く - matsu7874のブログ](https://matsu7874.hatenablog.com/entry/2018/07/15/200000)
* 「厳密被覆」という日本語訳を使っているページ
	* [Knuth先生の『TAOCP 7.2.2.2 Satisfiability』を読む](http://bach.istc.kobe-u.ac.jp/lect/taocp-sat/)
	* [厳密被覆問題の高速な全解列挙法 - NTTグループ](https://www.ntt.co.jp/journal/1709/files/JN20170913.pdf)（PDF）
* ゲーム情報
	* [すれちがいMii広場（すれちがい迷宮） | ニンテンドー3DS｜任天堂](https://www.nintendo.co.jp/hardware/3dsseries/miiplaza/meikyu/)
	* [すれちがい迷宮/パズルボックス - すれちがいMii広場 攻略まとめwiki - アットウィキ](https://w.atwiki.jp/miiplaza/pages/163.html)