DLX_精确覆盖问题

精确覆盖问题： 给定一个由0-1组成的矩阵， 问是否能找到一个行的集合， 使得集合中每一列都恰好包含一个1（如图）。

       

算法X： 通过dfs， 每次选取一行可行的集合row， 这时把剩下的集合中含有与row相同的1的集合剪枝， 继续搜索直至得到答案或者发现无解而退出。

模拟算法X过程：

{

给定初始矩阵：

1 0 0 1 0 0 1

1 0 0 1 0 0 0

0 0 0 1 1 0 1

0 0 1 0 1 1 0

0 1 1 0 0 1 1

0 1 0 0 0 0 1

首先选取第一行

1 0 0 1 0 0 1

1 0 0 1 0 0 0

0 0 0 1 1 0 1

0 0 1 0 1 1 0

0 1 1 0 0 1 1

0 1 0 0 0 0 1

——>    0 1 1 1

这时机智的我们将含有相同元素1的集合去掉， 我们假定电脑和我们一样机智地发现去掉含有紫色1的行后无解， 那么回溯， 选取第二行。

1 0 0 1 0 0 1

1 0 0 1 0 0 0

0 0 0 1 1 0 1

0 0 1 0 1 1 0  

0 1 1 0 0 1 1  

0 1 0 0 0 0 1

——> 

0 1 1 1 0

1 1 0 1 1

1 0 0 0 1

没有任何异常， continue

0 1 1 1 0

1 1 0 1 1

1 0 0 0 1

——> 1 1

向胜利进军：1 1

程序结束， 刚才分别用到了第2、4、6个集合， 即答案为2 4 6。 这就是X算法的过程。

}

很容易想到上面的搜索， 但是状态的改变很难操作， 包括了删除和复原， 使用普通的数据结构运算根本停不下来。 于是， 一位大师想到了神奇的数据结构Dancing Links。

类似一个双向链表， 对于每个节点， 记录其左边节点和右边节点， 这时会发现删除和复原的操作实现变得可能了。

在记录左右节点的同时， 我们还要记录上下节点和当前节点所属的行和列， 这些变量在接下来的操作中要用到。

于是， 我们得到一个纵横交错的图。

图中的Ci是用来辅助的虚拟节点， 而所有虚拟节点的最前面有一个头结点head。 由于是循环链表， 对于每一行最开始的元素， 其左节点即为该行的最右边的节点， 同样地， 每一行最后的元素的右节点即为最开头的节点。 每一列同理。现在， 我们可以高效地进行删除列和复原列的操作了， 具体过程见代码。

模仿Rujia Liu的写法， 将整个DLX作为一个结构体进行编写， 大体结构如下：

struct DLX
{
    int n, sz;//列数， 节点总数
    int row[N], col[N], sum[N];//节点对应的行、列， 该列节点数

/*之所以记录每一列的节点数（不包括虚拟节点）， 主要是搜索过程中选择节点数最小的列则能更快地求解, 因为保留了尽可能多的集合*/
    int l[N], r[N], u[N], d[N];//左右上下
    int num, ans[N];//记录答案
    void init(int n) { }//初始化虚拟节点
    void add(int bel, vector<int>& a) { }//读入数据后构建Dancing Links
    void set_out(int c) { }//将列删除
    void set_in(int c) { }//将列复原
    bool dfs(int x) { }//搜索过程
    bool solve(vector<int>& v) { }//解决问题
};

具体代码的实现如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#define N 1000 + 10

using namespace std;

struct DLX
{
    int n, sz;
    int row[N], col[N], sum[N];
    int l[N], r[N], u[N], d[N];
    int num, ans[N];
    void init(int n)
    {
        this->n = n;
        for (int i = 1; i <= n; ++i)
        {
            u[i] = d[i] = i;
            l[i] = i - 1, r[i] = i + 1;
        }
        r[n] = 0, l[0] = n;
        r[0] = 1;
        sz = n + 1;
        memset(sum, 0, sizeof sum);//初始化
    }
    void add(int bel, vector<int>& a)
    {
        int now = sz;
        for (int i = 0; i < a.size(); ++i)
        {
            int c = a[i];
            l[sz] = sz - 1, r[sz] = sz + 1;//左右
            d[sz] = c, u[sz] = u[c];
            d[u[c]] = sz, u[c] = sz;//上下， 由于是循环链表， 所以可直接调用虚拟节点的u[c]
            row[sz] = bel; col[sz] = c;
            sum[c]++; sz++;
        }
        r[sz-1] = now, l[now] = sz - 1;//将之前i = 0时和当前的错误赋值纠正
    }
    void set_out(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];
            sum[col[j]]--;
        }
    }
    void set_in(int c)
    {
        for (int i = u[c]; i != c; i = u[i])//从下到上
        for (int j = l[i]; j != i; j = l[j])//从右到左
        {
            ++sum[col[j]];
            u[d[j]] = j;
            d[u[j]] = j;
        }
        l[r[c]] = c;
        r[l[c]] = c;
    }//注意： set_in和set_out的方向相反
    bool dfs(int x)
    {
        if (!r[0])
        {
            num = x;
            return true;//自己指向自己， 求解结束
        }
        int c = r[0];
        for (int i = r[0]; i != 0; i = r[i])
        if (sum[i] < sum[c]) c = i;//寻找节点数最少的一列
        set_out(c);
        for (int i = d[c]; i != c; i = d[i])
        {
            ans[x] = row[i];//记录
            for (int j = r[i]; j != i; j = r[j])
            set_out(col[j]);//删除
            if (dfs(x+1)) return true;
            for (int j = l[i]; j != i; j = l[j])
            set_in(col[j]);//复原
        }
        set_in(c);
        return false;
    }
    bool solve(vector<int>& v)
    {
        v.clear();
        if (!dfs(0)) return false;
        for (int i = 0; i < num; ++i)
        v.push_back(ans[i]);
        return true;
    }
}test;
int n, m, x;
vector<int>v;
int main()
{
    scanf("%d %d", &n, &m);
    test.init(m);//对数据结构初始化
    for (int i = 1; i <= n; ++i)
    {
        v.clear();
        for (int j = 1; j <= m; ++j)
        {
            scanf("%d", &x);
            if (x) v.push_back(j);
        }
        test.add(i, v);//在Dancing Links中添加一行
    }
    v.clear();
    if (test.solve(v))
    {
        for (int i = 0; i < v.size(); ++i)
        printf("%d ", v[i]);
        putchar('\n');
    }
    else printf("No answer!\n");//调用solve函数
    return 0;
}