POJ 2676 锻炼码力：数独，精确覆盖的DLX

题意：先给定数据组数T，每组数据都是一个数独游戏，输出它任意一个解。

自从学了DLX之后，还没写过精确覆盖，只用自己YY代码写过一次可重复覆盖。这次写一个精确覆盖。数独麻烦的就是构建M矩阵，想了有一段时间。

对于构建数独的M矩阵，大都是这样的套路：
行表示的是在某个位置填某个数。
列表示的是：某个位置是否有数，某一行是否有某个数，某一列是否有某个数，某一个块是否有某个数。

只要记录清楚行、列对应的是那些信息就好了。

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;

int Time, zero, Sdk[15][15], need0[15][15], needr[15][15], needc[15][15], needb[15][15];
bool Mtx[335], App[3][15][15];

struct Choice {int x, y, z;}T[735];

struct DLX
{
    #define M 236666  // 9*9 sudoku -> mxr[729][324]

    int sz, Col, Row, col[M], row[M], S[M], ans[735];
    int U[M], D[M], L[M], R[M];

    void initialize(int Rows)
    {
        sz = Row = Rows; Col = 0;
        memset(S, 0, sizeof S);
        memset(U, 0, sizeof U);
        memset(D, 0, sizeof D);
        memset(L, 0, sizeof L);
        memset(R, 0, sizeof R);
        memset(col, 0, sizeof col);
        memset(row, 0, sizeof row);

        for(int i = 0; i <= sz; i++)
        {
            U[i] = i, D[i] = i, L[i] = i-1, R[i] = i+1;
            col[i] = i;     
        }
        L[0] = sz, R[sz] = 0;   
    }

    void add_col(bool *mtx)
    {
        int fir = sz; Col++;
        for(int i = 1; i <= Row; i++) if(mtx[i])
        {
            sz++; col[sz] = Col, row[sz] = i; S[i]++;
            U[sz] = U[i], D[sz] = i, L[sz] = sz-1, R[sz] = sz+1;
            D[U[i]] = sz, U[i] = sz;
        }
        if(sz != fir) L[fir+1] = sz, R[sz] = fir+1;
    }

    void remove(int r)
    {
        L[R[r]] = L[r], R[L[r]] = R[r];
        for(int i = D[r]; i != r; i = D[i])
        for(int j = R[i]; j != i; j = R[j])
            D[U[j]] = D[j], U[D[j]] = U[j], S[row[j]]--;
    }
    void resume(int r)
    {
        L[R[r]] = r, R[L[r]] = r;
        for(int i = D[r]; i != r; i = D[i])
        for(int j = R[i]; j != i; j = R[j])
            D[U[j]] = j, U[D[j]] = j, S[row[j]]++;
    }

    int dfs(int d)
    {
        if(!R[0]) return d;     

        int r = 0, Mins = 1<<30;
        for(int i = R[0]; i; i = R[i])
            if(S[i] < Mins) Mins = S[i], r = i;

        remove(r);
        for(int i = D[r]; i != r; i = D[i])
        {
            for(int j = R[i]; j != i; j = R[j]) remove(row[j]);
            ans[d] = col[i];
            int k = dfs(d+1); if(k) return k;
            for(int j = R[i]; j != i; j = R[j]) resume(row[j]);
        }
        resume(r);
        return 0;
    }

    void work()
    {
        int d = dfs(1);
        for(int i = 1; i <= d; i++)
        {
            int id = ans[i];
            Sdk[T[id].x][T[id].y] = T[id].z;
        }
        for(int i = 1; i <= 9; i++)
        {
            for(int j = 1; j <= 9; j++) printf("%d", Sdk[i][j]);
            putchar('\n');
        }
        putchar('\n');
    }
}Solver;

int ID(int x, int y)
{
    return (x-1)/3*3 + (y-1)/3+1;
}

bool ok(int x, int y, int z)
{
    int k = ID(x, y);
    return !App[0][x][z] && !App[1][y][z] && !App[2][k][z];
}

void Initialize()
{
    char s[15];
    zero = 0;
    memset(T, 0, sizeof T);
    for(int i = 1; i <= 9; i++)
    {
        scanf("%s", s+1);
        for(int j = 1; j <= 9; j++) Sdk[i][j] = s[j]-48;
    }

    memset(App, 0, sizeof App);
    for(int i = 1; i <= 9; i++)
    for(int j = 1; j <= 9; j++) 
    if(Sdk[i][j]){
        App[0][i][Sdk[i][j]] = 1;
        App[1][j][Sdk[i][j]] = 1;
        App[2][ID(i, j)][Sdk[i][j]] = 1;
    }

    memset(need0, 0, sizeof need0);
    memset(needr, 0, sizeof needr);
    memset(needc, 0, sizeof needc);
    memset(needb, 0, sizeof needb);

    for(int i = 1; i <= 9; i++)
    for(int j = 1; j <= 9; j++)
    {
        if(!Sdk[i][j]) need0[i][j] = ++zero;
        if(!App[0][i][j]) needc[i][j] = ++zero;
        if(!App[1][i][j]) needr[i][j] = ++zero;
        if(!App[2][i][j]) needb[i][j] = ++zero;
    }
}

void Add_col()
{
    for(int i = 1; i <= 9; i++)
    for(int j = 1; j <= 9; j++)
    {
        if(Sdk[i][j]) continue;
        for(int k = 1; k <= 9; k++)
        {
            if(!ok(i, j, k)) continue;
            memset(Mtx, 0, sizeof Mtx);
            Mtx[need0[i][j]] = 1;
            Mtx[needc[i][k]] = 1;
            Mtx[needr[j][k]] = 1;
            Mtx[needb[ID(i, j)][k]] = 1;
            Solver.add_col(Mtx);
            int t = Solver.Col;
            T[t].x = i, T[t].y = j, T[t].z = k;
        }
    }
}


int main()
{
    scanf("%d", &Time);
    while(Time--)
    {
        Initialize();
        Solver.initialize(zero);

        Add_col();
        Solver.work();
    }
    return 0;
}