Dancing links 数据结构

前言

想必很多人学习这个算法，都是因为数独的原因，虽然这个算法并不是专门解决数独的，但是，在解决数独方面，仍然比暴力搜索有很大，优势，在解法方面就显得很方便，复杂度方面也很客观，总得来说这个算法的思想并不是很难理解，但是没有一种很好的数据结构能很好的实现该算法，由此Dlx这种数据结构就诞生了，它的诞生是为了解决叫精度覆盖一类的问题的，所以要学习它，就要从最简单的精度覆盖开始学习。

推荐一篇讲解：DXL详解
符加一道例题：精确覆盖问题
因为这个数据结构或算法是由链表实现的，理解起来十分的绕脑，所以需要在纸上多画画才能理清思路，实现删除操作更是比较绕脑。

可行代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 6e3 + 5;
int l[N], r[N], d[N], u[N], col[N], row[N], s[N], ans[N];
int ct, top, n, m;
void init() {
  for (int i = 0; i <= m; i++) {
    l[i] = i - 1, r[i] = i + 1;
    u[i] = d[i] = i;
  }
  l[0] = m, r[m] = 0;
  ct = m + 1;
}
void add(int& hh, int& tt, int x, int y) {
  row[ct] = x, col[ct] = y, s[y]++;
  d[ct] = y, u[ct] = u[y], d[u[y]] = ct, u[y] = ct;
  l[hh] = ct, r[ct] = hh, r[tt] = ct, l[ct] = tt;
  tt = ct++;
}
void remove(int p) {
  r[l[p]] = r[p], l[r[p]] = l[p];
  for (int i = d[p]; i != p; i = d[i]) {
    for (int j = r[i]; j != i; j = r[j]) {
      u[d[j]] = u[j], d[u[j]] = d[j];
      s[col[j]]--;
    }
  }
}
void resum(int p) {
  for (int i = u[p]; i != p; i = u[i]) {
    for (int j = l[i]; j != i; j = l[j]) {
      u[d[j]] = j, d[u[j]] = j;
      s[col[j]]++;
    }
  }
  r[l[p]] = p, l[r[p]] = p;
}
bool dfs() {
  if (!r[0])
    return true;
  int p = r[0];
  for (int i = r[0]; i; i = r[i]) {
    if (s[i] < s[p]) {
      p = i;
    }
  }
  remove(p);
  for (int i = d[p]; i != p; i = d[i]) {
    ans[++top] = row[i];
    for (int j = r[i]; j != i; j = r[j]) {
      remove(col[j]);
    }
    if (dfs())
      return true;
    for (int j = l[i]; j != i; j = l[j]) {
      resum(col[j]);
    }
    top--;
  }
  resum(p);
  return false;
}
int main() {
  cin >> n >> m;
  init();
  for (int i = 1; i <= n; i++) {
    int hh = ct, tt = ct;
    for (int j = 1; j <= m; j++) {
      int x;
      cin >> x;
      if (x) {
        add(hh, tt, i, j);
      }
    }
  }
  if (dfs()) {
    for (int i = 1; i <= top; i++)
      cout << ans[i] << ' ';
    puts("");
  } else {
    puts("No Solution!");
  }
  return 0;
}
// 0 0 1 0 1 1 0
// 1 0 0 1 0 0 1
// 0 1 1 0 0 1 0
// 1 0 0 1 0 0 0
// 0 1 0 0 0 0 1
// 0 0 0 1 1 0 1