Dancing Link专题

一些链接：

　　　　http://www.cnblogs.com/-sunshine/p/3358922.html

　　　　http://www.cnblogs.com/grenet/p/3145800.html

1、hust 1017 Exact cover (Dancing Links 模板题)

　　题意：n*m的单位矩阵。现在要选一些行，使得这些行的集合中每列只出现一个1.

　　思路：裸的精确覆盖问题。刷一遍模板。

#include <iostream>  
#include <stdio.h>  
#include <string.h>  
//精确覆盖问题的定义：给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1
const int MN = 1005;//最大行数
const int MM = 1005;//最大列数
const int MNN = 1e5 + 5 + MM; //最大点数  

struct DLX
{
    int n, m, si;//n行数m列数si目前有的节点数  
    //十字链表组成部分  
    int U[MNN], D[MNN], L[MNN], R[MNN], Row[MNN], Col[MNN];
    //第i个结点的U向上指针D下L左R右，所在位置Row行Col列  
    int H[MN], S[MM]; //记录行的选择情况和列的覆盖情况  
    int ansd, ans[MN];
    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;
        si = m;                 //目前用了前0~m个结点  
        for (int i = 1; i <= n; i++)
            H[i] = -1;
    }
    void link(int r, int c)    //插入点(r,c)  
    {
        ++S[Col[++si] = c];     //si++;Col[si]=c;S[c]++;  
        Row[si] = r;//si该结点的行数为r
        D[si] = D[c];//向下指向c的下面的第一个结点
        U[D[c]] = si;//c的下面的第一个结点的上面为si
        U[si] = c;//si的上面为列指针
        D[c] = si;//列指针指向的第一个该列中的元素设为si
        if (H[r]<0)//如果第r行没有元素
            H[r] = L[si] = R[si] = si;
        else
        {
            R[si] = R[H[r]];//si的右边为行指针所指的右边第一个元素
            L[R[H[r]]] = si;//行指针所指的右边第一个元素的左侧为si
            L[si] = H[r];//si的左侧为行指针
            R[H[r]] = si;//行指针的右侧为si
        }
    }
    void remove(int c)        //列表中删掉c列  
    {
        L[R[c]] = L[c];//表头操作  //c列头指针的右边的元素的左侧指向c列头指针左边的元素
        R[L[c]] = R[c];//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)        //恢复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]];//D[U[j]]=j;U[D[j]]=j;S[Col[j]]++;
        L[R[c]] = R[L[c]] = c;//c列头指针左右相连
    }
    bool dance(int d) //选取了d行  
    {
        if (R[0] == 0)//全部覆盖了  
        {
            //全覆盖了之后的操作  
            ansd = d;
            return 1;
        }
        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 1;
            for (int j = L[i]; j != i; j = L[j])
                resume(Col[j]);
        }
        resume(c);
        return 0;
    }
}dlx;

int main()
{
    int n, m;
    while (scanf("%d%d", &n, &m) != EOF)
    {
        dlx.init(n, m);
        for (int i = 1; i <= n; i++)
        {//共n列
            int k;
            scanf("%d", &k);//每列中含1的个数
            while (k--)
            {
                int cc;
                scanf("%d", &cc);//输入其所在的列
                dlx.link(i, cc);//链接
            }
        }
        dlx.ansd = -1;
        if (dlx.dance(0))
        {
            printf("%d", dlx.ansd);
            for (int i = 0; i<dlx.ansd; i++)
                printf(" %d", dlx.ans[i]);
            printf("
");
        }
        else
            printf("NO
");
    }
    return 0;
}

2、ZOJ 3209 Treasure Map

　　题意：给出一些矩形，问最少需要多少个矩形可以把指定的一块区域覆盖。

　　思路：把每个矩形块看成行，把指定区域分成1*1的单元格，所有的单元格看成列。

#include <iostream>  
#include <stdio.h>  
#include <string.h>
#include<algorithm>
//精确覆盖问题的定义：给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1
const int MN = 1005;//最大行数
const int MM = 1005;//最大列数
const int MNN = 1e5 + 5 + MM; //最大点数  

struct DLX
{
    int n, m, si;//n行数m列数si目前有的节点数  
                 //十字链表组成部分  
    int U[MNN], D[MNN], L[MNN], R[MNN], Row[MNN], Col[MNN];
    //第i个结点的U向上指针D下L左R右，所在位置Row行Col列  
    int H[MN], S[MM]; //记录行的选择情况和列的覆盖情况  
    int ansd, ans[MN];
    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;
        si = m;                 //目前用了前0~m个结点  
        for (int i = 1; i <= n; i++)
            H[i] = -1;
    }
    void link(int r, int c)    //插入点(r,c)  
    {
        ++S[Col[++si] = c];     //si++;Col[si]=c;S[c]++;  
        Row[si] = r;//si该结点的行数为r
        D[si] = D[c];//向下指向c的下面的第一个结点
        U[D[c]] = si;//c的下面的第一个结点的上面为si
        U[si] = c;//si的上面为列指针
        D[c] = si;//列指针指向的第一个该列中的元素设为si
        if (H[r]<0)//如果第r行没有元素
            H[r] = L[si] = R[si] = si;
        else
        {
            R[si] = R[H[r]];//si的右边为行指针所指的右边第一个元素
            L[R[H[r]]] = si;//行指针所指的右边第一个元素的左侧为si
            L[si] = H[r];//si的左侧为行指针
            R[H[r]] = si;//行指针的右侧为si
        }
    }
    void remove(int c)        //列表中删掉c列  
    {
        L[R[c]] = L[c];//表头操作  //c列头指针的右边的元素的左侧指向c列头指针左边的元素
        R[L[c]] = R[c];//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)        //恢复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]];//D[U[j]]=j;U[D[j]]=j;S[Col[j]]++;
        L[R[c]] = R[L[c]] = c;//c列头指针左右相连
    }
    bool dance(int d) //选取了d行  
    {
        if (ansd != -1 && ansd < d)return 0;
        if (R[0] == 0)//全部覆盖了
        {
            //全覆盖了之后的操作  
            if(ansd==-1)ansd = d;
            else if (d < ansd) ansd = d;
            return 1;
        }
        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]);//将该列的某个元素的行上的元素所在的列都删去
            (dance(d + 1));
            for (int j = L[i]; j != i; j = L[j])
                resume(Col[j]);
        }
        resume(c);
        return 0;
    }
}dlx;

int main()
{
    int n, m,p;
    int t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d%d", &n, &m, &p);
        dlx.init(p, n*m);//将块当成行，所有的单元格看成列
        for (int pp = 1; pp <= p; pp++)
        {
            int x1, x2, y1, y2;
            scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
            for (int i = x1 + 1; i <= x2; i++)
            {
                for (int j = y1 + 1; j <= y2; j++)
                {
                    dlx.link(pp, (i - 1)*m + j);
                }
            }
        }
        dlx.ansd = -1;
        dlx.dance(0);
        printf("%d
", dlx.ansd);
    }
    return 0;
}

 3、HDU 2295 Radar

　　题意：给出n个城市，给出m个雷达（都是坐标），要求在使用不超过k个雷达的情况下，并且保证覆盖所有的城市，使得每个雷达的覆盖半径最小。

　　思路：DLK重复覆盖模板。

#include <iostream>  
#include <stdio.h>  
#include <string.h>  
//重复覆盖：找到一些行，使得这些行的集合中每列至少有一个1
const int MN = 55;//最大行数
const int MM = 55;//最大列数
const int MNN = MM*MN+MM+MN+10; //最大点数  

struct DLX
{
    int n, m, si;//n行数m列数si目前有的节点数  
                 //十字链表组成部分  
    int U[MNN], D[MNN], L[MNN], R[MNN], Row[MNN], Col[MNN];
    //第i个结点的U向上指针D下L左R右，所在位置Row行Col列  
    int H[MN], S[MM]; //记录行的选择情况和列的覆盖情况  
    int ansd, ans[MN];
    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;
        si = m;                 //目前用了前0~m个结点  
        for (int i = 1; i <= n; i++)
            H[i] = -1;
    }
    void link(int r, int c)    //插入点(r,c)  
    {
        ++S[Col[++si] = c];     //si++;Col[si]=c;S[c]++;  
        Row[si] = r;//si该结点的行数为r
        D[si] = D[c];//向下指向c的下面的第一个结点
        U[D[c]] = si;//c的下面的第一个结点的上面为si
        U[si] = c;//si的上面为列指针
        D[c] = si;//列指针指向的第一个该列中的元素设为si
        if (H[r]<0)//如果第r行没有元素
            H[r] = L[si] = R[si] = si;
        else
        {
            R[si] = R[H[r]];//si的右边为行指针所指的右边第一个元素
            L[R[H[r]]] = si;//行指针所指的右边第一个元素的左侧为si
            L[si] = H[r];//si的左侧为行指针
            R[H[r]] = si;//行指针的右侧为si
        }
    }
    void remove(int c)        //列表中删掉c列  
    {
        //L[R[c]] = L[c];//表头操作  //c列头指针的右边的元素的左侧指向c列头指针左边的元素
        //R[L[c]] = R[c];//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]];//该元素所在的列数目减一
        //    }
        /*重复覆盖*//*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)//恢复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]];//D[U[j]]=j;U[D[j]]=j;S[Col[j]]++;
        //L[R[c]] = R[L[c]] = c;//c列头指针左右相连
        /*重复覆盖*/
        for (int i = U[c]; i != c; i = U[i])
        {
            L[R[i]] = R[L[i]] = i;
        }
    }
    int f_check()//精确覆盖区估算剪枝  
    {
        /*
        强剪枝。这个 剪枝利用的思想是A*搜索中的估价函数。即，对于当前的递归深度K下的矩阵，估计其最好情况下（即最少还需要多少步）才能出解。也就是，如果将能够覆盖当 前列的所有行全部选中，去掉这些行能够覆盖到的列，将这个操作作为一层深度。重复此操作直到所有列全部出解的深度是多少。如果当前深度加上这个估价函数返 回值，其和已然不能更优（也就是已经超过当前最优解），则直接返回，不必再搜。
        */
        int vis[MNN];
        memset(vis, 0, sizeof(vis));
        int ret = 0;
        for (int c = R[0]; c != 0; c = R[c]) vis[c] = true;
        for (int c = R[0]; c != 0; c = R[c])
            if (vis[c])
            {
                ret++;
                vis[c] = false;
                for (int i = D[c]; i != c; i = D[i])
                    for (int j = R[i]; j != i; j = R[j])
                        vis[Col[j]] = false;
            }
        return ret;
    }
    bool dance(int d,int limit) //选取了d行,limit为限制选取的最大行数
    {
/*重复覆盖
1、如果矩阵为空，得到结果，返回
2、从矩阵中选择一列，以选取最少元素的列为优化方式
3、删除该列及其覆盖的行
4、对该列的每一行元素：删除一行及其覆盖的列，
5、进行下一层搜索，如果成功则返回
6、恢复现场，跳至4
7、恢复所选择行
*/
        if (d > limit)return false;
        if (d + f_check() > limit)return false;
        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];//记录该列元素的行
            remove(i);//新增(重复覆盖)
            for (int j = R[i]; j != i; j = R[j])
                remove(j);//remove(Col[j])(精确覆盖)
            if (dance(d + 1, limit)) return true;
            for (int j = L[i]; j != i; j = L[j])
                resume(j);//resume(Col[j])(精确覆盖)
            resume(i);//新增(重复覆盖)
        }
        //resume(c);(精确覆盖)
        return false;
    }
}dlx;
struct node
{
    int x;
    int y;
}citys[55],radar[55];
double dis[55][55];
int main()
{
    int n, m,k;
    int t;
    scanf("%d", &t);
    
    while (t--)
    {
        double l = 0, r=0,maxx=0,maxy=0;
        scanf("%d%d%d", &n, &m, &k);
        for (int i = 1; i <= n; i++)
        {
            scanf("%d%d", &citys[i].x, &citys[i].y);
            if (citys[i].x + citys[i].y > maxx + maxy)
            {
                maxx = citys[i].x, maxy = citys[i].y;
            }
        }
        for (int i = 1; i <= m; i++)
        {
            scanf("%d%d", &radar[i].x, &radar[i].y);
            if (radar[i].x + radar[i].y > maxx + maxy)
            {
                maxx = radar[i].x, maxy = radar[i].y;
            }
        }
        for (int i = 1; i <= m; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                dis[i][j] = sqrt((radar[i].x - citys[j].x)*(radar[i].x - citys[j].x) + (radar[i].y - citys[j].y)*(radar[i].y - citys[j].y));
            }
        }
        r = sqrt(maxx*maxx + maxy*maxy);
        while (r - l > 1e-7)
        {
            double mid = (l + r) / 2;
            dlx.init(m, n);
            for (int i = 1; i <= m; i++)
            {
                for (int j = 1; j <= n; j++)
                {
                    if (dis[i][j] <= mid) dlx.link(i, j);
                }
            }
            dlx.ansd = -1;
            if (dlx.dance(0,k)) r = mid;
            else l = mid;
        }
        printf("%.6lf
", l);
    }
    return 0;
}

 4、FZU 1686 神龙的难题

　　题意：有个n*m的矩形，每次可以把n1*m1小矩形范围内的敌人消灭，最少的次数。

　　思路：DLK重复覆盖模板，枚举所有的小矩形，设为行，把所有敌人编号，记为列。

#include<iostream>  
#include<cstdio>
#include<memory.h>
#include<algorithm>
using namespace std;
//重复覆盖：找到一些行，使得这些行的集合中每列至少有一个1
const int MN =250;//最大行数
const int MM = 250;//最大列数
const int MNN = MM*MN; //最大点数  

struct DLX
{
    int n, m, si;//n行数m列数si目前有的节点数  
                 //十字链表组成部分  
    int U[MNN], D[MNN], L[MNN], R[MNN], Row[MNN], Col[MNN];
    //第i个结点的U向上指针D下L左R右，所在位置Row行Col列  
    int H[MN], S[MM]; //记录行的选择情况和列的覆盖情况  
    int ansd, ans[MN];
    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;
        si = m;                 //目前用了前0~m个结点  
        for (int i = 1; i <= n; i++)
            H[i] = -1;
    }
    void link(int r, int c)    //插入点(r,c)  
    {
        ++S[Col[++si] = c];     //si++;Col[si]=c;S[c]++;  
        Row[si] = r;//si该结点的行数为r
        D[si] = D[c];//向下指向c的下面的第一个结点
        U[D[c]] = si;//c的下面的第一个结点的上面为si
        U[si] = c;//si的上面为列指针
        D[c] = si;//列指针指向的第一个该列中的元素设为si
        if (H[r]<0)//如果第r行没有元素
            H[r] = L[si] = R[si] = si;
        else
        {
            R[si] = R[H[r]];//si的右边为行指针所指的右边第一个元素
            L[R[H[r]]] = si;//行指针所指的右边第一个元素的左侧为si
            L[si] = H[r];//si的左侧为行指针
            R[H[r]] = si;//行指针的右侧为si
        }
    }
    void remove(int c)        //列表中删掉c列  
    {
        //L[R[c]] = L[c];//表头操作  //c列头指针的右边的元素的左侧指向c列头指针左边的元素
        //R[L[c]] = R[c];//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]];//该元素所在的列数目减一
        //    }
        /*重复覆盖*//*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)//恢复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]];//D[U[j]]=j;U[D[j]]=j;S[Col[j]]++;
        //L[R[c]] = R[L[c]] = c;//c列头指针左右相连
        /*重复覆盖*/
        for (int i = U[c]; i != c; i = U[i])
        {
            L[R[i]] = R[L[i]] = i;
        }
    }


    bool vis[MNN];
    int f_check()//精确覆盖区估算剪枝  
    {
        /*
        强剪枝。这个 剪枝利用的思想是A*搜索中的估价函数。即，对于当前的递归深度K下的矩阵，估计其最好情况下（即最少还需要多少步）才能出解。也就是，如果将能够覆盖当 前列的所有行全部选中，去掉这些行能够覆盖到的列，将这个操作作为一层深度。重复此操作直到所有列全部出解的深度是多少。如果当前深度加上这个估价函数返 回值，其和已然不能更优（也就是已经超过当前最优解），则直接返回，不必再搜。
        */
        
        int ret = 0;
        for (int c = R[0]; c != 0; c = R[c]) vis[c] = true;
        for (int c = R[0]; c != 0; c = R[c])
            if (vis[c])
            {
                ret++;
                vis[c] = false;
                for (int i = D[c]; i != c; i = D[i])
                    for (int j = R[i]; j != i; j = R[j])
                        vis[Col[j]] = false;
            }
        return ret;
    }
    void dance(int d) //选取了d行
    {
        /*重复覆盖
        1、如果矩阵为空，得到结果，返回
        2、从矩阵中选择一列，以选取最少元素的列为优化方式
        3、删除该列及其覆盖的行
        4、对该列的每一行元素：删除一行及其覆盖的列，
        5、进行下一层搜索，如果成功则返回
        6、恢复现场，跳至4
        7、恢复所选择行
        */
        if (d + f_check() >=ansd)return;
        if (R[0] == 0)//全部覆盖了  
        {
            //全覆盖了之后的操作  
            if(ansd > d) ansd=d;
            return;
        }
        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];//记录该列元素的行
            remove(i);//新增(重复覆盖)
            for (int j = R[i]; j != i; j = R[j])
                remove(j);//remove(Col[j])(精确覆盖)
            dance(d + 1);
            for (int j = L[i]; j != i; j = L[j])
                resume(j);//resume(Col[j])(精确覆盖)
            resume(i);//新增(重复覆盖)
        }
        //resume(c);(精确覆盖)
    }
}dlx;
int mp[20][20];
int main()
{
    int n, m,n1,m1;
    while (~scanf("%d%d",&n,&m))
    {
        int cnt = 0;
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++)
            {
                scanf("%d", &mp[i][j]);
                if (mp[i][j]) mp[i][j] = ++cnt;
            }
        }
        scanf("%d%d", &n1, &m1);
        dlx.init(n*m,cnt);
        cnt = 1;
        for (int i = 1; i <=n; i++)
        {
            for (int j = 1; j <=m; j++)
            {
                for (int x = 0; x <n1&&i+x<=n; x++)
                {
                    for (int z = 0; z < m1&&z+j<=m; z++)
                    {
                        if (mp[i+x][j+z]) dlx.link(cnt, mp[i+x][j+z]);
                    }
                }
                cnt++;
            }
        }
        dlx.ansd = 0x3f3f3f3f;
        dlx.dance(0);
        printf("%d
", dlx.ansd);
    }
    return 0;
}

5、poj 1084 Square Destroyer

　　题意：给出由火柴构成的网格，现在在已经删去若干根火柴后，问最少还需要删去多少火柴，使得网格中的所有正方形被破坏。

　　思路：DLK重复覆盖，把每根火柴作为行，每个正方形看成列，如果某根火柴可以构成该正方形的一条边，则link.

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define N 60//55个格子
#define M 70//60个火柴
#define NN 300//每个格子4根火柴，算上辅助是5
#define inf 0x3f3f3f3f
using namespace std;
/*60火柴，25格*/
int ans;
struct DLX
{
    int U[NN], D[NN], L[NN], R[NN], C[NN];
    int H[M], T[N], cnt;
    inline void init()
    {
        cnt = 0;
        memset(U, 0, sizeof(U));
        memset(D, 0, sizeof(D));
        memset(L, 0, sizeof(L));
        memset(R, 0, sizeof(R));
        memset(C, 0, sizeof(C));
        memset(H, 0, sizeof(H));
        memset(T, 0, sizeof(T));
    }
    inline void newnode(int x, int y)
    {
        C[++cnt] = y; T[y]++;

        if (!H[x])H[x] = L[cnt] = R[cnt] = cnt;
        else L[cnt] = H[x], R[cnt] = R[H[x]];
        R[H[x]] = L[R[H[x]]] = cnt, H[x] = cnt;

        U[cnt] = U[y], D[cnt] = y;
        U[y] = D[U[y]] = cnt;
    }
    int id[N][N][5], eid[2][7][7];
    bool destroy[N], map[N][M];
    inline void build()
    {
        init();
        int i, j, k, n, m;
        int nmrx = 0, npon = 0;
        scanf("%d%d", &n, &m);
        memset(destroy, 0, sizeof(destroy));
        memset(map, 0, sizeof(map));
        for (k = 0; k<n; k++)for (i = 1; i + k <= n; i++)for (j = 1; j + k <= n; j++)id[k][i][j] = ++nmrx;
        for (i = 1; i <= n; i++)
        {
            for (j = 1; j <= n; j++)eid[0][i][j] = ++npon;
            for (j = 1; j <= n + 1; j++)eid[1][i][j] = ++npon;
        }
        for (i = 1; i <= n; i++)eid[0][n + 1][i] = ++npon;
        for (k = 0; k<n; k++)
            for (i = 1; i + k <= n; i++)
                for (j = 1; j + k <= n; j++)
                {
                    int A = id[k][i][j], temp;
                    for (temp = j; temp <= j + k; temp++)map[A][eid[0][i][temp]] = map[A][eid[0][i + k + 1][temp]] = 1;
                    for (temp = i; temp <= i + k; temp++)map[A][eid[1][temp][j]] = map[A][eid[1][temp][j + k + 1]] = 1;
                }
        for (i = 1; i <= m; i++)
        {
            scanf("%d", &k);
            for (j = 1; j <= nmrx; j++)if (map[j][k])destroy[j] = 1;
        }
        for (i = 1; i <= nmrx; i++)if (!destroy[i])
        {
            U[i] = D[i] = i;
            L[i] = L[0], R[i] = 0;
            L[0] = R[L[0]] = i;
        }
        cnt = nmrx;
        for (i = 1; i <= nmrx; i++)
            if (!destroy[i])
                for (j = 1; j <= npon; j++)
                    if (map[i][j])
                        newnode(j, i);
    }
    inline void remove(int x)
    {
        int i = x;
        do
        {
            R[L[i]] = R[i];
            L[R[i]] = L[i];
            i = D[i];
        } while (i != x);
    }
    inline void resume(int x)
    {
        int i = x;
        do
        {
            R[L[i]] = i;
            L[R[i]] = i;
            i = U[i];
        } while (i != x);
    }
    inline void dfs(int x)
    {
        if (x >= ans)return;
        if (!R[0])
        {
            ans = x;
            return;
        }
        int S = R[0], W = T[S], i, j;
        int del[N], num;
        for (i = R[S]; i; i = R[i])if (T[i]<W)
        {
            W = T[i];
            S = i;
        }
        remove(S);
        for (i = D[S]; i != S; i = D[i])
        {
            del[num = 1] = R[i];
            for (j = R[R[i]]; j != R[i]; j = R[j])del[++num] = j;
            for (j = 1; j <= num; j++)remove(del[j]);
            dfs(x + 1);
            for (j = num; j; j--)resume(del[j]);
        }
        resume(S);
        return;
    }
}dlx;
int main()
{
    int g;
    scanf("%d", &g);
    while (g--)
    {
        ans = inf;
        dlx.build();
        dlx.dfs(0);
        printf("%d
", ans);
    }
    return 0;
}

 6、poj 3074 Sudoku

　　题意：解9*9的数独。

　　思路：主要建图，每个不确定格子至多可以填9种数字，一共9*9*9行，对于每个格子，其自身、所在行、所在列、所在块均存在约束，共9*9*4列。

#include <iostream>  
#include <stdio.h>  
#include <string.h>  
//精确覆盖问题的定义：给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1
const int MN = 9*9*9+10;//最大行数,共有9*9个格子，每个格子可以放1~9
const int MM = 9*9+9*9+9*9+9*9+100;//最大列数
//用第(i - 1) * 9 + j列为1表示i行j列的已经填数。一共占用81列。
//用81 + (i - 1) * 9 + v列表示第i行已经有v这个值。一共占用81列。
//用162 + (j - 1) * 9 + v列表示第j列已经有v这个值。一共占用81列。
//用243 + (3 * ((i - 1) / 3) + (j + 2) / 3 - 1) + v列表示第3*((i - 1) / 3) + (j + 2) / 3宫格已经有v这个值。一共占用81列。
const int MNN = MN*MM; //最大点数  

struct DLX
{
    int n, m, si;//n行数m列数si目前有的节点数  
                 //十字链表组成部分  
    int U[MNN], D[MNN], L[MNN], R[MNN], Row[MNN], Col[MNN];
    //第i个结点的U向上指针D下L左R右，所在位置Row行Col列  
    int H[MN], S[MM]; //记录行的选择情况和列的覆盖情况  
    int ansd, ans[MN];
    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;
        si = m;                 //目前用了前0~m个结点  
        for (int i = 1; i <= n; i++)
            H[i] = -1;
    }
    void link(int r, int c)    //插入点(r,c)  
    {
        ++S[Col[++si] = c];     //si++;Col[si]=c;S[c]++;  
        Row[si] = r;//si该结点的行数为r
        D[si] = D[c];//向下指向c的下面的第一个结点
        U[D[c]] = si;//c的下面的第一个结点的上面为si
        U[si] = c;//si的上面为列指针
        D[c] = si;//列指针指向的第一个该列中的元素设为si
        if (H[r]<0)//如果第r行没有元素
            H[r] = L[si] = R[si] = si;
        else
        {
            R[si] = R[H[r]];//si的右边为行指针所指的右边第一个元素
            L[R[H[r]]] = si;//行指针所指的右边第一个元素的左侧为si
            L[si] = H[r];//si的左侧为行指针
            R[H[r]] = si;//行指针的右侧为si
        }
    }
    void remove(int c)        //列表中删掉c列  
    {
        L[R[c]] = L[c];//表头操作  //c列头指针的右边的元素的左侧指向c列头指针左边的元素
        R[L[c]] = R[c];//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)        //恢复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]];//D[U[j]]=j;U[D[j]]=j;S[Col[j]]++;
        L[R[c]] = R[L[c]] = c;//c列头指针左右相连
    }
    bool dance(int d) //选取了d行  
    {
        if (R[0] == 0)//全部覆盖了  
        {
            //全覆盖了之后的操作  
            ansd = d;
            return 1;
        }
        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 1;
            for (int j = L[i]; j != i; j = L[j])
                resume(Col[j]);
        }
        resume(c);
        return 0;
    }
}dlx;
char s[90],path[90];
struct node
{
    int r, c, v;
}nds[MN];
int main()
{
    while (~scanf("%s",s))
    {
        if (s[0] == 'e')break;
        dlx.init(9*9*9,9*9*4);
        int r=1;
        for (int i = 1; i <= 9; i++)
        {
            for (int j = 1; j <= 9; j++)
            {
                if (s[(i - 1) * 9 + j - 1] == '.')
                {
                    for (int z = 1; z <= 9; z++)
                    {
                        dlx.link(r, (i - 1) * 9 + j);
                        dlx.link(r, 81 + (i - 1) * 9 + z);
                        dlx.link(r, 162 + (j - 1) * 9 + z);
                        dlx.link(r, 243 + (((i - 1) / 3) * 3 + (j + 2) / 3 - 1) * 9 + z);
                        nds[r].r = i, nds[r].c = j, nds[r].v = z;
                        r++;
                    }
                }
                else
                {
                    int z = s[(i - 1) * 9 + j - 1] - '0';
                    dlx.link(r, (i - 1) * 9 + j);
                    dlx.link(r, 81 + (i - 1) * 9 + z);
                    dlx.link(r, 162 + (j - 1) * 9 + z);
                    dlx.link(r, 243 + (((i - 1) / 3) * 3 + (j + 2) / 3 - 1) * 9 + z);
                    nds[r].r = i, nds[r].c = j, nds[r].v = z;
                    r++;
                }
            }
        }
        dlx.ansd = -1;
        dlx.dance(0);
        int deep = dlx.ansd;
        for (int i = 0; i < deep; i++)
        {
            int posr = dlx.ans[i];
            path[(nds[posr].r - 1) * 9 + nds[posr].c - 1] = '0' + nds[posr].v;
        }
        path[deep] = '';
        printf("%s
", path);
    }
    return 0;
}
/*
.2738..1..1...6735.......293.5692.8...........6.1745.364.......9518...7..8..6534.
......52..8.4......3...9...5.1...6..2..7........3.....6...1..........7.4.......3.
end
*/

7、POJ 3076 Sudoku

　　题意：解16*16的数独。

　　思路：和上题近似，不过维数从9变为16.

#include <iostream>  
#include <stdio.h>  
#include <string.h>  
//精确覆盖问题的定义：给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1
const int MN = 16*16*16 + 10;//最大行数,共有16*16个格子，每个格子可以放1~16（A~P）
const int MM = 16*16*4 + 100;//最大列数
const int MNN = MN*MM;//最大点数  

struct DLX
{
    int n, m, si;//n行数m列数si目前有的节点数  
                 //十字链表组成部分  
    int U[MNN], D[MNN], L[MNN], R[MNN], Row[MNN], Col[MNN];
    //第i个结点的U向上指针D下L左R右，所在位置Row行Col列  
    int H[MN], S[MM]; //记录行的选择情况和列的覆盖情况  
    int ansd, ans[MN];
    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;
        si = m;                 //目前用了前0~m个结点  
        for (int i = 1; i <= n; i++)
            H[i] = -1;
    }
    void link(int r, int c)    //插入点(r,c)  
    {
        ++S[Col[++si] = c];     //si++;Col[si]=c;S[c]++;  
        Row[si] = r;//si该结点的行数为r
        D[si] = D[c];//向下指向c的下面的第一个结点
        U[D[c]] = si;//c的下面的第一个结点的上面为si
        U[si] = c;//si的上面为列指针
        D[c] = si;//列指针指向的第一个该列中的元素设为si
        if (H[r]<0)//如果第r行没有元素
            H[r] = L[si] = R[si] = si;
        else
        {
            R[si] = R[H[r]];//si的右边为行指针所指的右边第一个元素
            L[R[H[r]]] = si;//行指针所指的右边第一个元素的左侧为si
            L[si] = H[r];//si的左侧为行指针
            R[H[r]] = si;//行指针的右侧为si
        }
    }
    void remove(int c)        //列表中删掉c列  
    {
        L[R[c]] = L[c];//表头操作  //c列头指针的右边的元素的左侧指向c列头指针左边的元素
        R[L[c]] = R[c];//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)        //恢复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]];//D[U[j]]=j;U[D[j]]=j;S[Col[j]]++;
        L[R[c]] = R[L[c]] = c;//c列头指针左右相连
    }
    bool dance(int d) //选取了d行  
    {
        if (R[0] == 0)//全部覆盖了  
        {
            //全覆盖了之后的操作  
            ansd = d;
            return 1;
        }
        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 1;
            for (int j = L[i]; j != i; j = L[j])
                resume(Col[j]);
        }
        resume(c);
        return 0;
    }
}dlx;
char s[20];
char path[16 * 16 + 10];
struct node
{
    int r, c, v;
}nds[MN];
void addlink(int r, int c, int v, int& cnt)
{
    dlx.link(cnt, (r - 1) * 16 + c);
    dlx.link(cnt, 16*16 + (r - 1) * 16 + v);
    dlx.link(cnt, 16*16*2 + (c - 1) * 16 + v);
    dlx.link(cnt, 16*16*3 + (((r-1)/4)*4+(c-1)/4) * 16 + v);
    nds[cnt].r = r, nds[cnt].c = c, nds[cnt].v = v;
    cnt++;
}
int main()
{
    while (~scanf("%s", s))
    {
        
        dlx.init(16*16*16, 16 * 16 * 4);
        int r = 1;
        for (int i = 0; i < 16; i++)
        {
            if (s[i] == '-')
            {
                for (int k = 1; k <= 16; k++)
                {
                    addlink(1, i + 1, k,r);
                }
            }
            else
            {
                int v = s[i] - 'A' + 1;
                addlink(1, i + 1, v, r);
            }
        }
        for (int i = 2; i <= 16; i++)
        {
            scanf("%s", s);
            for (int j = 1; j <= 16; j++)
            {
                if (s[j-1] == '-')
                {
                    for (int k = 1; k <= 16; k++)
                    {
                        addlink(i, j, k, r);
                    }
                }
                else
                {
                    int v = s[j-1] - 'A' + 1;
                    addlink(i,j, v, r);
                }
            }
        }
        dlx.ansd = -1;
        dlx.dance(0);
        int deep = dlx.ansd;
        for (int i = 0; i < deep; i++)
        {
            int posr = dlx.ans[i];
            path[(nds[posr].r - 1) * 16 + nds[posr].c - 1] = 'A' + nds[posr].v-1;
        }
        path[deep] = '';
        for (int i = 0; i < 16; i++)
        {
            for (int j = 0; j < 16; j++) printf("%c", path[i * 16 + j]);
            printf("
");
        }
        printf("
");
    }
    return 0;
}

8、hdu 4069 Squiggly Sudoku

　　题意：解9*9的数独，不过每一块的形状不一定是矩形。

　　思路：先用DFS分块，然后思路和6相同。

#include <iostream>  
#include <stdio.h>  
#include <string.h>  
//精确覆盖问题的定义：给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1
const int MN = 9 * 9 * 9 + 10;//最大行数,共有9*9个格子，每个格子可以放1~9
const int MM = 9 * 9 + 9 * 9 + 9 * 9 + 9 * 9 + 100;//最大列数
                                                   //用第(i - 1) * 9 + j列为1表示i行j列的已经填数。一共占用81列。
                                                   //用81 + (i - 1) * 9 + v列表示第i行已经有v这个值。一共占用81列。
                                                   //用162 + (j - 1) * 9 + v列表示第j列已经有v这个值。一共占用81列。
                                                   //用243 + (3 * ((i - 1) / 3) + (j + 2) / 3 - 1) + v列表示第3*((i - 1) / 3) + (j + 2) / 3宫格已经有v这个值。一共占用81列。
const int MNN = MN*MM; //最大点数  
int Count;//几种解决方案
bool iscontinue;//当找到两种及以上解决方案时退出
struct DLX
{
    int n, m, si;//n行数m列数si目前有的节点数  
                 //十字链表组成部分  
    int U[MNN], D[MNN], L[MNN], R[MNN], Row[MNN], Col[MNN];
    //第i个结点的U向上指针D下L左R右，所在位置Row行Col列  
    int H[MN], S[MM]; //记录行的选择情况和列的覆盖情况  
    int ansd, ans[MN];
    int tans[MN];//保存第一个解决方案
    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;
        si = m;                 //目前用了前0~m个结点  
        for (int i = 1; i <= n; i++)
            H[i] = -1;
    }
    void link(int r, int c)    //插入点(r,c)  
    {
        ++S[Col[++si] = c];     //si++;Col[si]=c;S[c]++;  
        Row[si] = r;//si该结点的行数为r
        D[si] = D[c];//向下指向c的下面的第一个结点
        U[D[c]] = si;//c的下面的第一个结点的上面为si
        U[si] = c;//si的上面为列指针
        D[c] = si;//列指针指向的第一个该列中的元素设为si
        if (H[r]<0)//如果第r行没有元素
            H[r] = L[si] = R[si] = si;
        else
        {
            R[si] = R[H[r]];//si的右边为行指针所指的右边第一个元素
            L[R[H[r]]] = si;//行指针所指的右边第一个元素的左侧为si
            L[si] = H[r];//si的左侧为行指针
            R[H[r]] = si;//行指针的右侧为si
        }
    }
    void remove(int c)        //列表中删掉c列  
    {
        L[R[c]] = L[c];//表头操作  //c列头指针的右边的元素的左侧指向c列头指针左边的元素
        R[L[c]] = R[c];//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)        //恢复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]];//D[U[j]]=j;U[D[j]]=j;S[Col[j]]++;
        L[R[c]] = R[L[c]] = c;//c列头指针左右相连
    }
    void dance(int d) //选取了d行  
    {
        if (!iscontinue) return;
        if (R[0] == 0)//全部覆盖了  
        {
            //全覆盖了之后的操作  
            ansd = d;
            if (Count == 0)
            {
                memcpy(tans, ans, sizeof(ans));
                Count++;
            }
            else if (Count == 1) iscontinue = false;
            return;
        }
        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]);//将该列的某个元素的行上的元素所在的列都删去
            dance(d + 1);
            for (int j = L[i]; j != i; j = L[j])
                resume(Col[j]);
        }
        resume(c);
        return ;
    }
}dlx;
struct node
{
    int r, c, v;
}nds[MN];
int dr[] = { 0,0,1,-1 };
int dc[] = { 1,-1,0,0 };
int mp[10][10];//记录值
bool wall[10][10][2][2];//记录某个点上下左右是否有墙
//[0][0]左，[0][1]右，[1][0]上，[1][1]下
int block[10][10];//标记分块
int solution[10][10];
void DFS(int r, int c, int flag)
{
    block[r][c] = flag;
    if (!wall[r][c][0][0]&&!block[r][c-1]) DFS(r, c - 1, flag);
    if (!wall[r][c][0][1]&&!block[r][c+1]) DFS(r, c + 1, flag);
    if (!wall[r][c][1][0]&&!block[r-1][c]) DFS(r - 1, c, flag);
    if (!wall[r][c][1][1]&&!block[r+1][c]) DFS(r + 1, c, flag);
}
int main()
{
    int t,Case=1;
    scanf("%d", &t);
    while (t--)
    {
        int num;
        memset(mp, 0, sizeof(mp));
        memset(wall, 0, sizeof(wall));
        memset(block, 0, sizeof(block));
        for (int i = 1; i <= 9; i++)
        {
            for (int j = 1; j <= 9; j++)
            {
                scanf("%d", &num);
                if (num - 128 >= 0) num -= 128, wall[i][j][0][0] = true;
                if (num - 64 >= 0) num -= 64, wall[i][j][1][1] = true;
                if (num - 32 >= 0) num -= 32, wall[i][j][0][1] = true;
                if (num - 16 >= 0) num -= 16, wall[i][j][1][0] = true;
                mp[i][j] = num;
            }
        }
        int id = 0;
        for (int i = 1; i <= 9; i++)
        {
            for (int j = 1; j <= 9; j++)
            {
                if (!block[i][j])
                {
                    DFS(i, j, ++id);
                }
            }
        }
        dlx.init(9 * 9 * 9, 9 * 9 * 4);
        int Cnt = 1;
        for (int i = 1; i <= 9; i++)
        {
            for (int j = 1; j <= 9; j++)
            {
                if (mp[i][j]==0)
                {
                    for (int z = 1; z <= 9; z++)
                    {
                        dlx.link(Cnt, (i - 1) * 9 + j);
                        dlx.link(Cnt, 81 + (i - 1) * 9 + z);
                        dlx.link(Cnt, 162 + (j - 1) * 9 + z);
                        dlx.link(Cnt, 243 + (block[i][j]-1) * 9 + z);
                        nds[Cnt].r = i, nds[Cnt].c = j, nds[Cnt].v = z;
                        Cnt++;
                    }
                }
                else
                {
                    int z =mp[i][j];
                    dlx.link(Cnt, (i - 1) * 9 + j);
                    dlx.link(Cnt, 81 + (i - 1) * 9 + z);
                    dlx.link(Cnt, 162 + (j - 1) * 9 + z);
                    dlx.link(Cnt, 243 + (block[i][j]-1) * 9 + z);
                    nds[Cnt].r = i, nds[Cnt].c = j, nds[Cnt].v = z;
                    Cnt++;
                }
            }
        }
        dlx.ansd = -1;
        iscontinue = true;
        Count = 0;
        dlx.dance(0);
        printf("Case %d:
", Case++);
        if (Count == 0)
        {
            printf("No solution
");
            continue;
        }
        else if (!iscontinue)
        {
            printf("Multiple Solutions
");
            continue;
        }
        int deep = dlx.ansd;
        for (int i = 0; i < deep; i++)
        {
            int posr = dlx.tans[i];
            solution[nds[posr].r][nds[posr].c] = nds[posr].v;
        }
        for (int i = 1; i <= 9; i++)
        {
            for (int j = 1; j <= 9; j++)
            {
                printf("%d", solution[i][j]);
            }
            printf("
");
        }
    }
    return 0;
}

 9、hdu 3335 Divisibility

　　题意：给出n个数，每次从中取出一个数后，不能再取它的倍数或其因子。问最多能取多少个数，

　　思路：DLK求极大重复覆盖(因为一个数可能是若干个数的倍数，所以用重复覆盖)。当一个数为另一个数的因子或倍数时，建边。

#include <iostream>  
#include <stdio.h>  
#include <string.h>  
//重复覆盖：找到一些行，使得这些行的集合中每列至少有一个1
const int MN = 1010;//最大行数
const int MM = 1010;//最大列数
const int MNN = MM*MN + MM + MN + 10; //最大点数  

struct DLX
{
    int n, m, si;//n行数m列数si目前有的节点数  
                 //十字链表组成部分  
    int U[MNN], D[MNN], L[MNN], R[MNN], Row[MNN], Col[MNN];
    //第i个结点的U向上指针D下L左R右，所在位置Row行Col列  
    int H[MN], S[MM]; //记录行的选择情况和列的覆盖情况  
    int ansd, ans[MN];
    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;
        si = m;                 //目前用了前0~m个结点  
        for (int i = 1; i <= n; i++)
            H[i] = -1;
    }
    void link(int r, int c)    //插入点(r,c)  
    {
        ++S[Col[++si] = c];     //si++;Col[si]=c;S[c]++;  
        Row[si] = r;//si该结点的行数为r
        D[si] = D[c];//向下指向c的下面的第一个结点
        U[D[c]] = si;//c的下面的第一个结点的上面为si
        U[si] = c;//si的上面为列指针
        D[c] = si;//列指针指向的第一个该列中的元素设为si
        if (H[r]<0)//如果第r行没有元素
            H[r] = L[si] = R[si] = si;
        else
        {
            R[si] = R[H[r]];//si的右边为行指针所指的右边第一个元素
            L[R[H[r]]] = si;//行指针所指的右边第一个元素的左侧为si
            L[si] = H[r];//si的左侧为行指针
            R[H[r]] = si;//行指针的右侧为si
        }
    }
    void remove(int c)        //列表中删掉c列  
    {
        //L[R[c]] = L[c];//表头操作  //c列头指针的右边的元素的左侧指向c列头指针左边的元素
        //R[L[c]] = R[c];//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]];//该元素所在的列数目减一
        //    }
        /*重复覆盖*//*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)//恢复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]];//D[U[j]]=j;U[D[j]]=j;S[Col[j]]++;
        //L[R[c]] = R[L[c]] = c;//c列头指针左右相连
        /*重复覆盖*/
        for (int i = U[c]; i != c; i = U[i])
        {
            L[R[i]] = R[L[i]] = i;
        }
    }
    int f_check()//精确覆盖区估算剪枝  
    {
        /*
        强剪枝。这个 剪枝利用的思想是A*搜索中的估价函数。即，对于当前的递归深度K下的矩阵，估计其最好情况下（即最少还需要多少步）才能出解。也就是，如果将能够覆盖当 前列的所有行全部选中，去掉这些行能够覆盖到的列，将这个操作作为一层深度。重复此操作直到所有列全部出解的深度是多少。如果当前深度加上这个估价函数返 回值，其和已然不能更优（也就是已经超过当前最优解），则直接返回，不必再搜。
        */
        int vis[MNN];
        memset(vis, 0, sizeof(vis));
        int ret = 0;
        for (int c = R[0]; c != 0; c = R[c]) vis[c] = true;
        for (int c = R[0]; c != 0; c = R[c])
            if (vis[c])
            {
                ret++;
                vis[c] = false;
                for (int i = D[c]; i != c; i = D[i])
                    for (int j = R[i]; j != i; j = R[j])
                        vis[Col[j]] = false;
            }
        return ret;
    }
    void dance(int d) //选取了d行,limit为限制选取的最大行数
    {
        /*重复覆盖
        1、如果矩阵为空，得到结果，返回
        2、从矩阵中选择一列，以选取最少元素的列为优化方式
        3、删除该列及其覆盖的行
        4、对该列的每一行元素：删除一行及其覆盖的列，
        5、进行下一层搜索，如果成功则返回
        6、恢复现场，跳至4
        7、恢复所选择行
        */
        //if (ansd!=-1&&d > ansd)return;
        //if (ansd!=-1&&d + f_check() >ansd)return;
        if (R[0] == 0)//全部覆盖了  
        {
            //全覆盖了之后的操作  
            if(ansd==-1)ansd = d;
            else if (d > ansd) ansd = d;
        }
        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];//记录该列元素的行
            remove(i);//新增(重复覆盖)
            for (int j = R[i]; j != i; j = R[j])
                remove(j);//remove(Col[j])(精确覆盖)
            dance(d + 1);
            for (int j = L[i]; j != i; j = L[j])
                resume(j);//resume(Col[j])(精确覆盖)
            resume(i);//新增(重复覆盖)
        }
        //resume(c);(精确覆盖)
        return;
    }
}dlx;
long long num[1010];
int main()
{
    int n;
    int t;
    scanf("%d", &t);

    while (t--)
    {
        scanf("%d", &n);
        for (int i = 1; i <= n; i++)
        {
            scanf("%lld", &num[i]);
        }
        dlx.init(n, n);
        for (int i = 1; i <=n; i++)
        {
            for (int j = 1; j <= n; j++) if (num[i] % num[j] == 0||num[j]%num[i]==0) dlx.link(i, j);
        }
        dlx.ansd = -1;
        dlx.dance(0);
        printf("%d
",dlx.ansd);
    }
    return 0;
}

　　拓展：二分图求最大独立集(选最多的数使得两两之间不能整除)。最大独立集 = 点数 - 二分图最大匹配。

#include<iostream>
#include<queue>
#include<memory.h>
#include<algorithm>
#include<cmath>
using namespace std;
int n,dis,Ny,Nx;
const int maxn = 1010;//最大行数
const int maxm = 1010;//最大列数
const int maxk = 1010;
const int INF = 0x7fffffff;
bool mp[maxk][maxk];//1表示该ij可以匹配
int cx[maxk];//记录x集合中匹配的y元素是哪一个
int dx[maxk];
int cy[maxk];//记录y集合中匹配的x元素是哪一个
int dy[maxk];
int vis[maxk];//标记该顶点是否访问过
bool searchP(void)    //BFS   
{
    queue <int> Q;
    dis = INF;
    memset(dx, -1, sizeof(dx));
    memset(dy, -1, sizeof(dy));
    for (int i = 1; i <= Nx; i++)
        if (cx[i] == -1)
        {
            Q.push(i); dx[i] = 0;
        }
    while (!Q.empty())
    {
        int u = Q.front(); Q.pop();
        if (dx[u] > dis) break;        //说明该增广路径长度大于dis还没有结束，等待下一次BFS在扩充  
        for (int v = 1; v <= Ny; v++)
            if (mp[u][v] && dy[v] == -1)
            {        //v是未匹配点  
                dy[v] = dx[u] + 1;
                if (cy[v] == -1) dis = dy[v];    //得到本次BFS的最大遍历层次  
                else
                {
                    dx[cy[v]] = dy[v] + 1;         //v是匹配点，继续延伸  
                    Q.push(cy[v]);
                }
            }
    }
    return dis != INF;
}

bool DFS(int u)
{
    for (int v = 1; v <= Ny; v++)
        if (!vis[v] && mp[u][v] && dy[v] == dx[u] + 1)
        {
            vis[v] = 1;
            if (cy[v] != -1 && dy[v] == dis) continue;   //层次（也就是增广路径的长度）大于本次查找的dis，是searchP被break的情况，也就是还不确定是否是增广路径，只有等再次调用searchP()在判断。  
            if (cy[v] == -1 || DFS(cy[v]))
            {     //是增广路径，更新匹配集  
                cy[v] = u; cx[u] = v;
                return 1;
            }
        }
    return 0;
}

int MaxMatch()
{
    int res = 0;
    memset(cx, -1, sizeof(cx));
    memset(cy, -1, sizeof(cy));
    while (searchP())
    {
        memset(vis, 0, sizeof(vis));
        for (int i = 1; i <= Nx; i++)
            if (cx[i] == -1 && DFS(i)) res++;   //查找到一个增广路径，匹配数res++  
    }
    return res;
}
long long num[1010];
int main()
{
    int C;
    scanf("%d", &C);
    int Case = 1;
    while (C--)
    {
        scanf("%d", &n);
        for (int i = 1; i <= n; i++) scanf("%lld", &num[i]);
        sort(num + 1, num + 1 + n);
        memset(mp, 0, sizeof(mp));
        for (int i = 1; i <= n; i++)
        {
            for (int j = i+1; j <=n; j++) if (num[j] % num[i] == 0) mp[j][i] = 1;
        }

        Nx = n, Ny =n;
        int ans = MaxMatch();
        printf("%d
", n - ans);//无向二分图：最小路径覆盖数 = "拆点"前原图的顶点数 - 最大匹配数/2  
    }
    return 0;
}