POJ 3076 sudoku DLX

题意：经典的数独问题。

思路：DLX算法可以高效的解决精确覆盖问题，而数独问题也可以转化精确覆盖问题。

            在DLX算法中，我们要分清决策和任务。在这个数独问题中，行表示着决策，每个决策用一个三元组表示（r,c,v）,即将(r,c)格子填上v这个数字。

            而列表示着任务，一共有四种任务需要完成：1.第a行第b列有数字。2.第a行有数字b。3.第a列有数字b。4.第a个九宫格有数字b。同时保证是精确覆盖，这样我们就将数独问题进行了转化。而一个决策可以完成四个任务

    可以计算出，一共有9*9*9 = 729行，4 * 9 * 9  = 324列， 729 * 4 = 2916个结点。可见，dlx对空间要求是巨大的。

代码如下：

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>

using namespace std;

    static const int maxn = 5000;
    static const int maxnode = 20000;
    static const int maxr = 20000;
    int n, sz;
    int S[maxn];
    int row[maxnode],col[maxnode];
    int L[maxnode],R[maxnode],U[maxnode],D[maxnode];
    int columns[maxn],tot;

    int ansd,ans[maxr];

    void init(int n)
    {
        for(int i = 0; i <= n; ++i)
            U[i] = i,D[i] = i,L[i] = i-1,R[i]=i+1;
        R[n] = 0;L[0] = n;
        sz = n + 1;
        memset(S,0,sizeof(S));
    }
    void addrow(int r){
        int first = sz;
        for(int i = 0; i < tot; ++i){
            int c = columns[i];
            L[sz] = sz - 1,R[sz] = sz + 1,D[sz] = c,U[sz] = U[c];
            D[U[c]] = sz; U[c] = sz;
            row[sz] = r,col[sz] = c;
            S[c]++;sz++;
        }
        R[sz - 1] = first;L[first] = sz - 1;
    }

    void remove(int c){
        L[R[c]] = L[c];
        R[L[c]] = R[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 restore(int c){
        L[R[c]] = c;
        R[L[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]] = j,D[U[j]] = j,++S[col[j]];
    }
    bool dfs(int d){
        if(R[0] == 0){
            ansd = d;
            return true;
        }
        //puts("*");
        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(dfs(d+1)) return true;
            for(int j = L[i]; j != i; j = L[j])
                restore(col[j]);
        }
        restore(c);
        return false;
    }

int encode(int a,int b, int c)
{
    return a * 81 + b * 9 + c + 1;
}
void decode(int code, int & a, int & b, int & c)
{
    code--;
    c = code % 9;code /= 9;
    b = code % 9;code /= 9;
    a = code;
}

int main(void)
{
    //freopen("input.txt","r",stdin);
    char sudoku[200];
    while(scanf("%s",sudoku),strcmp("end",sudoku) != 0){
        init(324);
        for(int i = 0; i < 81; ++i){
            int x = i / 9, y = i % 9;
            for(int z = 0; z < 9; ++z){
                if(sudoku[i] == '.' || sudoku[i] == '1' + z){
                    tot = 0;
                    columns[tot++] = encode(0,x,z);
                    columns[tot++] = encode(1,y,z);
                    columns[tot++] = encode(2,x/3*3+y/3,z);
                    columns[tot++] = encode(3,x,y);
                    addrow(encode(x,y,z));
                }
            }
        }
        dfs(0);
        for(int i = 0; i < ansd; ++i){
            int x,y,z;
            decode(ans[i],x,y,z);
            sudoku[9 * x + y] = '1' + z;
        }
        puts(sudoku);
    }
    return 0;
}