dancing link模板

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iomanip> 
using namespace std;

const int n=729,m=324;
bool mx[2000][2000];//数独转化过来的01矩阵 
int map[10][10],cnt[2000],head,cur,ans;
int sqr[10][10]={{0,0,0,0,0,0,0,0,0,0},  //九宫格的编号 
               {0,1,1,1,4,4,4,7,7,7},
               {0,1,1,1,4,4,4,7,7,7},
               {0,1,1,1,4,4,4,7,7,7},
               {0,2,2,2,5,5,5,8,8,8},
               {0,2,2,2,5,5,5,8,8,8},
               {0,2,2,2,5,5,5,8,8,8},
               {0,3,3,3,6,6,6,9,9,9},
               {0,3,3,3,6,6,6,9,9,9},
               {0,3,3,3,6,6,6,9,9,9}};

int w[10][10]={{0,0,0,0,0,0,0,0,0,0},
               {0,6,6,6,6,6,6,6,6,6},
               {0,6,7,7,7,7,7,7,7,6},
               {0,6,7,8,8,8,8,8,7,6},
               {0,6,7,8,9,9,9,8,7,6},
               {0,6,7,8,9,10,9,8,7,6},
               {0,6,7,8,9,9,9,8,7,6},
               {0,6,7,8,8,8,8,8,7,6},
               {0,6,7,7,7,7,7,7,7,6},
               {0,6,6,6,6,6,6,6,6,6}};
               
struct point
{
    int row,lc,rc,up,down,col;//元素的上下左右，行号和列标 
}node[2000*2000];

inline int id(int x,int y)
{
    return (x-1)*9+y;//格子（x，y）的编号 
}

void init(int c)//初始化列标元素 
{
    for (int i=0;i<=c;i++)
    {
        node[i].lc=i-1;
        node[i].rc=i+1;
        node[i].up=node[i].down=node[i].col=i;
    }
    node[0].lc=c;
    node[c].rc=0;
}

void build_link()//把01矩阵中的 1 用dancing link 连接 
{
    cur=m;
    for (int i=1;i<=n;i++)
    {
        int start,pre;
        start=pre=cur+1;
        for (int j=1;j<=m;j++)
            if (mx[i][j])
            {
                cur++;
                cnt[j]++;
                node[cur].row=i;
                
                node[cur].lc=pre;
                node[cur].rc=start;
                node[pre].rc=cur;
                node[start].lc=cur;
                
                node[cur].col=j;
                node[cur].up=node[j].up;
                node[cur].down=j;
                node[node[j].up].down=cur;
                node[j].up=cur;
                pre=cur;
            }
    }
}

inline void cover(int c)//删除冲突元素 
{
    for (int i=node[c].up;i!=c;i=node[i].up)
        for (int j=node[i].rc;j!=i;j=node[j].rc)
        {
            node[node[j].up].down=node[j].down;
            node[node[j].down].up=node[j].up;
            cnt[node[j].col]--;
        }
    node[node[c].lc].rc=node[c].rc;
    node[node[c].rc].lc=node[c].lc;
}

inline void uncover(int c)//恢复冲突元素 
{
    for (int i=node[c].up;i!=c;i=node[i].up)
        for (int j=node[i].rc;j!=i;j=node[j].rc)
        {
            node[node[j].up].down=j;
            node[node[j].down].up=j;
            cnt[node[j].col]++;
        }
    node[node[c].lc].rc=c;
    node[node[c].rc].lc=c;
}

void read_data()//把数独转化成01矩阵 
{
    for (int i=1;i<=9;i++)
        for (int j=1;j<=9;j++)
        {
            scanf("%d",&map[i][j]);
            int c=id(i,j),t,k;
            if (map[i][j])//数独中本来有数，直接加入 
            {
                k=map[i][j];
                t=(c-1)*9+k;
                mx[t][c]=true;
                mx[t][81+9*(i-1)+k]=true;
                mx[t][162+9*(j-1)+k]=true;
                mx[t][243+(sqr[i][j]-1)*9+k]=true;
            }
            else 
            {
                for (k=1;k<=9;k++) //数独中本来没数，那么加入1-9的情况 
                {
                    t=(c-1)*9+k;
                    mx[t][c]=true;
                    mx[t][81+9*(i-1)+k]=true;
                    mx[t][162+9*(j-1)+k]=true;
                    mx[t][243+(sqr[i][j]-1)*9+k]=true;
                }
            }
        }
}

bool dfs(int step,int score)
{
    if (node[head].rc==head) //已经全部覆盖 
    {
        ans=max(score,ans);
        return true;
    }
    
    int i,j,c,t=210000,x,y,num,flag=0;
    for (i=node[head].rc;i!=head;i=node[i].rc) //启发式，每次处理元素最少的列 
        if (cnt[i]<t)
        {
            t=cnt[i];
            c=i;
        }
    if (t==0)
        return false;
        
    cover(c);//覆盖当前列 
    
    for (i=node[c].down;i!=c;i=node[i].down)
    {
        for (j=node[i].lc;j!=i;j=node[j].lc)//删除冲突的行 
            cover(node[j].col);
        num=(node[i].row-1)/9+1;
        x=(num-1)/9+1;
        y=num-9*(x-1);
        flag|=dfs(step+1,score+w[x][y]*(node[i].row-(num-1)*9));
        for (j=node[i].rc;j!=i;j=node[j].rc)//恢复删除冲突的行 
            uncover(node[j].col);
    }
    
    uncover(c);//恢复当前列 
    return flag;
}

void solve()
{
    init(m);
    build_link();
    int flag=1;
    if (!dfs(1,0))
        printf("-1\n");
    else printf("%d\n",ans);
}

int main()
{
    read_data();
    solve();
    return 0;
}