poj 3074

题意：解数独

分析：

完整的数独有四个充要条件：

1.每个格子都有填数字

2.每列都有1~9中的每个数字

3.每行都有1~9中的每个数字

4.每个9宫格都有1~9中的每个数字

可以转化成精确覆盖问题。每行表示一个格子的一种填法，1~81列表示这个格子的位置，82~162列表示这是哪一行的什么数字，163~243列表示这是哪一列的什么数字，244~324列表示这是哪一个九宫格里的什么数字。每行都把四个1填入这四个区间里的对应位置。最后求出这个01矩阵的精确覆盖就是解。

在DFS里删除列的顺序为由左往右时TLE了，由右向左却AC，什么原因？？？

#include <cstdio>
#include <cstring>
int U[240005],D[240005],L[240005],R[240005],row[800],col[800],cont[800];
int X[240005],Y[240005],H[800],S[350],M,N,sz,ans[9][9];
bool hashr[10][10],hashc[10][10],hashp[10][10];
void init(int m)
{
    for(int i = 0;i <= m;i++)
    {
        U[i] = D[i] = i;
        L[i + 1] = i;
        R[i] = i + 1;
        S[i] = 0;
    }
    R[m] = 0;
    L[0] = m;
    sz = m + 1;
}

void remove(int c)
{
    //删除一整列
    R[L[c]] = R[c];
    L[R[c]] = L[c];
    //删除行
    for(int i = D[c];i != c;i = D[i])
    {
        for(int j = R[i];j != i;j = R[j])
        {
            D[U[j]] = D[j];
            U[D[j]] = U[j];
            S[X[j]]--;
        }
    }
}

void resume(int c)
{
    //恢复一整列
    L[R[c]] = c;
    R[L[c]] = c;
    //恢复行
    for(int i = U[c];i != c;i = U[i])
    {
        for(int j = L[i];j != i;j = L[j])
        {
            D[U[j]] = j;
            U[D[j]] = j;
            S[X[j]]++;
        }
    }
}

void ins(int r,int c)
{
    S[c]++;
    //纵向插入
    D[U[c]] = sz;
    U[sz] = U[c];
    D[sz] = c;
    U[c] = sz;
    X[sz] = c;
    Y[sz] = r;
    //横向插入
    if(H[r] == -1)
    {
        H[r] = L[sz] = R[sz] = sz;
    }
    else
    {
        R[L[H[r]]] = sz;
        L[sz] = L[H[r]];
        R[sz] = H[r];
        L[H[r]] = sz;
    }
    sz++;
}

bool dfs(int k)
{
    if(R[0] == 0)
    {
        return true;
    }
    else
    {
        int m = 0xfffffff,num;
        for(int i = R[0];i != 0;i = R[i])
        {
            if(S[i] == 0)
            {
                return false;
            }
            if(m > S[i])
            {
                m = S[i];
                num = i;
                if(m == 1)
                {
                    break;
                }
            }
        }
        remove(num);
        for(int i = D[num];i != num;i = D[i])
        {
            ans[row[Y[i]]][col[Y[i]]] = cont[Y[i]];
            for(int j = R[i];j != i;j = R[j])
            {
                remove(X[j]);
            }
            if(dfs(k + 1))
            {
                return true;
            }
            for(int j = L[i];j != i;j = L[j])//恢复顺序改为由左向右居然慢N倍？！
            {
                resume(X[j]);
            }
        }
        resume(num);
    }
    return false;
}

int main()
{
    char input[90];
    while(scanf("%s",input),input[0] != 'e')
    {
        memset(hashr,false,sizeof(hashr));
        memset(hashc,false,sizeof(hashc));
        memset(hashp,false,sizeof(hashp));
        for(int i = 0;i < 9;i++)
        {
            for(int j = 0;j < 9;j++)
            {
                if(input[i * 9 + j] != '.')
                {
                    hashr[i][input[i * 9 + j] - '0'] = true;
                    hashc[j][input[i * 9 + j] - '0'] = true;
                    hashp[i / 3 * 3 + j / 3][input[i * 9 + j] - '0'] = true;
                }
            }
        }
        M = 4 * 9 * 9;
        N = 0;
        init(M);
        for(int i = 0;i < 9;i++)
        {
            for(int j = 0;j < 9;j++)
            {
                int k;
                if(input[i * 9 + j] != '.')
                {
                    k = input[i * 9 + j] - '0';
                }
                else
                {
                    k = 0;
                }
                if(k != 0)
                {
                    row[N] = i;
                    col[N] = j;
                    cont[N] = k;
                    H[N] = -1;
                    ins(N,i * 9 + j + 1);//(i,j)位置已填数字
                    ins(N,81 + i * 9 + k);//i行已有k
                    ins(N,162 + j * 9 + k);//j列已有k
                    ins(N++,243 + (i / 3 * 3 + j / 3) * 9 + k);//宫格已有k
                }
                else
                {
                    for(k = 1;k <= 9;k++)
                    {
                        if(!hashr[i][k] && !hashc[j][k] && !hashp[i / 3 * 3 + j / 3][k])
                        {
                            row[N] = i;
                            col[N] = j;
                            cont[N] = k;
                            H[N] = -1;
                            ins(N,i * 9 + j + 1);//(i,j)位置已填数字
                            ins(N,81 + i * 9 + k);//i行已有k
                            ins(N,162 + j * 9 + k);//j列已有k
                            ins(N++,243 + (i / 3 * 3 + j / 3) * 9 + k);//宫格已有k
                        }
                    }
                }
            }
        }
        dfs(0);
        for(int i = 0;i < 9;i++)
        {
            for(int j = 0;j < 9;j++)
            {
                printf("%d",ans[i][j]);
            }
        }
        printf("
");
    }
    return 0;
}