Vision_数据结构_舞蹈连

最新推荐文章于 2023-08-09 17:22:37 发布
最新推荐文章于 2023-08-09 17:22:37 发布
阅读量334 收藏
点赞数
分类专栏： # ACM-模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/txgANG/article/details/78165618
版权

///定义（ctrl+c）：
/*
    （1）历史：
　　     X算法是高德纳提出的解决精确覆盖问题的算法，而dancing links X算法则是DonKnuth(《计算机程序设计艺术》
         的作者)提出的对X算法的一种高效实现，这种实现建立在如上所说的矩阵表示法上。


    （2）算法思想：
        由如上精确覆盖问题的矩阵表示法中，我们知道dancing links x 是用来求解一个 01矩阵中选取哪几行可以使得
        这几行每一列都有且仅有一个1（就是每个元素在这几个子集里有且仅有出现过一次）。先不管他的实际意义，
        我们需要做的就是在一个01矩阵的选取某几行使之符合上述条件。我们很容易就想到枚举，然后判断符不符合条件，
        但是这个做法实在是太消耗时间。dacing links x就是一个高效的求解该类问题的算法，而这种算法，基于交叉十字
        循环双向链的数据结构。
    （3）精确覆盖问题的定义：
        给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1
    （4）重复覆盖问题：
        即选取一个01矩阵中的几行，使这几行组成的新矩阵的每一列至少有一个1。 
        该问题在精确覆盖问题上减少了一个约束条件
    （5）应用：
        解决精确覆盖问题和重复覆盖问题
    
*/
///代码：


/*
**name:舞蹈连-精确覆盖问题
**function:给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1
**输入参数：包含1的位置（i,j）
**输出参数：行集合的信息
*/
#include <iostream>
#include <cstdio>
using namespace std;

const int maxnode = 100010;
const int maxm = 1010;
const int maxn = 1010;

struct DLX{
    int n,m,len;
    int U[maxnode],D[maxnode],R[maxnode],L[maxnode],Row[maxnode],Col[maxnode];
    int H[maxn];//行头结点
    int S[maxm];//每列有多少个结点
    int ansd,ans[maxn];//如果有答案，则选了ansd行，具体是哪几行放在ans[]数组里面,ans[0~ansd-1]

    void init(int _n,int _m){
        n = _n;m = _m;
        for(int i = 0; i <= m; i++){
            S[i] = 0;
            U[i] = D[i] = i;//初始状态时，上下都指向自己
            L[i] = i-1;
            R[i] = i+1;
        }
        R[m] = 0,L[0] = m;
        len = m;//编号，每列都有一个头结点，编号1~m
        for(int i = 1; i <= n; i++)
            H[i] = -1;//每一行的头结点
    }

    void link(int r,int c){//第r行，第c列
        ++S[Col[++len]=c];//第len个节点所在的列为c,当前列的结点数++
        Row[len] = r;//第len个结点行位置为r
        D[len] = D[c];
        U[D[c]] = len;
        U[len] = c;
        D[c] = len;
        if(H[r] < 0)
            H[r] = L[len] = R[len] = len;
        else{
            R[len] = R[H[r]];
            L[R[H[r]]] = len;
            L[len] = H[r];
            R[H[r]] = len;
        }
    }

    void del(int c){//删除结点c，以及c上下结点所在的行
        //每次调用这个函数，都是从列头节点开始向下删除，这里c也可以理解为第c列
        //因为第c列的列头节点编号为c
        L[R[c]] = L[c];
        R[L[c]] = R[c];
        for(int i = D[c]; i != c; i = D[i]){
            for(int j = R[i]; j != i; j = R[j]){
                U[D[j]] = U[j];
                D[U[j]] = D[j];
                --S[Col[j]];
            }
        }
    }

    void resume(int c){//回复结点c，以及c上下节点所在的行(同上，也可以理解为从第c列的头节点开始恢复
        for(int i = U[c]; i != c; i = U[i]){
            for(int j = L[i]; j != i; j = L[j]){
                ++S[Col[U[D[j]]=D[U[j]]=j]];
            }
        }
        L[R[c]] = R[L[c]] = c;
    }

    bool dance(int d){//递归深度
        if(R[0] == 0){
            ansd = d;
            return true;
        }
        int c = R[0];
        for(int i = R[0]; i != 0; i = R[i]){
            if(S[i] < S[c])
                c = i;
        }

        del(c);//找到结点数最少的列，当前元素不是原图上0，1的节点，而是列头节点
        for(int i = D[c]; i != c; i = D[i]){
            ans[d] = Row[i];//列头节点下面的一个节点
            for(int j = R[i]; j != i; j = R[j])
                del(Col[j]);
            if(dance(d+1))//找到，返回
                return true;
            for(int j = L[i]; j != i; j = L[j])
                resume(Col[j]);
        }
        resume(c);
        return false;
    }
};

DLX head;

int main(){
    int n,m,k;
    while(~scanf("%d%d%d",&n,&m,&k)){
        head.init(n,m);
        for(int i = 1,x; i <= n; i++){
            for(int j = 1;j<=m;j++){
                scanf("%d",&x);
                if(!x)head.link(i,j);
            }
        }

        if(!head.dance(0))
            printf("NO\n");
        else{
            printf("%d\n",head.ansd);
            for(int i = 0; i < head.ansd; i++)
                printf(" %d",head.ans[i]);
            printf("\n");
        }
    }
    return 0;
}




/*
**name: 舞蹈连-重复覆盖问题
**function: 即选取一个01矩阵中的几行，使这几行组成的新矩阵的每一列至少有一个1。 
**输入参数：包含1的位置（i,j）
**输出参数：至少所消耗的行数，如果返回无穷大则表明不存在
*/
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;
struct DLX
{
    int n,m,len,ansd;
    int S[400],U[200000],D[200000],L[200000],R[200000],Row[200000],Col[200000];
    int H[400];

    void init(int _n,int _m)
    {
        n=_n;
        m=_m;
        len=m;
        ansd=0x3f3f3f3f;
        for(int i=0; i<=m; i++)
        {
            S[i]=0;
            U[i]=D[i]=i;
            R[i]=i+1;
            L[i]=i-1;
            Row[i]=0;
            Col[i]=i;
        }
        R[m]=0;
        L[0]=m;
        for(int i=1; i<=n; i++)
            H[i]=-1;
    }

    void link(int r,int c)
    {
        ++len;
        ++S[c];
        Row[len]=r;
        Col[len]=c;
        D[len]=D[c];
        U[D[c]]=len;
        U[len]=c;
        D[c]=len;
        if(H[r]==-1)
        {
            H[r]=R[len]=L[len]=len;
        }
        else
        {
            R[len]=R[H[r]];
            L[R[H[r]]]=len;
            L[len]=H[r];
            R[H[r]]=len;
        }
    }
    int f()
    {
        int ans=0;
        int V[400];
        memset(V,0,sizeof(V));
        for(int i=R[0]; i!=0; i=R[i])
        {
            V[i]=true;
        }
        for(int i=R[0]; i!=0; i=R[i])
        {
            if(V[i])
            {
                ans++;
                V[i]=false;
                for(int j=D[i]; j!=i; j=D[j])
                {
                    for(int k=R[j]; k!=j; k=R[k])
                    {
                        V[Col[k]]=false;
                    }
                }

            }
        }
        return ans;
    }

    void del(int c)
    {
        for(int i=D[c]; i!=c; i=D[i])
        {
            R[L[i]]=R[i];
            L[R[i]]=L[i];
        }
    }
    void resume(int c)
    {
        for(int i=U[c]; i!=c; i=U[i])
        {
            L[R[i]]=i;
            R[L[i]]=i;
        }
    }
    void Dance(int d)
    {
        if(d>=ansd)return ;
        if(d+f()>=ansd)return ;
        if(R[0]==0)
        {
            ansd=min(ansd,d);
            return ;
        }
        int c=R[0];
        for(int i=R[0]; i!=0; i=R[i])
        {
            if(S[i]<S[c])
                c=i;
        }

        for(int i=D[c]; i!=c; i=D[i])
        {
            del(i);
            for(int j=R[i]; j!=i; j=R[j])del(j);
            Dance(d+1);
            for(int j=L[i]; j!=i; j=L[j])resume(j);
            resume(i);
        }
        return ;
    }
};
DLX head;
int main(){
    int n,m,k,x;
    while(~scanf("%d%d%d",&n,&m,&k)){
        head.init(n,m);
        for(int i = 1;i<=n;i++){
            for(int j = 1;j<=m;j++){
                scanf("%d",&x);
                if(!x)head.link(i,j);
            }
        }
        head.Dance(0);
        if(head.ansd<=k&&head.ansd!=0x3f3f3f3f)printf("yes\n");
        else printf("no\n");
        //printf("%d\n",head.ansd);
    }
    return 0;
}




/*
**name:舞蹈连-精确覆盖问题
**function:求解数独
**输入参数：数独盘的字符串
**输出参数：完整的数独盘字符串
*/
#include <cstring>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <cmath>
#include <algorithm>

using namespace std;
const int maxn=1000,maxm=400,maxnode=400000;
struct DLX
{
    int n,m,len;
    int U[maxnode],D[maxnode],R[maxnode],L[maxnode],Row[maxnode],Col[maxnode];
    int H[maxn];///行头结点
    int S[maxm];///每列有多少个结点
    int ansd,ans[maxn];

    void init(int _n,int _m)
    {
        n=_n;
        m=_m;
        for(int i=0; i<=m; i++)
        {
            S[i]=0;
            U[i]=D[i]=i;
            L[i]=i-1;
            R[i]=i+1;
        }
        R[m]=0,L[0]=m;
        len=m;
        for(int i=1; i<=n; i++)
        {
            //cout<<"**"<<endl;
            H[i]=-1;
        }
    }

    void link(int r,int c)
    {
        ++S[Col[++len]=c];
        Row[len]=r;
        D[len]=D[c];
        U[D[c]]=len;
        U[len]=c;
        D[c]=len;
        if(H[r]<0)
            H[r]=L[len]=R[len]=len;
        else
        {
            R[len]=R[H[r]];
            L[R[H[r]]]=len;
            L[len]=H[r];
            R[H[r]]=len;
        }
    }

    void del(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=R[i]; j!=i; j=R[j])
            {
                U[D[j]]=U[j];
                D[U[j]]=D[j];
                --S[Col[j]];
            }
        }
    }

    void resume(int c)
    {
        for(int i=U[c]; i!=c; i=U[i])
        {
            for(int j=L[i]; j!=i; j=L[j])
            {
                ++S[Col[U[D[j]]=D[U[j]]=j]];
            }
        }
        L[R[c]]=R[L[c]]=c;
    }
    bool dance(int d)
    {
        //cout<<d<<endl;
        if(R[0]==0)
        {
            ansd=d;
            return true;
        }
        int c=R[0];
        ///找一个1少的列,相当于剪枝了
        for(int i=R[0]; i!=0; i=R[i])
        {
            //cout<<S[i]<<endl;
            if(S[i]<S[c])
            {
                c=i;
            }
        }
        del(c);
        //cout<<S[1]<<endl;
        //cout<<"del()"<<c<<endl;
        //cout<<D[c]<<" "<<endl;
        for(int i=D[c]; i!=c; i=D[i])
        {
            //cout<<i<<endl;
            ans[d]=Row[i];
            for(int j=R[i]; j!=i; j=R[j])
            {
                del(Col[j]);
            }
            if(dance(d+1))return true;
            for(int j=L[i]; j!=i; j=L[j])
            {
                resume(Col[j]);
            }
        }
        resume(c);
        return false;
    }
};
struct node
{
    int pos;
    int data;
    int lie;
} q[2000];
DLX head;
int main()
{
    char s[100];
    while(scanf("%s",s))
    {
        if(strcmp(s,"end")==0)break;
        int len=strlen(s);
        head.init(1000,324);
        int row=0;
        for(int i=0; i<len; i++)
        {
            int x=i/9,y=i%9;
            if(s[i]=='.')
            {
                for(int j=1; j<=9; j++)
                {
                    //x行y列填了一个数字
                    head.link(++row,x*9+(y+1));
                    //x行填了一个数字j
                    head.link(row,x*9+j+81);
                    //y列填了一个数字j
                    head.link(row,y*9+j+162);
                    //g宫填了一个数字j
                    int xx=x/3*3,yy=y/3*3;
                    int g=xx/3*3+yy/3+1;
                    head.link(row,(g-1)*9+j+243);
                    q[row].pos=i;
                    q[row].data=j;
                    q[row].lie=x*9+y+1;
                }
            }
            else
            {
                int a=s[i]-'0';
                //x行y列填了一个数字
                head.link(++row,x*9+(y+1));
                //x行填了一个数字j
                head.link(row,x*9+a+81);
                //y列填了一个数字j
                head.link(row,y*9+a+162);
                //g宫填了一个数字j
                int xx=x/3*3,yy=y/3*3;
                int g=xx/3*3+yy/3+1;
                head.link(row,(g-1)*9+a+243);
                q[row].pos=i;
                q[row].data=a;
                q[row].lie=x*9+y+1;
            }
        }
        //cout<<head.S[1]<<endl;
        bool ok=head.dance(0);
        //cout<<ok<<endl;
        //cout<<head.ansd<<endl;
        for(int i=0; i<head.ansd; i++)
        {
            if(s[q[head.ans[i]].pos]=='.')s[q[head.ans[i]].pos]='0'+q[head.ans[i]].data;
        }
        //cout<<endl;
        printf("%s\n",s);
    }
    return 0;
}



///扩展：
/*
    舞蹈连的步骤：
        1、从矩阵中选择一行
        2、根据定义，标示矩阵中其他行的元素
        3、删除相关行和列的元素，得到新矩阵
        4、如果新矩阵是空矩阵，并且之前的一行都是1，那么求解结束，跳转到6；新矩阵不是空矩阵，
    继续求解，跳转到1；新矩阵是空矩阵，之前的一行中有0，跳转到5
        5、说明之前的选择有误，回溯到之前的一个矩阵，跳转到1；如果没有矩阵可以回溯，说明该问题无解，跳转到7
        6、求解结束，把结果输出
        7、求解结束，输出无解消息
*/

_txg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
夜深人静写算法（五十）- Dancing Links X（跳舞链）
英雄哪里出来
01-31 32万+
双向十字交叉循环链表求解精确覆盖、重复覆盖。 骨牌覆盖、N皇后问题的高效解法。
数据结构算法之跳舞配对
04-27
数据结构算法之跳舞配对：在周末舞会上，男生和女生进入舞厅后，各自排成一队。跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。要求采用链队列实现上述配对算法。
【数据结构】用舞蹈的方式打开排序算法，趣味数据结构，简单易懂。
一个记录积累的地方
02-22 176
文章目录前言插入排序希尔排序冒泡排序快速排序选择排序堆排序归并排序总结 前言 在计算机考研中，数据结构是一门很重要的课程，在开发中更是十分重要。下面几个是我再考研期间发现的宝藏视频，是关于各种排序算法的，分享给大家。 插入排序 插入排序 希尔排序 冒泡排序 快速排序 选择排序 堆排序 堆排序
数据结构c语言版舞蹈配对问题（实验报告）
07-22
班上有m个女生 ，有n个男生（m不等于n），现要开一个舞会，男女生分别以1 ~m和1~n编号，坐在舞池两边的椅子上，每曲开始时，依次从男生和女生中各抽出一人配对跳舞，本曲没成功配对者坐着等待下一曲找舞伴。配对成功的舞伴跳完舞排回各自队伍的最后。 请设计一系统模拟动态地显示上述过程，要求输出第K支舞曲配对情况。
跳跃的舞者，舞蹈链（Dancing Links）算法——求解精确覆盖问题
weixin_33843409的博客
06-30 787
精确覆盖问题的定义：给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1 例如：如下的矩阵 就包含了这样一个集合（第1、4、5行）   如何利用给定的矩阵求出相应的行的集合呢？我们采用回溯法   矩阵1：   先假定选择第1行，如下所示： 如上图中所示，红色的那行是选中的一行，这一行中有3个1，分别是第3、5、6列。 由于这3列已经包含了...
深度学习关键要素：数据集汇总与分享
最新发布
十年以上架构设计经验，专注于软件架构和人工智能领域，对机器视觉、NLP、音视频等领域都有涉猎
08-09 7970
在深度学习的应用中，数据被认为是最重要的因素之一。因此，选择一个好的数据集对于深度学习的成功至关重要。在选择数据集时，不仅需要关注数据量的大小、多样性以及质量，还要考虑数据集是否代表了所研究问题的真实情况。本文整理了当前深度学习领域公开的数据集，供大家训练模型时选择和使用。
部分数据集
tcd1112的博客
01-09 1万+
为防丢失，进行记录 大学公开数据集 (Stanford)69G大规模无人机(校园)图像数据集【Stanford】 http://cvgl.stanford.edu/projects/uav_data/ 人脸素描数据集【CUHK】 http://mmlab.ie.cuhk.edu.hk/archive/facesketch.html 自然语言推理(文本蕴含标记)数据集【NYU】 htt...
Image数据集
it-hao的博客
11-23 1万+
原文链接： （English）http://homepages.inf.ed.ac.uk/rbf/CVonline/Imagedbase.htm#action 一、行动数据库 20bn-Something-Something - 密集标记的视频剪辑，显示人类使用日常物品执行预定义的基本动作（Twenty Billion Neurons GmbH） 3D在线行动数据集 - 有七个行动类别（微软和南...
机器学习数据集的方法 及 数据集资源
ejinxian的专栏
01-21 9472
  亚马逊AWS高级技术顾问Will Badr介绍了8种寻找机器学习数据集的方法 1、Kaggle数据集   Kaggle的数据集中，包含了用于各种任务，不同规模的真实数据集，而且有许多不同的格式。此外，你还可以在这里找到与每个数据集相关联的交互式笔记本Kernels，这些笔记本能够在浏览器中运行。 在这里，每个数据集都是一个小的交流社区，可以讨论数据，寻找一些公开的代码，或者在Kern...
网络编程_8(项目附件)
热门推荐
weixin_38717634的博客
01-13 3万+
dict.txt abandonment n.放弃 abbreviation n.缩写 abeyance n.缓办，中止 abide v.遵守 ability n.能力 able adj.有能力的，能干的 abnormal adj.反常的，变态的 aboard adv.船(车)上 abolish v.废除，取消 abolition n.废除，取消 abortion n.流产 abortive adj.无效果的，失败的 about prep.关于，大约 ab
如何用Visio画数据库实体关系图
走马观花
06-22 7189
http://jingyan.baidu.com/article/e4511cf3374a862b855eaf58.html http://wenku.baidu.com/link?url=-Q09Emmgj2QzUZ81KIX9n3l1N4OhCqCa9ucT8mp4t5GLuCO_Zx5VlBGWEOp_5hMEABL6UzJC2KIkvYYb_YNE2wzCoMfmvuUvLGzO
Vision_字符串_AC自动机
Vision
10-07 492
///定义： /*     （1）AC自动机简介：         首先简要介绍一下AC自动机：Aho-Corasick automation，     该算法在1975年产生于贝尔实验室，是著名的多模匹配算法之一。     一个常见的例子就是给出n个单词，再给出一段包含m个字符的文章，     让你找出有多少个单词在文章里出现过。要搞懂AC自动机，先得有字     典树Trie和K
Vision_MATH_球盒问题+第二类Stirling数
Vision
10-05 485
///定义: /*     排列组合解决球盒的八大问题，其中用到排列组合公式和第二类斯特林公式 */ ///代码： /* **name:第二类斯特林数（第二类Stirling数） **function:解决求不同盒同等问题 **公式： S(r, c) = S(r-1,c-1) + c * S(r-1, c) */ #include #include #include #in
Vision_字符串_字符串哈希(BKDR Hash)
Vision
10-10 462
///定义： /*         将一个字符串哈希成一个数值，使得这些数值的冲突尽量的小。     最直白的是sum = s[0] + s[1] + ... + s[len],其中sum就是s的哈希值。 */ ///代码： /* **name:BKDR Hash **来源：官方模板 */ unsigned int BKDRHash(char *str){ unsigned i
Vision_字符串_后缀数组
Vision
10-05 441
后缀数组
Vision_数据结构_线段树
Vision
10-19 367
///定义： /*     线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间， 每个单元区间对应线段树中的一个叶结点。使用线段树可以快速的查找某一个节点在 若干条线段中出现的次数，时间复杂度为O(logN）。而未优化的空间复杂度为2N，实 际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。 */ ///代码： /* **name:一维线段树 *
Vision_MATH_快速幂||矩阵快速幂
Vision
10-19 339
///定义： /*     快速幂就是快速算底数的n次幂。其时间复杂度为 O(logN)， 与朴素的O(N)相比效率有了极大的提高。     也就是求A^B%mod的值，其中A可以是数字也可以是矩阵（矩阵快速幂） */ ///代码： /* **name:快速幂 **function:求解a^b%mod的值(mod*mod不会爆long long的情况) **输入参数：a,b,m
Vision_MATH_中国剩余定理
Vision
10-17 332
///定义： /*     中国剩余定理给出了以下的一元线性同余方程组：     x ≡ a1 (mod m1)     x ≡ a2 (mod m2)     x ≡ a3 (mod m3)     x ≡ a4 (mod m4)         *         *         *     x ≡ ak (mod mk) */ ///代码： /* **n
vision_msgs安装
07-29
要安装`vision_msgs`，您可以按照以下步骤进行操作： 1. 首先，确保您已经安装了ROS（Robot Operating System）并设置了工作空间。 2. 在终端中，导航到您的ROS工作空间的源文件目录。 3. 使用以下命令克隆`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值