Dancing Links 小结 (因为之前丢了一次稿，未完待续)

Dancing Links (DLX)是Knuth为了解决精确覆盖问题而提出的算法，很多搜索问题可以转化位精确覆盖问题从而使用Dancing Links解决（效率会比DFS高很多，因为里面常常蕴涵着意想不到的剪枝）

信息学竞赛中的DLX的问题类似网络流，只需建图+贴版即可

参考文献：

1、DLX的原理：Knuth的论文：

原版：http://arxiv.org/abs/cs/0011047

翻译版：http://wenku.baidu.com/view/d8f13dc45fbfc77da269b126.html

2、DLX在搜索中的应用（DLX应用于信息学竞赛的论文）：http://bbs.whu.edu.cn/wForum/elite.php?file=%2Fgroups%2FGROUP_3%2FACM_ICPC%2Fnx08%2FD.08010000%2FM.1215524645.R0&ap=563

首先介绍精确覆盖问题概念：

精确覆盖：在一个全集$X$中若干子集的集合为$S$，精确覆盖是指，$S$的子集$S*$，满足$X$中的每一个元素在$S*$中 extbf{恰好}出现一次。

即：给你一个0-1矩阵，选取若干行，使得选取的行组成的新矩阵的每一列有且仅有一个1

关于DLX的原理这里就不详细介绍了，有兴趣了解者可以去阅读Knuth的论文

DLX精确覆盖模板(From kuangbin)：

const int maxnode = 100010;
const int maxr = 1010;
const int maxc = 1010;
struct DLX
{
    int n, m, size;
    int U[maxnode], D[maxnode], R[maxnode], L[maxnode], Row[maxnode], Col[maxnode];
    int H[maxc], S[maxr];
    int ansd, ans[maxc];
    void init(int _n, int _m)
    {
        n = _n;
        m = _m;
        for (int i = 0; i <= m; i++)
        {
            S[i] = 0;
            U[i] = D[i] = i;
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0; L[0] = m;
        size = m;
        for (int i = 1; i <= n; i++)
            H[i] = -1;
    }
    void Link(int r, int c)
    {
        ++S[Col[++size] = c];
        Row[size] = r;
        D[size] = D[c];
        U[D[c]] = size;
        U[size] = c;
        D[c] = size;
        if (H[r] < 0)H[r] = L[size] = R[size] = size;
        else
        {
            R[size] = R[H[r]];
            L[R[H[r]]] = size;
            L[size] = H[r];
            R[H[r]] = size;
        }
    }
    void remove(int c)
    {
        L[R[c]] = L[c]; R[L[c]] = R[c];
        for (int i = D[c]; i != c; 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 resume(int c)
    {
        for (int i = U[c]; i != c; i = U[i])
            for (int j = L[i]; j != i; j = L[j])
                ++S[Col[U[D[j]] = D[U[j]] = j]];
        L[R[c]] = R[L[c]] = c;
    }
    //d为递归深度
    bool Dance(int d)
    {
        if (R[0] == 0)
        {
            ansd = d;
            return true;
        }
        int c = R[0];
        for (int i = R[0]; i != 0; i = R[i])
            if (S[i] < S[c])
                c = i;
        remove(c);
        for (int i = D[c]; i != c; i = D[i])
        {
            ans[d] = Row[i];
            for (int j = R[i]; j != i; j = R[j])remove(Col[j]);
            if (Dance(d + 1))return true;
            for (int j = L[i]; j != i; j = L[j])resume(Col[j]);
        }
        resume(c);
        return false;
    }
};

PS：init函数初始化，0-1矩阵中为1的位置(i,j)用Link(i,j)添加约束，Dance函数为解决过程(bool表示能否完成)，ansd为选取的数量，and[]为选取的行

精确覆盖问题可以延伸为重复覆盖问题，定义如下：

重复覆盖：在一个全集$X$中若干子集的集合为$S$，重复覆盖是指，$S$的子集$S*$，满足$X$中的每一个元素在$S*$中 extbf{至少}出现一次。

即：给你一个0-1矩阵，选取若干行，使得选取的行组成的新矩阵的每一列至少有一个1

DLX重复覆盖模板

const int maxnode = 360000;
const int maxc = 500;
const int maxr = 500;
const int inf = 0x3f3f3f3f;
struct DLX
{
    int L[maxnode], R[maxnode], D[maxnode], U[maxnode], C[maxnode];
    int S[maxc], H[maxr], size;
    int ans;
    ///不需要S域
    void Link(int r, int c)
    {
        S[c]++; C[size] = c;
        U[size] = U[c]; D[U[c]] = size;
        D[size] = c; U[c] = size;
        if (H[r] == -1) H[r] = L[size] = R[size] = size;
        else
        {
            L[size] = L[H[r]]; R[L[H[r]]] = size;
            R[size] = H[r]; L[H[r]] = size;
        }
        size++;
    }
    void remove(int c)
    {
        for (int i = D[c]; i != c; i = D[i])
            L[R[i]] = L[i], R[L[i]] = R[i];
    }
    void resume(int c)
    {
        for (int i = U[c]; i != c; i = U[i])
            L[R[i]] = R[L[i]] = i;
    }
    int h() ///用精确覆盖去估算剪枝
    {
        int ret = 0;
        bool vis[maxc];
        memset (vis, false, sizeof(vis));
        for (int i = R[0]; i; i = R[i])
        {
            if (vis[i])continue;
            ret++;
            vis[i] = true;
            for (int j = D[i]; j != i; j = D[j])
                for (int k = R[j]; k != j; k = R[k])
                    vis[C[k]] = true;
        }
        return ret;
    }
    //根据具体问题选择限制搜索深度或直接求解。
    bool Dance(int k)
    {
        if (k + h() >= ans) return 0;
        if (!R[0])
        {
            if (k < ans)ans = k;
            return 1;
        }
        int c = R[0];
        for (int i = R[0]; i; i = R[i])
            if (S[i] < S[c])c = i;
        for (int i = D[c]; i != c; i = D[i])
        {
            remove(i);
            for (int j = R[i]; j != i; j = R[j])
                remove(j);
            Dance(k + 1);
            for (int j = L[i]; j != i; j = L[j])
                resume(j);
            resume(i);
        }
        return 0;
    }
    void initL(int x) ///col is 1~x,row start from 1
    {
        for (int i = 0; i <= x; ++i)
        {
            S[i] = 0;
            D[i] = U[i] = i;
            L[i + 1] = i; R[i] = i + 1;
        }///对列表头初始化
        R[x] = 0;
        size = x + 1; ///真正的元素从m+1开始
        memset (H, -1, sizeof(H));
        ///mark每个位置的名字
    }
};

输入：Link()
输出：ans, bool Dance(int k)

重点来了：如何建图？这里选取典型例题说明

(因为之前丢了一次稿，未完待续)