DancingLinks模板

最新推荐文章于 2020-07-07 19:50:30 发布
最新推荐文章于 2020-07-07 19:50:30 发布
阅读量204 收藏 1
点赞数
分类专栏： 模板 文章标签： DancingLinks 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34921856/article/details/79406551
版权
  • 地表最强DLX(必要时需对dancing进行修改)
const int maxnode = 262500;
const int maxn = 750;
const int maxm = 350;
const int inf = 0x3f3f3f;
struct DLX
{
    int n, m, size;
    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[]数组里面0~ansd-1

    int ansnum;
    int theans[maxn];
    void init(int _n, int _m)
    {
        n = _n, m = _m;
        //memset(cans, '\0', sizeof(cans));
        ansnum = 0;
        ansd = inf;
        for (int i = 0;i <= m;i++)
        {
            S[i] = 0;
            U[i] = D[i] = i;//初始状态下,上下自己指向自己(也就知道了头结点的值为i)
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0, L[0] = m;//环状,下面的Link一样也是环,这样，不管从一行中的任意一个结点都可以遍历完这一行.
        size = m;//编号,每列的头结点编号1-m，所以size从m+1开始
        for (int i = 1;i <= n;i++)
            H[i] = -1;
    }

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

    void exact_remove(int 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 repeat_remove(int c)//只删除列
    {
        for (int i = D[c];i != c;i = D[i])
            L[R[i]] = L[i], R[L[i]] = R[i];
    }

    void exact_resume(int 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;
    }

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

    void exact_dance(int d)//深度
    {
        if (R[0] == 0)
        {
            ansnum++;
            memcpy(theans, ans, sizeof(ans));
            ansd = d;
            return;
        }
        int c = R[0];
        for (int i = R[0];i != 0;i = R[i])
            if (S[i] < S[c])
                c = i;
        exact_remove(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])
                exact_remove(Col[j]);
            exact_dance(d + 1);

            for (int j = L[i];j != i;j = L[j])
                exact_resume(Col[j]);
        }
        exact_resume(c);
    }

    int f()  //估价函数
    {
        bool vv[maxm];
        int ret = 0, c, i, j;
        for (c = R[0];c != 0;c = R[c])vv[c] = 1;
        for(c=R[0];c!=0;c=R[c])
            if (vv[c])
            {
                ret++, vv[c] = 0;
                for (i = D[c];i != c;i = D[i])
                    for (j = R[i];j != i;j = R[j])
                        vv[Col[j]] = 0;
            }
        return ret;
    }

    void repeat_dance(int d)
    {
        if (d + f() >= ansd)return;
        if (R[0] == 0)
        {
            if (d < ansd)ansd = d;
            return;
        }
        int c = R[0], i, j;
        for (i = R[0];i;i = R[i])
            if (S[i] < S[c])c = i;
        for (i = D[c];i != c;i = D[i])
        {
            repeat_remove(i);
            for (j = R[i];j != i;j = R[j])repeat_remove(j);
            repeat_dance(d + 1);
            for (j = L[i];j != i;j = L[j])repeat_resume(j);
            repeat_resume(i);
        }
    }
};
DLX x;
  • 模板（poj3740）
#include<iostream>
#include<stdio.h>
#include<cstring>

using namespace std;
const int maxnode = 60000;
const int maxn = 20;
const int maxm = 305;

struct DLX
{
    int n, m, size;
    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[]数组里面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;//初始状态下,上下自己指向自己(也就知道了头结点的值为i)
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0, L[0] = m;//环状,下面的Link一样也是环,这样，不管从一行中的任意一个结点都可以遍历完这一行.
        size = m;//编号,每列的头结点编号1-m，所以size从m+1开始
        for (int i = 1;i <= n;i++)
            H[i] = -1;
    }

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

    void remove(int 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),以及恢复所有在这一列的节点所在的行中的所有的节点。
    {
        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;
        remove(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])
                remove(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 x;


int main()
{
    int M, N;
    while (~scanf("%d %d",&M,&N))
    {
        x.init(M, N);
        int num;
        for(int i=1;i<=M;i++)
            for (int j = 1;j <= N;j++)
            {
                scanf("%d", &num);
                if(num)x.link(i, j);
            }
        if (!x.dance(0))
            puts("It is impossible");
        else
            puts("Yes, I found it");
    }
    return 0;


}
  • 求数独
#include<iostream>
#include<stdio.h>
#include<cstring>

using namespace std;
const int maxnode = 60000;
const int maxn = 800;
const int maxm = 350;

struct DLX
{
    int n, m, size;
    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[]数组里面0~ansd-1
    char cans[9 * 9 + 10];
    void init(int _n, int _m)
    {
        n = _n, m = _m;
        memset(cans, '\0', sizeof(cans));
        for (int i = 0;i <= m;i++)
        {
            S[i] = 0;
            U[i] = D[i] = i;//初始状态下,上下自己指向自己(也就知道了头结点的值为i)
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0, L[0] = m;//环状,下面的Link一样也是环,这样，不管从一行中的任意一个结点都可以遍历完这一行.
        size = m;//编号,每列的头结点编号1-m，所以size从m+1开始
        for (int i = 1;i <= n;i++)
            H[i] = -1;
    }

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

    void remove(int 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),以及恢复所有在这一列的节点所在的行中的所有的节点。
    {
        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;
        remove(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])
                remove(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;
    }
    void out()
    {
        int kinds, num;
        for (int i = 0;i < ansd;i++)
        {
            kinds = (ans[i]-1) % 9+1;
            num = (ans[i]-1) / 9+1;
            cans[num] = kinds + '0';
        }
        printf("%s\n", cans+1);
    }
};

DLX x;


int main()
{
    char s[9 * 9 + 10];
    while (~scanf("%s",s+1))
    {
        if (s[1] == 'e')break;
        x.init(9 * 9 * 9, 324);
        int Size = strlen(s + 1);
        for (int i = 1;i <= Size;i++)
        {
            int row = (i - 1) / 9 + 1;
            int col = (i - 1) % 9 + 1;
            int grid = ((row - 1) / 3) * 3 + (col - 1) / 3 + 1;
            if (s[i] == '.')
            {
                for (int k = 1;k <= 9;k++)
                {
                    x.link((i - 1) * 9 + k, i);
                    x.link((i - 1) * 9 + k, 81 + (row - 1) * 9+k);
                    x.link((i - 1) * 9 + k, 81 * 2 + (col - 1) * 9+k);
                    x.link((i - 1) * 9 + k, 81 * 3 + (grid - 1) * 9 + k);
                }
            }
            else
            {
                int temp = s[i] - '0';
                x.link((i - 1) * 9 + temp, i);
                x.link((i - 1) * 9 + temp, 81+(row - 1) * 9 + temp);
                x.link((i - 1) * 9 + temp, 81 * 2 + (col - 1) * 9 + temp);
                x.link((i - 1) * 9 + temp, 81 * 3 + (grid - 1) * 9 + temp);
            }
        }
        x.dance(0);
        x.out();

    }


}
大学要有梦想
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dancing links 模板
01-16
提供dancing links 的模板，适合ACMer 使用，
dancing links 骑士遍历
07-10
dancing links 解决骑士遍历问题，实验报告，含源代码
Dancing Link --- 模板题 HUST 1017 - Exact cover
weixin_33674976的博客
04-14 106
 1017 - Exact cover Problem's Link:   http://acm.hust.edu.cn/problem/show/1017   Mean:  给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1   analyse: 初学DLX。 这是DLX处理的最简单的问题，也是模板题。 Time complexity: O...
Dancing Links 模板
skyfisherman的专栏
10-30 737
终于搞清楚了Dancing links是怎么写的了，并用P和C各写了一遍 program poj_3740; var l,r,u,d,ch:array[0..10000]of longint; lin,col,size,o:array[0..1000]of longint; mx,bj,st,i,j,m,n,x,head:longint; procedure origin(
模板 - DancingLinks
aoying6521的博客
08-28 128
#include<bits/stdc++.h> using namespace std; typedef long long ll; const int N = 9; const int MaxN = N * N * N + 10; const int MaxM = N * N * 4 + 10; const int maxnode = MaxN * 4 + MaxM + ...
Dancing links 模板
做一只熊猫不好吗？
07-07 202
Dancing links 模板 知识点传送门 用途：精确覆盖问题：给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1 代码 #include<iostream> #include<algorithm> #include<cstring> #include<queue> #include<map> #include<string> #include<cstdio> #include
Dancing Links中文版
08-10
### Dancing Links中文版：一种高效的回溯算法应用 #### 精确覆盖问题与Dancing Links Dancing Links，简称DLX，是由Donald E. Knuth教授在斯坦福大学提出的一种算法，主要用于解决精确覆盖问题（Exact Cover ...
dancing links X的相关资料
10-26
【标题】：“Dancing Links X”算法详解 【描述】：Dancing Links（跳舞链接）是一种高效的回溯算法，由Donald Knuth在2000年提出，主要用于解决全排列、数独等组合优化问题。它以其独特的数据结构和操作方式，显著...
Dancing Links 中文版
10-08
**Dancing Links 中文版** Dancing Links 是一种算法，由计算机科学家 Donald Knuth 提出，主要用于解决全排列、组合优化和其他与回溯法相关的计算问题。这个算法的名字源自于跳舞的人的形象，因为在数据结构中，...
模板_DancingLink(Algorithm X)
BeiYu
02-06 1177
关于舞蹈链(DLX)原理传送门#include<cstdio> #include<cstring> #define N 9*9*9*9*9*4+10 #define M 9*9*9+10 struct DancingLink{ int n,s,ansd;//列数 节点总数 int S[M],A[M],H[M];//S[]该列节点总数 A[]答案 H[]行首指针 int
Dance Links X模板（转自 Kuangbin）
YancyKahn
09-27 439
【Dance Links X】 Dance Links X 舞蹈链算法， 原理为一个双端十字链表的数据结构， 主要用于处理精确覆盖问题（解决n皇后问题， 数独问题）。 下面的代码为 【ZOJ-3209 Treasure Map】的题解， 此题要求的是整个面积的覆盖， 把每个格子当成一个列， 然后用模板跑一次就行。 #include &amp;lt;bits/stdc++.h&amp;gt; using name...
dancing link模板
dehs8915的博客
08-24 126
1 #include<cstdio> 2 #include<iostream> 3 #include<cstring> 4 #include<algorithm> 5 #include<cmath> 6 #include<iomanip> 7 using namespac...
dancing links精确覆盖模版
w750636248的专栏
03-11 997
#include #include #include #include #include #include using namespace std; const int N=1000009,INF=0xffffff; int n,m;///构造n行m列 int U[N],D[N],L[N],R[N]; int row[N],col[N]; int S[N],H[N],ans[N];
Sudoku 数独 Dancing Links模板
魔神翼
08-05 3219
推荐论文： momodi的《Dancing Links 在搜索中的应用》、Knuth的DLX论文、陈丹琦的《Dancing Links的应用》   Dancing Links是用来优化一类精确覆盖问题中的DFS过程。 精确覆盖问题是指在一个01矩阵中，选出一些行使每一列有且
Dancing Links ---- D - Sudoku
qq_36386435的博客
10-02 300
In the game of Sudoku, you are given a large 9 × 9 grid divided into smaller 3 × 3 subgrids. For example, . 2 7 3 8 . . 1 . . 1 . . . 6 7 3 5 . . . . . . . 2 9 3 . 5 6 9 2 . 8 . . . . . . . . . . . 6 ...
解题报告 (一) Dancing Links X
热门推荐
英雄哪里出来
01-28 30万+
Dancing Links、数独、精确覆盖、重复覆盖
简单易懂的Dancing links讲解（1）
mu399的专栏
06-03 2万+
最早接触Dancing Links的时候，是在csdn论坛上逛的时候，发现有人在研究数独程序，由于本人开发过数独游戏，就进去看了看，发现有人说用Dancing Links来求解数独最快了，于是我就决定去了解一下Dancing Links。 1.   Dancing Links是什么？ Dancing Links是一类搜索问题的通用优化,对精确覆盖问题有奇效，也可解决重复覆盖问题，D
"深入探讨计算机程序设计艺术：第4卷第5册C Dancing Links1
Knuth, titled "Dancing Links", delves into the intricacies of computer program design. This volume explores the concept of Dancing Links, a data structure used in algorithm implementation and problem...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值