Dancing Links + A* 应用于精确覆盖、重复覆盖

Dancing Links是由Knuth提出的用于一类搜索问题的通用优化。

或称DLX。

主要应用于精确覆盖和重复覆盖。

精确覆盖题目：

POJ3740、POJ3074、POJ3076、HDU4069

重复覆盖题目：

HDU3529、HDU2295、POJ1084

关于DLX的详细介绍可以去查阅相关资料。

假设一个0-1矩阵，要求选择某几个行，使得所有的列均只有一个1（精确覆盖），或者至少有一个1（重复覆盖）。

DLX使用双向链表极大地优化了搜索。

DLX可以说是一种模板。应用于一类题目。只要把问题建模转化为一定的格式，则可以应用DLX。

精确覆盖应用于解数独、八皇后等。据说目前解数独速度最快的就是DLX。

重复覆盖应用于类似雷达覆盖的问题。

精确覆盖模板：

void remove(const int &c)
{
l[r[c]] = l[c];
r[l[c]] = r[c];
int i, j;
for (i=d[c]; i!=c; i=d[i])
{
for (j=r[i]; j!=i; j=r[j])
{
u[d[j]] = u[j];
d[u[j]] = d[j];
s[ch[j]]--;
}
}
}

void resume(const int &c)
{
int i, j;
for (i=u[c]; i!=c; i=u[i])
{
for (j=l[i]; j!=i; j=l[j])
{
s[ch[j]]++;
u[d[j]] = j;
d[u[j]] = j;
}
}
l[r[c]] = c;
r[l[c]] = c;
}

bool dfs(const int &k)
{
if (r[head]==head)
{
return true;
}
int ss = INT_MAX;
int c;
int i, j;
for (i=r[head]; i!=head; i=r[i])
{
if (s[i]<ss)
{
ss = s[i];
c = i;
}
}
remove(c);
for (i=d[c]; i!=c; i=d[i])
{
o[k] = rh[i];
len = k;
for (j=r[i]; j!=i; j=r[j]) remove(ch[j]);
if (dfs(k+1)) return true;
for (j=l[i]; j!=i; j=l[j]) resume(ch[j]);
}
resume(c);
return false;
}

重复覆盖模板：

void remove(int c)
{
int i;
for (i=d[c]; i!=c; i=d[i])
{
l[r[i]] = l[i];
r[l[i]] = r[i];
}
}

void resume(int c)
{
int i;
for (i=u[c]; i!=c; i=u[i])
{
l[r[i]] = r[l[i]] = i;
}
}

int h()
{
memset(used, false, sizeof(used));
int c, i, j;
int ret = 0;
for (c=r[head]; c!=head; c=r[c])
{
if (!used[c])
{
ret++;
used[c] = true;
for (i=d[c]; i!=c; i=d[i])
{
for (j=r[i]; j!=i; j=r[j])
{
used[ch[j]] = true;
}
}
}
}
return ret;
}

void dfs(int k)
{
if (k+h()>=len)//启发式搜索
return;
if (r[head]==head)
{
len = k;
return;
}
int ss = INT_MAX;
int c, i, j;
for (i=r[head]; i!=head; i=r[i])
{
if (s[i]<ss)
{
ss = s[i];
c = i;
}
}
for (i=d[c]; i!=c; i=d[i])
{
remove(i);
for (j=r[i]; j!=i; j=r[j]) remove(j);
dfs(k+1);
for (j=l[i]; j!=i; j=l[j]) resume(j);
resume(i);
}
}

共用部分：

int new_node(int up, int down, int left, int right)
{
l[size] = left;
r[size] = right;
u[size] = up;
d[size] = down;
l[right] = r[left] = u[down] = d[up] = size;
return size++;
}

void init(int n, int m)
{
size = 0;
head = new_node(0, 0, 0, 0);
len = n;
int i;
for (i=1; i<=m; i++)
{
new_node(i, i, l[head], head);
ch[i] = i;
s[i] = 0;
}
for (i=0; i<=n; i++)
rh[i] = -1;
}

void insert_node(int i, int j)
{
ch[size] = j;
s[j]++;
if (rh[i]==-1)
{
rh[i] = new_node(j, d[j], size, size);
}
else
{
new_node(j, d[j], rh[i], r[rh[i]]);
}
}

DLX一般难在建模。只要建好模，一切都好办。

不过有些题目建模过程极其猥琐……比如POJ1084……

题解：

POJ3740：精确覆盖的基本题目。

POJ3074、POJ3076：数独的基本题目。把数组转化为01矩阵再进行DLX。

HDU4069：数独小变种，只是块的部分改变了，影响不大。

HDU3529：以空格为行，障碍为列，进行重复覆盖即可。

HDU2295：NC的我，由于一个字母打错，TLE了10次，然后精度问题WA了3次，还有一个CE，最终AC……二分雷达的半径进行重复覆盖，以雷达为行，以城市为列。

POJ1084：超恶心的一道题目。重复覆盖。以火柴为行，以方格为列。若某火柴支配某个方格（可多个方格），则标记为1。题目恶心在，方格的边长必须从小到大排列；如果从大到小排列的话，超时没话说。做这道题耗时n天，期间感冒……