裸的模板题HUST 1017 Exact cover(舞蹈链&不能为了ac而ac)

There is an N*M matrix with only 0s and 1s, (1 <= N,M <= 1000). An exact cover is a selection of rows such that every column has a 1 in exactly one of the selected rows. 
Try to find out the selected rows. 

Input

There are multiply test cases. 
First line: two integers N, M; 
The following N lines: Every line first comes an integer C(1 <= C <= 100), represents the number of 1s in this row, then comes C integers: the index of the columns whose value is 1 in this row. 

Output

First output the number of rows in the selection, then output the index of the selected rows. 
If there are multiply selections, you should just output any of them. 
If there are no selection, just output "NO". 

Sample Input

6 7
3 1 4 7
2 1 4
3 4 5 7
3 3 5 6
4 2 3 6 7
2 2 7

Sample Output

3 2 4 6

标准的舞蹈链模版题，理解了舞蹈链就能a了。 
学习舞蹈链，推荐此博文，相当清晰:跳跃的舞者，舞蹈链（Dancing Links）算法——求解精确覆盖问题 
 

给定一01矩阵，问是否能够精确覆盖(就是选取任意行，这些行的1所在的列互不冲突且完整覆盖所有列)，若有输出行号(要按递增顺序输出)，否则输出NO。

 int c = R[0];
 for(int i = R[0]; i!=0; i = R[i])   //挑结点数最少的那一列，否则会超时
   if(S[i]<S[c])
     c = i;

上面这段代码作用是每次选取元素最少的列进行操作，可以有效减少递归层数，从而加快程序效率。
因为本人好奇，取消了它试了一下，发现wrong(按理也应该是timelimit啊)，一试再试，发现是得出的行号没有排序的原因，加上对结果的排序就好了。
但本人又好奇了，一再思索，终究还是想不出来上述代码为什么能够使结果递增序，于是做了一组数据：
5 5
2 4 5
3 1 3 4
1 5
1 2
2 1 5
测试后发现无论加不加上述代码结果都不是递增序的，也就是说上述代码只是加速的功能而已。

 

#include <iostream>
#include <algorithm>
#include <string>
using namespace std;

typedef long long LL;
const int MAXN = 1e3+10;
const int MAXM = 1e3+10;
const int maxnode = 1e6+10;
 
int n, m;
struct DLX      //矩阵的行和列是从1开始的
{
    int n, m, size; //size为结点数
    int U[maxnode], D[maxnode], L[maxnode], R[maxnode], Row[maxnode], Col[maxnode];
    int H[MAXN], S[MAXM];   //H为每一行的头结点，但不参与循环。S为每一列的结点个数
    int ansd, ans[MAXN];//结果保存数组
 
    void init(int _n, int _m)   //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)
    {
        size++; //类似于前向星
        Col[size] = c;
        Row[size] = r;
        S[Col[size]]++;
        D[size] = D[c];
        U[D[c]] = size;
        U[size] = c;
        D[c] = size;
        if(H[r]==-1) H[r] = L[size] = R[size] = size; //当前行为空
        else        //当前行不为空： 头插法，无所谓顺序，因为Row、Col已经记录了位置
        {
            R[size] = R[H[r]];
            L[R[H[r]]] = size;
            L[size] = H[r];
            R[H[r]] = size;
        }
    }
 
    void remove(int c)  //c是列的编号， 不是结点的编号
    {
        L[R[c]] = L[c]; R[L[c]] = R[c];     //在列的头结点的循环队列中， 越过列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)
    {
        L[R[c]] = R[L[c]] = c;
        for(int i = U[c]; i!=c; i = U[i])
        for(int j = L[i]; j!=i; j = L[j])
        {
            U[D[j]] = D[U[j]] = j;
            S[Col[j]]++;
        }
    }
 
    bool Dance(int d)
    {
        if(R[0]==0)//列辅助数组为空表示已得解
        {
            printf("%d ", d);
            for(int i = 0; i<d; i++)
                printf("%d ", ans[i]);
            printf("\n");
            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;
    }
};
 
DLX dlx;
int main()
{
    while(scanf("%d%d", &n, &m)!=EOF)
    {
        dlx.init(n,m);  //初始化矩阵， n*m为矩阵的大小
        for(int i = 1; i<=n; i++)
        {
            int num, j;
            scanf("%d",&num);
            while(num--)
            {
                scanf("%d", &j);
                dlx.Link(i, j);      //在矩阵中的第i行， 第j列加入一个“1”
            }
        }
        if(!dlx.Dance(0))
            puts("NO");
    }
    return 0;
}