Sudoku (DLX 算法)

#include <iostream>
#include<stdio.h>
#include<cmath>
#include<string.h>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;
const int maxn = 2010;
const int maxnode = 20010;
const int maxr = 5010;
struct DLX
{
int n,sz; // 列数，节点总数
int S[maxn];  //各列节点数

int row[maxnode],col[maxnode];   //各节点行列标号
int L[maxnode],R[maxnode],U[maxnode],D[maxnode];  // 十字链表 记录节点ID

int ansd,ans[maxr];   //解

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

//虚拟节点
for(int i=0;i<=n;i++)
{
U[i]=i,D[i]=i,L[i]=i-1,R[i]=i+1;
}
R
=0,L[0]=n;

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

void addrow(int r,vector<int>columns)   //添加一行
{
int first=sz;
for(int i=0;i<(int)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;
}
#define FOR(i,A,s) for(int i=A[s];i!=s;i=A[i])
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 1;
}
//找到S最小的列c
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 1;
FOR(j,L,i) restore(col[j]);
}
restore(c);

return 0;
}
bool solve(vector<int> &v)
{
v.clear();
if(!dfs(0)) return 0;
for(int i=0;i<ansd;i++)
v.push_back(ans[i]);
return 1;
}
};
DLX sudoku;
struct Sel
{
int r,c,v;
}S[maxr];
char G[20][20];
int get_id(int x,int y)
{
return 4*(x/4)+y/4;
}
void add(int id,int r,int c,int v)
{
vector<int>x;
x.push_back(16*r+c+1);
x.push_back(16*16+16*r+v+1);
x.push_back(16*16*2+16*c+v+1);
x.push_back(16*16*3+16*get_id(r,c)+v+1);
sudoku.addrow(id,x);

}
int main()
{
int ca=0;
while(~scanf("%s",G[0]))
{
if(ca)
puts("");
ca++;
for(int i=1;i<16;i++)
scanf("%s",G[i]);
sudoku.init(1024);
int cnt=1;
for(int i=0;i<16;i++)
{
for(int j=0;j<16;j++)
{
if(G[i][j]=='-')
{
for(int k=0;k<16;k++)
{
S[cnt].r=i;
S[cnt].c=j;
S[cnt].v=k;
add(cnt,i,j,k);
cnt++;
}
}
else
{
S[cnt].r=i;
S[cnt].c=j;
S[cnt].v=G[i][j]-'A';
add(cnt,i,j,G[i][j]-'A');
cnt++;
}
}
}
vector<int>ans;
ans.clear();
sudoku.solve(ans);
for(int i=0;i<ans.size();i++)
{
int tmp=ans[i];
G[S[tmp].r][S[tmp].c]=S[tmp].v+'A';
}

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