2020-21

dlx/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_library(dlx src/dlx.cpp)
+target_include_directories(dlx PUBLIC include)

dlx/include/dlx.hpp

@@ -0,0 +1,113 @@
+#ifndef DLX_DLX_HPP_
+#define DLX_DLX_HPP_
+
+#include <cstddef>
+#include <functional>
+#include <vector>
+
+namespace dlx {
+
+class Dlx {
+
+  struct Cell {
+    Cell *U, *D, *L, *R;
+    std::size_t n;
+    union {
+      Cell* c;
+      std::size_t s;
+    };
+
+    auto LR_self() -> void { L = R = this; }
+    auto UD_self() -> void { U = D = this; }
+    auto LR_delete() -> void { L->R = R; R->L = L; }
+    auto UD_delete() -> void { U->D = D; D->U = U; }
+    auto UD_restore() -> void { U->D = D->U = this; }
+    auto LR_restore() -> void { L->R = R->L = this; }
+    auto LR_insert(Cell* k) -> void { L = k->L; R = k; k->L = k->L->R = this; }
+    auto UD_insert(Cell* k) -> void { U = k->U, D = k, k->U = k->U->D = this; }
+
+    static Cell* ColNew() {
+      auto c = new Cell;
+      c->UD_self();
+      c->s = 0;
+      return c;
+    }
+
+    auto CoverCol() -> void {
+      LR_delete();
+      for (auto i = D; i != this; i = i->D) {
+        for (auto j = i->R; j != i; j = j->R) {
+          j->UD_delete();
+          j->c->s--;
+        }
+      }
+    }
+
+    auto UncoverCol() -> void {
+      for (auto i = U; i != this; i = i->U) {
+        for (auto j = i->L; j != i; j = j->L) {
+          j->c->s++;
+          j->UD_restore();
+        }
+      }
+      LR_restore();
+    }
+
+  };
+
+  std::vector<Cell*> ctab_;
+  std::vector<Cell*> rtab_;
+  Cell* root_;
+
+  auto AddCol() -> void;
+  auto AddRow() -> void;
+  auto AllocCol(std::size_t n) -> void;
+  auto AllocRow(std::size_t n) -> void;
+
+public:
+  Dlx();
+  ~Dlx();
+
+  // Returns number of rows.
+  auto Rows() const -> std::size_t;
+
+  // Returns number of columns.
+  auto Cols() const -> std::size_t;
+
+  // Places a 1 in the given row and column.
+  // Increases the number of rows and columns if necessary.
+  auto Set(std::size_t row, std::size_t col) -> void;
+
+// Marks a column as optional: a solution need not cover the given column,
+// but it still must respect the constraints it entails.
+  auto MarkOptional(std::size_t col) -> void;
+
+  // Removes a row from consideration. Returns 0 on success, -1 otherwise.
+  // Should only be called after all dlx_set() calls.
+  auto RemoveRow(std::size_t row) -> int;
+
+  // Picks a row to be part of the solution. Returns 0 on success, -1 otherwise.
+  // Should only be called after all dlx_set() calls and dlx_remove_row() calls.
+  // TODO: Check the row can be legally chosen.
+  auto PickRow(std::size_t row) -> int;
+
+  auto Solve(
+    std::function<void(std::size_t, std::size_t, std::size_t)> try_cb,
+    std::function<void()> undo_cb,
+    std::function<void()> found_cb,
+    std::function<void(std::size_t)> stuck_cb) -> void;
+};
+
+auto ForallCover(Dlx& dlx, auto cb) {
+  std::vector<std::size_t> sol;
+  dlx.Solve(
+    [&](std::size_t c, std::size_t s, std::size_t r) { sol.push_back(r); },
+    [&](){ sol.pop_back(); },
+    [&](){ cb(sol); },
+    [](std::size_t){}
+  );
+}
+
+} // namespace
+
+#endif

dlx/src/dlx.cpp

@@ -0,0 +1,170 @@
+// See http://en.wikipedia.org/wiki/Dancing_Links.
+
+#include "dlx.hpp"
+
+#include <limits>
+
+using namespace dlx;
+
+#define F(i,n) for(int i = 0; i < n; i++)
+
+#define C(i,n,dir) for(cell_ptr i = (n)->dir; i != n; i = i->dir)
+
+Dlx::Dlx() {
+  root_ = Cell::ColNew();
+  root_->LR_self();
+}
+
+Dlx::~Dlx() {
+  for (auto const row : rtab_) {
+    if (row) {
+      Cell* next;
+      for (auto cursor = row->R; cursor != row; cursor = next) {
+        next = cursor->R;
+        delete cursor;
+      }
+      delete row;
+    }
+  }
+  for (auto const col : ctab_) {
+    if (col) { delete col; }
+  }
+  delete root_;
+}
+
+auto Dlx::Rows() const -> std::size_t { return rtab_.size(); }
+auto Dlx::Cols() const -> std::size_t { return ctab_.size(); }
+
+auto Dlx::AddCol() -> void {
+  auto c = Cell::ColNew();
+  c->LR_insert(root_);
+  c->n = Cols();
+  ctab_.push_back(c);
+}
+
+auto Dlx::AddRow() -> void {
+  rtab_.push_back(nullptr);
+}
+auto Dlx::AllocCol(std::size_t n) -> void {
+  while(Cols() <= n) AddCol();
+}
+
+auto Dlx::AllocRow(std::size_t n) -> void {
+  while(Rows() <= n) AddRow();
+}
+
+
+auto Dlx::MarkOptional(std::size_t col) -> void {
+  AllocCol(col);
+  auto c = ctab_[col];
+  // Prevent undeletion by self-linking.
+  c->LR_delete();
+  c->LR_self();
+}
+
+
+auto Dlx::Set(std::size_t row, std::size_t col) -> void {
+  // We don't bother sorting. DLX works fine with jumbled rows and columns.
+  // We just have to watch out for duplicates. (Actually, I think the DLX code
+  // works even with duplicates, though it would be inefficient.)
+  //
+  // For a given column, the UD list is ordered in the order that dlx_set()
+  // is called, not by row number. Similarly for a given row and its LR list.
+  AllocRow(row);
+  AllocCol(col);
+  auto c = ctab_[col];
+
+  auto const new1 = [&]() -> Cell* {
+    auto n = new Cell;
+    n->n = row;
+    n->c = c;
+    c->s++;
+    n->UD_insert(c);
+    return n;
+  };
+  
+  auto & r = rtab_[row];
+  
+  if (!r) {
+    r = new1();
+    r->LR_self();
+    return;
+  }
+
+  // Ignore duplicates.
+  if (r->c->n == col) return;
+
+  for (auto cursor = r->R; cursor != r; cursor = cursor->R) {
+    if (cursor->c->n == col) return;
+  }
+
+  // Otherwise insert at end of LR list.
+  new1()->LR_insert(r);
+}
+
+auto Dlx::PickRow(std::size_t i) -> int {
+  auto r = rtab_.at(i);
+  if (!r) return 0;  // Empty row.
+  r->c->CoverCol();
+  for (auto j = r->R; j != r; j = j->R) {
+    j->c->CoverCol();
+  }
+
+  return 0;
+}
+
+
+auto Dlx::RemoveRow(std::size_t i) -> int {
+  auto & r = rtab_.at(i);
+  if (!r) return 0;  // Empty row.
+  r->UD_delete();
+  r->c->s--;
+  for (auto j = r->R; j != r; j = j->R) {
+    j->UD_delete();
+    j->c->s--;
+  }
+  r = nullptr;
+  return 0;
+}
+
+auto Dlx::Solve(
+  std::function<void(std::size_t, std::size_t, std::size_t)> try_cb,
+  std::function<void()> undo_cb,
+  std::function<void()> found_cb,
+  std::function<void(std::size_t)> stuck_cb) -> void
+{
+  auto const recurse = [&](auto const& self) -> void {
+    auto c = root_->R;
+    if (c == root_) {
+      found_cb();
+      return;
+    }
+
+    auto s = std::numeric_limits<std::size_t>::max();  // S-heuristic: choose first most-constrained column.
+    for (auto i = root_->R; i != root_; i = i->R) {
+      if (i->s < s) {
+        s = (c = i)->s;
+      }
+    }
+    
+    if (!s) {
+      stuck_cb(c->n);
+      return;
+    }
+
+    c->CoverCol();
+    for (auto r = c->D; r != c; r = r->D) {
+      try_cb(c->n, s, r->n);
+      for (auto j = r->R; j != r; j = j->R) {
+        j->c->CoverCol();
+      }
+      self(self);
+      undo_cb();
+      for (auto j = r->L; j != r; j=j->L) {
+        j->c->UncoverCol();
+      }
+    }
+    c->UncoverCol();
+  };
+  recurse(recurse);
+}