【搜索】Dancing Links——01矩阵

转载 2012年03月28日 20:22:04

本文转载自 

ccy1991911的博客


本来ccy是决定放弃Dancing Links的,结果第二天吴老师又哈来一堆关于Dancing Links的资料,于是,ccy又被埋了!~

    额,到现在为止,ccy就会01矩阵,这里,写一下我学习01矩阵这个问题时操作上的一些东西。

    ccy对于01矩阵的操作想的比较清楚,但是,对于效率的一些分析还是很茫然,吴老师说,我们长期处于知其然而不知其所以然状态中。

    这是Dancing Links论文的链接,反正ccy看起很累就是了:http://sqybi.com/works/dlxcn/

**************************************************************************************************

    问题描述:给定一个由0和1组成的矩阵,是否能找到一个行的集合,使得集合中每一列都恰好包含一个1?

    如:6 7
        0010110
        1001001
        0110010
        1001000
        0100001
        0001101

    其中,行集合{1,4,5}是一解。

 

    拿着这题,在不考虑啥时间复杂度效率问题的时候,很明显,用暴搜肯定是搜得出来的。现在,我们就来看下暴搜要怎样搜。(虽然,不管怎么搜,貌似都搜都出来。)

    如果01矩阵为空,问题解决;

    否则

        选取一个列c(保证列c上一定有1);

        选取一行r,满足01矩阵中A[r][c]==1;

            删除列j满足A[r][j]==1;

            删除行i满足A[i][j]==1;

    在不断减小01矩阵下,递归进行上述操作。

    这是个很明显的暴搜方案。

 

    Dancing Links同样在暴搜,只是,舞得很漂亮。

   

    DLX有种压缩的感觉。我们保存的不是整个矩阵,而是矩阵里1的关系。对于每个1,我们生成一个新的结点,结点包括这几个域:

    1、链表连接:L[x],R[x],U[x],D[x],分别表示它的上下左右是哪个结点。

    2、坐标标号:nRow[x],nCol[x],表示结点x的行号列号。

    在这个表里,我们还要做两个表头,列表头和行表头,可以直接把它想成平时链表里的哨兵结点,但是又有那么一点点不同。对于每行每列而言,我们让链尾连向那个哨兵结点,形成一个环,即,每列每行又是一个单独的双向链环。

    还需要一个大表头head,它连接着列表头和行表头。

    因为,我们是给每个1新建结点,对于表头同样是新建,所以,需要建数组表示第几行的行表头的结点标号是多少,第几列的列表头的结点标号是多少。有数组:Rd[r],Cd[c]。

    下面,我们还需要一个S[c]数组,表示,第c列上有S[c]个1。

 

    现在,看我们那个朴素的搜索,把它用上面建的这些变量来实现。

 

    先说明一下,这个诡异的链表建出来究竟是什么样子。

    如上面的样例:

    
    (ccy辛苦画滴图呀!!!!)

    绿色的是行表头和列表头,右下角那个绿色的是大表头。

    蓝色的是1结点。

    红色是链表的链接情况。

    注意两条粉红色的连线,这里只是个行和列的示意,说明的是每个行每个列其实是单独的一个环。

 

    在做dfs操作前,我们需要把这个表建出来。

    对于每个方框,我们分配一个结点空间给它,并有自己的标号。

    首先建行,再建列,再建读入数据中的那些1结点。

    有图:

     

    关于选确定的列c,我们总是选S[c]最小的一个。

    论文上阐述了好多,ccy就茫然了好多。

    我们每选取一行后,就会删除一些其他的行,使得S[]里的一些元素一定变小。而在列c的前提下,我们选取的行是要枚举的,所以,枚举数量当然越小越好。

 

    下面,我们把这个搜索的流程dfs()再写一下。

 

    如果R[head]==head,则找到一个解;

    否则

        选取一个列c;

        删除列c;

        对于每个r=D[c],D[D[c],……,当r!=c,

            选取当行nRow[r],加进答案集合;

            对于每个j=R[r],R[R[r],……,当j!=r,

                删除列Cd[nCol[j]];

            dfs();

            把nRow[r]从集合里取出;

            对于每个j=L[r],L[L[r]],……,当j!=r,

                取消删除列Cd[nCol[j]];

        取消删除列c;

 

    选取列c:

    int minnum=INT_MAX;
    int c=R[head];
    for (int i=R[head];i!=head;i=R[i])
    {
        if (!nCol[D[i]]) continue;
        if (S[nCol[D[i]]]<minnum)
        {
            minnum=S[nCol[D[i]]];
            c=i;
        }
    }

 

    删除列c:把c从表头删除,通过c的列链表去删除c链表的所有行。

    L[R[c]]=L[c];
    R[L[c]]=R[c];

    for (int i=U[c];i!=c;i=U[i])
        for (int j=L[i];j!=i;j=L[j])
        {
            if (!nCol[j]) continue;
            U[D[j]]=U[j];
            D[U[j]]=D[j];
            S[nCol[j]]--;
        }

 

    取消删除列c:

    for (int i=D[c];i!=c;i=D[i])
        for (int j=R[i];j!=i;j=R[j])
        {
            if (!nCol[j]) continue;
            S[nCol[j]]++;
            U[D[j]]=D[U[j]]=j;
        }
    L[R[c]]=R[L[c]]=c;

    这里,我们删除的方向是相反的,这里也是Dancing Links最精彩的地方。

    其实行恢复并不一定要相反,因为j的移动方向和for循环里的操作方向是垂直的,但是,列恢复一定要相反。

    如图:

     
    我们是从上到下进行删除的,这是删除后的图,打了叉的连线代表已经不存在。

    如果,我们恢复的时候依然从上到下,恢复出来的图就是这个样子:

    


    题目要求,保证选出来的行集合,每列都有1,这个,要怎么实现呢?

    开始,我纠结过这个问题,其实,有很多解决方法,就是硬开变量来记录都OK。只是,下面这个代码在处理这里的时候很巧妙,并不需要特别判断与记录。

    我们每次选取一行放进集合时,就要把那一行有1的列删去。抓住这点,如果没有1,就没有做列删除的操作,由于一开始就是建了所有列的列表头的,那么,即使做完都没还有列表头存在,那就证明该列根本就没有1,也就是在判断链表是否为空R[head]==R时,就可以做出每列是否都有1的判断。

 

ccy代码:

#include<iostream>
using namespace std;

const int maxr=1001;
const int maxc=1001;


int L[maxr*maxc],R[maxr*maxc],U[maxr*maxc],D[maxr*maxc];

int S[maxc];

int Rd[maxr],Cd[maxc];

int nRow[maxr*maxc],nCol[maxr*maxc];

int head;


int n,m,cnt;


int best[maxr],ans[maxr];

void ins_row(int r)
{
    cnt++;

    U[D[head]]=cnt;
    D[cnt]=D[head];
    U[cnt]=head;
    D[head]=cnt;

    L[cnt]=R[cnt]=cnt;

    Rd[r]=cnt;
}

void ins_column(int c)
{
    cnt++;

    L[R[head]]=cnt;
    R[cnt]=R[head];
    L[cnt]=head;
    R[head]=cnt;

    U[cnt]=D[cnt]=cnt;

    Cd[c]=cnt;
}

void ins_node(int r,int c)
{
    cnt++;

 
    int rhead=Rd[r];
 
    int chead=Cd[c];

    L[R[rhead]]=cnt;
    R[cnt]=R[rhead];
    L[cnt]=rhead;
    R[rhead]=cnt;

    U[D[chead]]=cnt;
    D[cnt]=D[chead];
    U[cnt]=chead;
    D[chead]=cnt;

    S[c]++;
    nRow[cnt]=r;
    nCol[cnt]=c;
}

void init()
{
 
    head=0;
    L[head]=R[head]=U[head]=D[head]=head;
 
    cnt=0;

    scanf("%d%d",&n,&m);
 
    for (int i=1;i<=n;i++)
        ins_row(i);
 
    for (int i=1;i<=m;i++)
        ins_column(i);
    char ch;
    for (int i=1;i<=n;i++)
    {
        scanf("%c",&ch);
        for (int j=1;j<=m;j++)
        {
            scanf("%c",&ch);
            if (ch=='1') ins_node(i,j);
        }
    }
}

void Remove(int c)
{
 
    L[R[c]]=L[c];
    R[L[c]]=R[c];

 
    for (int i=D[c];i!=c;i=D[i])
        for (int j=L[i];j!=i;j=L[j])
        {
            if (!nCol[j]) continue;
            U[D[j]]=U[j];
            D[U[j]]=D[j];
            S[nCol[j]]--;
        }
}

void Resume(int c)
{
 
    for (int i=U[c];i!=c;i=U[i])
        for (int j=R[i];j!=i;j=R[j])
        {
            if (!nCol[j]) continue;
            S[nCol[j]]++;
            U[D[j]]=D[U[j]]=j;
        }
 
    L[R[c]]=R[L[c]]=c;
}

void dfs()
{
 
    if (R[head]==head)
    {
        if (ans[0]>best[0])
            for (int i=0;i<=ans[0];i++)
                best[i]=ans[i];
        return;
    }

 
    int minnum=INT_MAX;
    int c;
    for (int i=R[head];i!=head;i=R[i])
    {
        if (!nCol[D[i]]) {c=i; return;}
        if (S[nCol[D[i]]]<minnum)
        {
            minnum=S[nCol[D[i]]];
            c=i;
        }
    }

 
    Remove(c);
 
    for (int i=U[c];i!=c;i=U[i])
    {
        ans[0]++;
        ans[ans[0]]=nRow[i];
  
        for (int j=L[i];j!=i;j=L[j])
        {
            if (!nRow[j]) continue;
            Remove(Cd[nCol[j]]);
        }
        dfs();
        ans[0]--;
  
        for (int j=R[i];j!=i;j=R[j])
        {
            if (!nRow[j]) continue;
            Resume(Cd[nCol[j]]);
        }
    }
 
    Resume(c);
}

void out_ans()
{
    for (int i=1;i<best[0];i++)
        for (int j=i+1;j<=best[0];j++)
            if (best[j]<best[i]) swap(best[i],best[j]);
    printf("%d\n",best[0]);
    for (int i=1;i<=best[0];i++)
        printf("%d ",best[i]);
}

int main()
{
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);

    init();
    dfs();
    out_ans();

    fclose(stdin);
    fclose(stdout);
    return 0;
}

    这个代码是ccy在网上东拼西凑,最后综合了一下,形成自己的这种。

    本来找到一个代码,在建表的时候,没有先建行表头和列表头,而是遇到新的行列再建,原本两者没有什么大区别,但是,针对这题而言,我觉得我这样建还好些,而且,这样建的表和读入的数据对应得起来。

    在理解这个算法的时候,ccy有几个疑问,基本上上面都已经解释了,这里,我在列一下:

    1、删除与恢复的方向。

    2、c为什么要去S[]中的最小。

    3、怎样保证每列都有1。

    4、代码中标红色的一句。

       本来我找到的代码,这里的return写的是continue。试想,如果,有一次c的值真的是continue那里来的,那么一定没有解,而如果真的进了continue句话,这样的状态又不会再变,所以,一旦真有这种情况出现,说明,这样走下去肯定无解,因为,即使走下去,总有一次c的值会是从continue那里的i赋值而来,依然无解。

       这里,我直接用了return。

       原因是,如果列表头中存在这个表头,但是它的D[]有指着的是自己,那说明该列根本就不可能再出现1了,所以,再深入dfs下去也没有意义了,直接可以return掉。

 

    额,ccy继续加油……O(∩_∩)O~……

**************************************************************************************************

    有个地方,开始没看透,在Kruth的论文里其实就只有列表头,而这里,我还有行表头。现在正在做n皇后问题,这样,我就需要列、行、两个方向对角线的表头。这时,才发现,需呀与head关联的实际上只是列表头,这样来看,其实,我们也只需要列表头。不过,现在ccy还做不来只有列表头的呢。还是开个哨兵结点当表头比较好。O(∩_∩)O~


跳跃的舞者,舞蹈链(Dancing Links)算法——求解精确覆盖问题

精确覆盖问题的定义:给定一个由0-1组成的矩阵,是否能找到一个行的集合,使得集合中每一列都恰好包含一个1 例如:如下的矩阵 就包含了这样一个集合(第1、4、5行)   ...
  • update7
  • update7
  • 2017年03月18日 11:18
  • 1693

跳跃的舞者,舞蹈链(Dancing Links)算法——求解精确覆盖问题

转自:http://www.cnblogs.com/grenet/p/3145800.html 近日开始学习舞蹈链算法,觉得这份博客真的写的很赞,推荐给要学习舞蹈链算法的新手。 精确覆盖问...

hdu 1426——Dancing links

最近在学Dancing links 然后问学长。。。被骂- - “这么简单都不会啊!!!自己慢慢学。。。什么都要人教的啊。。。那你以后怎么办啊!!!” 好吧~然后。。自学了。。。 自...

跳跃的舞者,舞蹈链(Dancing Links)算法——求解精确覆盖问题

DLX(精确覆盖)算法

DLX舞蹈链(Dancing Links)——求解精确覆盖问题

精确覆盖问题的定义:给定一个由0-1组成的矩阵,是否能找到一个行的集合,使得集合中每一列都恰好包含一个1 例如:如下的矩阵 就包含了这样一个集合(第1、4、5行)   ...
  • gwq5210
  • gwq5210
  • 2014年10月12日 14:50
  • 495

跳跃的舞者,舞蹈链(Dancing Links)算法——求解精确覆盖问题

博客园闪存首页新随笔联系管理订阅 随笔- 154  文章- 1  评论- 901  跳跃的舞者,舞蹈链(Dancing Links)算法——求解精确覆盖问题 ...

【DLX】【vijos P1345】【codevs1174】舞蹈链(Dancing Links)——数独问题

好久都没有写博客了,要不起来在写之前,先安利另外一个作者写的 跳跃的舞者,舞蹈链(Dancing Links)算法——求解精确覆盖问题:http://www.cnblogs.com/grenet/p...

DLX (Dancing Links/舞蹈链)算法——求解精确覆盖问题

精确覆盖问题的定义:给定一个由0-1组成的矩阵,是否能找到一个行的集合,使得集合中每一列都恰好包含一个1 例如:如下的矩阵 就包含了这样一个集合(第1、4、5行)   如何利用给定的矩阵求...

搜索链表优化(dancing links?)

这是一种很优美也很简洁的算法。 实现非常的容易,其容易程度类似于树状数组。 利用在深度优先搜索的栈中所保存的指针,我们可以一句话O(1)的删除链表中的一个元素和还原链表中的一个元素。 删除:p-...

dancing links2

  • 2010年01月09日 19:45
  • 696KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【搜索】Dancing Links——01矩阵
举报原因:
原因补充:

(最多只允许输入30个字)