【pku2676+pku3074+pku3076】数独——dancing links

终于搞出个dancing links啦，跳舞庆祝。。

先简单讲讲dancing links，大概就是处理一大类覆盖问题的神法。

这个算法处理的是一个叫做精确覆盖的模型，意思大概就是给你个01矩阵，要求你选出若干行，使得每列有且仅有一个1

不同于别的搜索，dancing links是搜每一列去被哪个行来覆盖，用一个双向十字链表来将所有的1链起来，从而达到去除冗余操作，提升运行速度的神奇效果，疗效显著，3盒一个疗程。。

好了，刚才有一点废话，进入正题。（那个dancing links的具体实现可以参考一些论文或是代码）

讲讲数独怎么转化为精确覆盖模型吧

可以想到，数独无非就是带有一大堆限制条件的选数问题嘛，精确覆盖也就是有每列只能选一个的限制条件的选行问题，

那么只要把这些限制条件对应到精确覆盖上就可以了，怎么对应呢？

以9数独为例，每个格子理论上是可以填1~9之间的任意一个数，但由于有行列宫的限制，所以不能随心所欲地填

而如果我们以 第i行第j列填k 对应到精确覆盖中的行，那么在第i行第j列填了k之后，第i行就不能再填k了，第j列也不能再填k了，第g[i,j]个宫也不能填k了，事实上，第i行第j列这个格子也不能再填别的数了

这可以联想到精确覆盖中每列有且仅有一个1吧！那么我们把 第i行填k、第j列填k、第g[i,j]宫填k 还有 第i行第j列这个格子 对应到精确精确覆盖中的列，再把 第i行第j列填k 这样的行中 对应的列放上1（也就是在 第i行填k、第j列填k、第g[i,j]宫填k 还有 第i行第j列这个格子 这些列放1），恰好契合了数独的所有限制条件，就可以用精确覆盖模型做了！

dancing links=高效+极速，这话不假。

数独实测，就算是加了一大堆优化的直接搜索（包括某年集训队论文提到的一个带状态压缩优化的那个版本）在dancing links面前也是抬不起头的。

真的太神了~~

代码：（代码大同小异，这里就贴个16数独的算了）

pku 3076

program syj; {sudoku_dancing links} const nn=16; oo=maxlongint shr 1; var u,d,l,r,h,tx,ty,tz:array[0..(nn+1)*nn*nn*4]of longint; size:array[1..nn*nn*4]of longint; map:array[1..nn,1..nn]of longint; n,m,tot:longint; ok:boolean; procedure print; var i,j:longint; begin for i:=1 to n do begin for j:=1 to n do write(chr(map[i,j]+64)); writeln; end; writeln; // writeln; inc(tt); // writeln(tt); // close(input);close(output); // halt; ok:=true; end; procedure cover(i:longint); var j,k:longint; begin l[r[i]]:=l[i];r[l[i]]:=r[i]; j:=d[i]; while j<>i do begin k:=r[j]; while k<>j do begin u[d[k]]:=u[k];d[u[k]]:=d[k]; dec(size[h[k]]); k:=r[k]; end; j:=d[j]; end; end; procedure recover(i:longint)； var j,k:longint; begin l[r[i]]:=i;r[l[i]]:=i; j:=u[i]; while j<>i do begin k:=l[j]; while k<>j do begin u[d[k]]:=k;d[u[k]]:=k; inc(size[h[k]]); k:=l[k]; end; j:=u[j]; end; end; procedure dlx; var i,j,k,min:longint; begin i:=r[0]; min:=oo while i<>0 do begin if size[i]<=min then begin //!! <= min:=size[i]; j:=i; end; i:=r[i]; end; if min=0 then exit; if min=oo then begin print;exit; end; cover(j); i:=d[j]; while i<>j do begin k:=r[i]; map[tx[i],ty[i]]:=tz[i]; while k<>i do begin cover(h[k]); map[tx[k],ty[k]]:=tz[k]; k:=r[k]; end; dlx; if ok then exit; k:=l[i]; map[tx[i],ty[i]]:=0; while k<>i do begin recover(h[k]); map[tx[k],ty[k]]:=0; k:=l[k]; end; i:=d[i]; end; recover(j); end; function calc(i,j:longint):longint; begin calc:=(i-1)div m*m+(j+m-1) div m; end; procedure init; var i,j,k,ii,kk:longint; cc:char; begin tot:=n*n*4; for i:=1 to tot do begin l[i]:=i-1;r[i]:=i+1;u[i]:=i;d[i]:=i; end; r[0]:=1; r[tot]:=0; ii:=tot; for i:=1 to n do for j:=1 to n do for k:=1 to n do begin inc(tot); tx[tot]:=i;ty[tot]:=j;tz[tot]:=k; h[tot]:=(i-1)*n+k;inc(size[h[tot]]); l[tot]:=tot+3;r[tot]:=tot+1;u[tot]:=u[h[tot]];d[tot]:=h[tot]; d[u[h[tot]]]:=tot;u[h[tot]]:=tot; inc(tot); tx[tot]:=i;ty[tot]:=j;tz[tot]:=k; h[tot]:=(j-1)*n+k+n*n;inc(size[h[tot]]); l[tot]:=tot-1;r[tot]:=tot+1;u[tot]:=u[h[tot]];d[tot]:=h[tot]; d[u[h[tot]]]:=tot;u[h[tot]]:=tot; inc(tot); tx[tot]:=i;ty[tot]:=j;tz[tot]:=k; h[tot]:=(calc(i,j)-1)*n+k+n*n*2;inc(size[h[tot]]); l[tot]:=tot-1;r[tot]:=tot+1;u[tot]:=u[h[tot]];d[tot]:=h[tot]; d[u[h[tot]]]:=tot;u[h[tot]]:=tot; inc(tot); tx[tot]:=i;ty[tot]:=j;tz[tot]:=k; h[tot]:=(i-1)*n+j+n*n*3;inc(size[h[tot]]); l[tot]:=tot-1;r[tot]:=tot-3;u[tot]:=u[h[tot]];d[tot]:=h[tot]; d[u[h[tot]]]:=tot;u[h[tot]]:=tot; end; for i:=1 to n do begin for j:=1 to n do begin read(cc);if cc='-' then continue; k:=ord(cc)-64; kk:=4*((i-1)*n*n+(j-1)*n+k-1)+ii; for kk:=kk+1 to kk+4 do begin map[tx[kk],ty[kk]]:=tz[kk]; cover(h[kk]); end; end; readln; end; end; begin n:=nn; m:=round(sqrt(n)); while not seekeof do begin ok:=false;tot:=0; fillchar(size,sizeof(size),0); fillchar(map,sizeof(map),0); init; dlx; readln; end; end.

可惜，速度还是比盾盾那个诡异动态版dlx慢一点

还有，那个每次选1最少的那个列的那个地方，如果<=就是400ms左右，<就是3000ms+了

因为我的列的顺序是行->列->宫->格子，估计是后面的宫的那个限制条件卡的紧一些，所有先选后面的会好些，这个地方囧了我好久