UVa 1309 DLX Sudoku

16×16的数独。

看白书学的DLX，有些细节还有待消化，贴个模板先。

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

const int maxn = 16;
const int maxnode = 16384 + 100;
const int maxr = 4096 + 10;
const int maxc = 1024 + 10;

#define FOR(i,A,s) for(int i = A[s]; i != s; i = A[i])

struct DLX
{
    int n, sz;
    int S[maxc];

    int row[maxnode], col[maxnode];
    int L[maxnode], R[maxnode], U[maxnode], D[maxnode];

    int ansd, ans[maxr];

    void init(int n)
    {
        this-> n = n;

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

        sz = n + 1;
        memset(S, 0, sizeof(S));
    }

    void AddRow(int r, vector<int> columns)
    {
        int first = sz;
        for(int i = 0; i < columns.size(); 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(i,D,c)
            FOR(j,R,i) { U[D[j]] = U[j]; D[U[j]] = D[j]; --S[col[j]]; }
    }

    void restore(int c)
    {
        FOR(i,U,c)
            FOR(j,L,i) { ++S[col[j]]; U[D[j]] = j; D[U[j]] = j; }
        L[R[c]] = c;
        R[L[c]] = c;
    }

    bool dfs(int d)
    {
        if(R[0] == 0) { ansd = d; return true; }

        int c = R[0];
        FOR(i,R,0) if(S[i] < S[c]) c = i;

        remove(c);
        FOR(i,D,c)
        {
            ans[d] = row[i];
            FOR(j,R,i) remove(col[j]);
            if(dfs(d + 1)) return true;
            FOR(j,L,i) restore(col[j]);
        }
        restore(c);

        return false;
    }

    bool solve(vector<int>& v)
    {
        v.clear();
        if(!dfs(0)) return false;
        for(int i = 0; i < ansd; i++) v.push_back(ans[i]);
        return true;
    }
}solver;

const int SLOT = 0;
const int ROW = 1;
const int COL = 2;
const int SUB = 3;

int encode(int a, int b, int c) {
    return a * 256 + b * 16 + c + 1;
}

void decode(int code, int& a, int& b, int& c) {
    code--;
    c = code % 16; code /= 16;
    b = code % 16; code /= 16;
    a = code % 16;
}

char G[maxn][maxn + 10];

bool read()
{
    for(int i = 0; i < 16; i++)
        if(scanf("%s", G[i]) != 1) return false;
    return true;
}

int main()
{
    int kase = 0;
    while(read())
    {
        if(kase++ > 0) puts("");
        
        solver.init(1024);
        for(int r = 0; r < 16; r++)
            for(int c = 0; c < 16; c++)
                for(int v = 0; v < 16; v++)
                    if(G[r][c] == '-' || G[r][c] == 'A' + v) {
                        vector<int> columns;
                        //一行完成四个任务
                        columns.push_back(encode(SLOT, r, c));
                        columns.push_back(encode(ROW, r, v));
                        columns.push_back(encode(COL, c, v));
                        columns.push_back(encode(SUB, (r/4)*4+c/4, v));
                        solver.AddRow(encode(r,c,v), columns);
                    }

        vector<int> ans;
        solver.solve(ans);

        for(int i = 0; i < ans.size(); i++) {
            int r, c, v;
            decode(ans[i], r, c, v);
            G[r][c] = 'A' + v;
        }

        for(int i = 0; i < 16; i++) printf("%s
", G[i]);
    }

    return 0;
}