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天,期间感冒……

     

阅读更多
文章标签: c insert 优化 up
个人分类: 搜索 数据结构
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭