HDU 3111 Sudoku ( Dancing Links 精确覆盖模型 )

推荐两篇学DLX的博文：

http://bbs.9ria.com/thread-130295-1-1.html（这篇对DLX的工作过程演示的很详细）

http://yzmduncan.iteye.com/blog/1151695（这篇对精确覆盖与重复覆盖解释的简洁清晰，模板来自这篇博文）

以下转载：

DLX解决9*9的数独问题，转化为729*324的精确覆盖问题 

行：一共9 * 9 * 9 == 729行。一共9 * 9小格，每一格有9种可能性(1 - 9)，每一种可能都对应着一行。 

列： 一共(9 + 9 + 9) * 9 + 81 == 324 种前面三个9分别代表着9行9列和9小块，乘以9的意思是9种可能(1 - 9)，因为每种可能只可以选择一个。 81代表着81个小格，限制着每一个小格只放一个数字。 

读入数据后，如果为'.'，则建9行，即有1-9种可能，否则建一行，表示某小格只能放确定的某个数字。 

以下个人理解：

列： 一共(9 + 9 + 9) * 9 + 81 == 324 种

对于这个（9+9+9）*9 我是这么理解的：一个数a，它在某一行有9个位置可以放，在某一列有9个位置可以放，在某一个3×3小格中有9个位置可以放，所以一共可以放的位置是（9+9+9）个，然后一共9个数字，所以是（9+9+9）*9 。

不知道这样理解是否正确，望大家指教！

 

#include <cstdio>

#include <cstring>

#include <cstdlib>

#include <algorithm>



using namespace std;



const int INF = 1 << 30;

const int SZ = 9;

const int MAXR = SZ * SZ * SZ;

const int MAXC = ( SZ+SZ+SZ )*SZ + SZ*SZ;



char mat[SZ+10][SZ+10];

char str[SZ+10];

bool maxtri[MAXR+40][MAXC+40];    //01矩阵

int C[(MAXR+40)*(MAXC+40)], cnt[MAXC+40];

int U[(MAXR+40)*(MAXC+40)], D[(MAXR+40)*(MAXC+40)];

int L[(MAXR+40)*(MAXC+40)], R[(MAXR+40)*(MAXC+40)];

int head;

int ans[MAXR+40];

int val[SZ+10][SZ+10];



void Remove( int c )

{

    int i, j;

    L[ R[c] ] = L[c];

    R[ L[c] ] = R[c];

    for ( i = D[c]; i != c; i = D[i] )

    {

        for ( j = R[i]; j != i; j = R[j] )

        {

            U[ D[j] ] = U[j];

            D[ U[j] ] = D[j];

            --cnt[ C[j] ];

        }

    }

    return;

}



void Resume( int c )

{

    int i, j;

    R[ L[c] ] = c;

    L[ R[c] ] = c;

    for ( i = D[c]; i != c; i = D[i] )

    {

        for ( j = R[i]; j != i; j = R[j] )

        {

            U[ D[j] ] = j;

            D[ U[j] ] = j;

            ++cnt[ C[j] ];

        }

    }

    return;

}



bool DFS( int cur )

{

    int i, j, c, minv;

    if ( R[head] == head )

        return true;



    minv = INF;

    for ( i = R[head]; i != head; i = R[i] )

    {

        if ( cnt[i] < minv )

        {

            minv = cnt[i];

            c = i;

        }

    }



    Remove(c);

    for ( i = D[c]; i != c; i = D[i] )

    {

        ans[cur] = (i - 1)/MAXC;

        for( j = R[i]; j != i; j = R[j] )

            Remove( C[j] );



        if ( DFS( cur + 1 ) ) return true;



        for( j = R[i]; j != i; j = R[j] )

            Resume( C[j] );

    }



    Resume(c);

    return false;

}



bool build()

{

    int i, j, cur, pre, first;

    head = 0;

    for ( i = 0; i < MAXC; ++i )

    {

        R[i] = i + 1;

        L[i + 1] = i;

    }

    R[ MAXC ] = 0;

    L[0] = MAXC;



    //列双向链表

    for ( j = 1; j <= MAXC; ++j )

    {

        pre = j;

        cnt[j] = 0;

        for ( i = 1; i <= MAXR; ++i )

        {

            if ( maxtri[i][j] )

            {

                ++cnt[j];

                cur = i * MAXC + j;  //当前节点的编号

                C[cur] = j;          //当前节点所在列

                D[pre] = cur;

                U[cur] = pre;

                pre = cur;

            }

        }

        U[j] = pre;

        D[pre] = j;

        if ( !cnt[j] ) return false; //一定无解

    }



    //行双向链表

    for ( i = 1; i <= MAXR; ++i )

    {

        pre = first = -1;

        for ( j = 1; j <= MAXC; ++j )

        {

            if( maxtri[i][j] )

            {

                cur = i * MAXC + j;

                if ( pre == -1 ) first = cur;

                else

                {

                    R[pre] = cur;

                    L[cur] = pre;

                }

                pre = cur;

            }

        }

        if ( first != -1 )

        {

            R[pre] = first;

            L[first] = pre;

        }

    }

    return true;

}



/**************以上DLX模板*****************/



void show()

{

    for ( int i = 0; i <= MAXR; ++i )

    {

        for ( int j = 0; j <= MAXC; ++j )

            printf( "%d", maxtri[i][j] );

        puts("");

    }

    return;

}



//得到该情况下的01矩阵

void init()

{

    memset( maxtri, false, sizeof(maxtri) );



    for ( int i = 1; i <= SZ; ++i )

    {

        for ( int j = 1; j <= SZ; ++j )

        {

            int col = ( i - 1 ) * SZ + j;  //格子编号（1-81）

            if ( mat[i][j] == '?' )

            {

                for ( int k = 1; k <= SZ; ++k )

                {

                    maxtri[ (col - 1)*SZ + k ][col] = true;      //81保证不重复

                    maxtri[ (col - 1)*SZ + k ][ 81 + (i - 1)*SZ + k ] = true;    //9行中哪一行

                    maxtri[ (col - 1)*SZ + k ][ 162 + (j - 1)*SZ + k ] = true;   //9列中哪一列

                    maxtri[ (col - 1)*SZ + k ][ 243 + ((i-1)/3*3 + (j-1)/3 )*SZ + k ] = true;//9小格中哪一个小格

                }

            }

            else

            {

                int k = mat[i][j] - '0';

                maxtri[ (col - 1)*SZ + k ][col] = true;

                maxtri[ (col - 1)*SZ + k ][ 81 + (i - 1)*SZ + k ] = true;

                maxtri[ (col - 1)*SZ + k ][ 162 + (j - 1)*SZ + k ] = true;

                maxtri[ (col - 1)*SZ + k ][ 243 + ((i-1)/3*3 + (j-1)/3 )*SZ + k ] = true;

            }

        }

    }

    //show();



    return;

}



void PrintAns()

{

    for ( int i = 0; i < 81; ++i )

    {

        int num = ans[i];

        int gird = num / SZ;

        if ( num % SZ ) ++gird;

        int aaa = num % SZ;

        if ( aaa == 0 ) aaa = 9;

        int x = (gird-1)/SZ+1;

        int y = (gird-1)%SZ+1;

        val[x][y] = aaa;

    }



    for ( int i = 1; i <= SZ; ++i )

    {

        for ( int j = 1; j <= SZ; ++j )

            printf( "%d", val[i][j] );

        puts("");

    }

    return;

}



int main()

{

    //freopen( "in.txt", "r", stdin );

    //freopen( "out.txt", "w", stdout );

    int T;

    scanf( "%d", &T );

    while ( T-- )

    {

        for ( int i = 1; i <= SZ; ++i )

            scanf( "%s", &mat[i][1] );

        if ( T ) scanf( "%s", str );

        init();

        if ( build() )

        {

            if ( DFS(0) )

                PrintAns();

            else puts("impossible");

        }

        else puts("impossible");

        if ( T ) puts("---");

    }

    return 0;

}

昨天比赛做到一个题，正解DLX，不过让薛薛位运算+剪枝直接暴过去了……跪。

为了保险起见，今天学了一下DLX。目前只明白了精确覆盖，对重复覆盖还不是很了解。

那个题似乎不是个很简单的DLX，需要精确覆盖+重复覆盖。orz，再接再厉吧。

不得不说，DLX的剪枝效果真是让人惊叹……