可重复覆盖的DLX

在精确覆盖的基础上只修改remove() 和resume() 就好了，每次选中一行，只把这一行对应的列以及这一行删除即可。

很显然的，这样降低了矩阵缩小的速度，但是出现A*优化的补救方法，H()是在VJ上扒下来的，233。

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <queue>
#include <cmath>
#include <stack>
#include <map>

#pragma comment(linker, "/STACK:1024000000")
#define EPS (1e-8)
#define LL long long
#define ULL unsigned long long
#define _LL __int64
#define INF 0x3f3f3f3f
#define Mod 100007

using namespace std;

const int MAXCLOUM = 300,MAXROW = 300,MAXPOINT = MAXCLOUM*MAXROW;

bool MARKCLOUM[MAXCLOUM];
int sta[MAXROW],sta_anw;//答案栈以及栈内元素个数
int SIZE[MAXCLOUM];//每一列元素个数，不包括虚拟列指针
int PRE[MAXROW];//每一行最后加入的元素位置，初始为-1.
int C[MAXCLOUM];//每一列的头指针的位置
int ROW[MAXPOINT],COL[MAXPOINT];//每个元素的行列坐标
int L[MAXPOINT],R[MAXPOINT],U[MAXPOINT],D[MAXPOINT];//每个元素的四个指针
int Top;//第一个未分配元素的地址
int Min;//记录最优解

inline int Creat(int row,int col)
{
COL[Top] = col;
ROW[Top] = row;

U[Top] = Top;
D[Top] = Top;
L[Top] = Top;
R[Top] = Top;

return Top++;
}

void Init(int row,int col)
{
Min = MAXCLOUM;
sta_anw = 0;
Top = 0;
C[0] = Creat(0,0);
for(int i = 1; i <= col; ++i)
{
C[i] = Creat(0,i);
R[C[i]] = R[C[i-1]];
L[R[C[i-1]]] = C[i];
R[C[i-1]] = C[i];
L[C[i]] = C[i-1];
SIZE[i] = 0;
}

memset(PRE,-1,sizeof(PRE));
}

void Insert(int row,int col)
{
//cout<<"row = "<<row<<" col = "<<col<<endl;
int now = Creat(row,col);

D[U[C[col]]] = now;
U[now] = U[C[col]];
D[now] = C[col];
U[C[col]] = now;
++SIZE[col];

if(PRE[row] != -1)
{
L[R[PRE[row]]] = now;
R[now] = R[PRE[row]];
L[now] = PRE[row];
R[PRE[row]] = now;
}

PRE[row] = now;
}

void Remove(int c)
{
for(int i = D[c]; i != c; i = D[i])
{
L[R[i]] = L[i];
R[L[i]] = R[i];
}
}

void Resume(int c)
{
for(int i = U[c]; i != c; i = U[i])
{
L[R[i]] = i;
R[L[i]] = i;
}
}

int H()
{
memset(MARKCLOUM,false,sizeof(MARKCLOUM));

int i,j,k,ans = 0;

for(i = R[C[0]];i != C[0] ;i = R[i])
{
if(MARKCLOUM[COL[i]])
continue;

MARKCLOUM[COL[i]] = true;
ans++;

for(j = D[i];j != i; j = D[j])
{
for(k = R[j];k != j ; k = R[k])
{
MARKCLOUM[COL[k]] = true;
}
}
}
return ans;
}

bool Dance(int dis)
{
int now,i,j;

if(dis+H() >= Min)
return false;

if(R[C[0]] == C[0])
return Min = dis,true;

for(i = now = R[C[0]];i != C[0];i = R[i])
{
if(SIZE[COL[i]] < SIZE[COL[now]])
now = i;
}

for(i = D[now]; i != now; i = D[i])
{
Remove(i);
for(j = R[i]; j != i; j = R[j])
Remove(j);
sta[sta_anw++] = ROW[i];
Dance(dis+1);
sta_anw--;
for(j = L[i]; j != i; j = L[j])
Resume(j);
Resume(i);
}

return false;
}

char Map[20][20];
int vis[20][20];

int jx[] = {-1, 0, 0, 1};
int jy[] = { 0,-1, 1, 0};

int Cal(int x,int y,int dir)
{
while(1)
{
x += jx[dir];
y += jy[dir];

if(Map[x][y] == '*')
return -1;
if(vis[x][y])
return vis[x][y];

}
}

int main()
{
int ans,n,m,i,j,k,tmp;

while(scanf("%d %d",&n,&m) != EOF)
{
for(i = 1;i <= n; ++i)
scanf("%s",Map[i]+1);

memset(vis,0,sizeof(vis));

for(i = 1,ans = 0;i <= n; ++i)
for(j = 1;j <= m; ++j)
if(Map[i][j] == '#')
vis[i][j] = ++ans;

Init(256,ans);

for(ans = 1,i = 1;i <= n; ++i)
for(j = 1;j <= m; ++j)
{
if(Map[i][j] == '.')
{
for(k = 0;k < 4; ++k)
{
if((tmp = Cal(i,j,k)) != -1)
{
Insert(ans,tmp);
}
}
ans++;
}
}

Dance(1);

printf("%d\n",Min-1);
}

return 0;
}