dancing links x（舞蹈链算法）

最新推荐文章于 2021-02-21 19:20:11 发布
最新推荐文章于 2021-02-21 19:20:11 发布
阅读量206 收藏
点赞数
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhe_zhenbuhui_a/article/details/107777406
版权

舞蹈链算法详解

ZOJ 3209 题目链接

题意

给定P个完整矩形的小矩形，找到最少的可以填充原来完整矩阵的矩形数

思路

DLX（精准覆盖）算法，把p个矩形当成行，把每一小格当成列（有nm小格），然后填充精确填充nm列即可

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
const int N = 505;
const int M = 905;
struct node{
    int n,m,id;
    int U[N * M],D[N * M],R[N * M],L[N * M],Row[N * M],Col[N * M];
    int H[N];/// 行头结点
    int S[M];
    int ansd,ans[N];
    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;
        }
        L[0] = m;
        R[m] = 0;
        id = m;
        for (int i = 1; i <= n; i++){
            H[i] = -1;
        }
    }
    void link(int r,int c){
        Col[++id] = c;
        S[c]++;
        Row[id] = r;
        D[id] = D[c];
        U[D[c]] = id;
        U[id] = c;
        D[c] = id;
        if (H[r] < 0){
            H[r] = L[id] = R[id] = id;
        }
        else {
            R[id] = R[H[r]];
            L[R[H[r]]] = id;
            L[id] = H[r];
            R[H[r]] = id;
        }
    }
    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 = 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]){
                U[D[j]] = D[U[j]] = j;
                S[Col[j]]++;
            }
        }
        L[R[c]] = R[L[c]] = c;
    }
    void dance(int deep){
        if (ansd != -1 && ansd <= deep) return ;
        if (R[0] == 0){
            if (ansd == -1) ansd = deep;
            ansd = min(ansd,deep);
            return ;
        }
        int c = R[0];
        for (int i = R[0]; i != 0; i = R[i]){
            if (S[i] < S[c]) {
                c = i;
            }
        }
        Remove(c);
        for (int i = D[c]; i != c; i = D[i]){
            ans[deep] = Row[i];
            for (int j = R[i]; j != i; j = R[j]){
                Remove(Col[j]);
            }
            dance(deep + 1);
            for (int j = L[i]; j != i; j = L[j]){
                Resume(Col[j]);
            }
        }
        Resume(c);
    }
}DLX;
int pos[33][33];
void get_pos(int n,int m)
{
    int cnt = 1;
    for (int i = 1; i <= n; i++){
        for (int j = 1; j <= m; j++){
            pos[i][j] = cnt++;
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        int n,m,p;
        scanf("%d %d %d",&n,&m,&p);
        DLX.init(p,n * m);
        get_pos(n,m);
        for (int r = 1; r <= p; r++){
            int x1,y1,x3,y3; 
            scanf("%d %d %d %d",&x1,&y1,&x3,&y3);
            for (int i = x1 + 1; i <= x3; i++){
                for (int j = y1 + 1; j <= y3; j++){
                    DLX.link(r,pos[i][j]);
                }
            }
        }
        DLX.ansd = -1;
        DLX.dance(0);
        printf("%d\n",DLX.ansd);
    }
    return 0;
}

HDU 2295 题目链接

题意

n个城市，m个雷达，雷达有限制，问雷达的最小半径是多少可以覆盖所有城市

思路

雷达为行，城市为列，DLX重复覆盖，二分查找半径跑一遍DLX
DLX中的calc类似A*算法的评估函数

#include <cstdio>
#include <cmath>
#include <iostream>
#include <cstring>
using namespace std;
const double eps = 1e-8;
const int N = 66;
const int M = 66;
int limit;
struct node{
    int n,m,id;
    int U[N * M],D[N * M],R[N * M],L[N * M],Row[N * M],Col[N * M];
    int H[N];/// 行头结点
    int S[M];
    bool v[N * M];
    int ansd,ans[N];
    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;
        }
        L[0] = m;
        R[m] = 0;
        id = m;
        for (int i = 1; i <= n; i++){
            H[i] = -1;
        }
    }
    void link(int r,int c)
    {
        Col[++id] = c;
        S[c]++;
        Row[id] = r;
        D[id] = D[c];
        U[D[c]] = id;
        U[id] = c;
        D[c] = id;
        if (H[r] < 0){
            H[r] = L[id] = R[id] = id;
        }
        else {
            R[id] = R[H[r]];
            L[R[H[r]]] = id;
            L[id] = H[r];
            R[H[r]] = id;
        }
    }
    void Remove(int c)
    {
        for (int i = D[c]; i != c; i = D[i]){
            L[R[i]] = L[i];
            R[L[i]] = R[i];
        }
    }
    void Resume(int c)
    {
        for (int i = U[c]; i != c; i = U[i]){
            L[R[i]] = R[L[i]] = i;
        }
    }
    int calc()
    {
        int cnt = 0;
        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]){
                cnt++;
                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 cnt;
    }
    bool dance(int deep)
    {
        if (deep + calc() > limit) return false;
        if (deep > limit) return false;
        if (R[0] == 0) return true;
        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]){
            Remove(i);
            for (int j = R[i]; j != i; j = R[j]){
                Remove(j);
            }
            if (dance(deep + 1)) return true;
            for (int j = L[i]; j != i; j = L[j]){
                Resume(j);
            }
            Resume(i);
        }
        return false;
    }
}DLX;
struct Point{
    double x,y;
}city[55],radar[55];
double dist(int i,int j)
{
    return sqrt((city[i].x - radar[j].x) * (city[i].x - radar[j].x) + (city[i].y - radar[j].y) * (city[i].y - radar[j].y));
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        int n,m;
        scanf("%d %d %d",&n,&m,&limit);
        for (int i = 1; i <= n; i++){
            scanf("%lf %lf",&city[i].x,&city[i].y);
        }
        for (int j = 1; j <= m; j++){
            scanf("%lf %lf",&radar[j].x,&radar[j].y);
        }
        double l = 0,r = 1e5;
        while(r - l >= eps){
            double mid = (l + r) / 2.0;
            DLX.init(m,n);
            for (int i = 1; i <= n; i++){
                for (int j = 1; j <= m; j++){
                    if (dist(i,j) <= mid){
                        DLX.link(j,i);
                    }
                }
            }
            if (DLX.dance(0)) r = mid;
            else l = mid;
        }
        printf("%.6f\n",r);
    }
    return 0;
}

POJ 1084 题目链接

题意

有很多个火柴形成的正方形，有m个火柴已被破坏，问还需要破坏多少个火柴才能破坏所有的正方形

思路

把正方形当成列，火柴当成行，把所有的正方形破坏，就相当于选择所有的列
DLX重复覆盖
预处理所有的火柴和正方形的行列关系，然后标记m个火柴，把这些已经破坏的正方形列去掉
(也可以写个remove1函数(不会写，照抄别人的)，在添加所有的结点后，再把m个火柴破坏的列去掉)

void remove1(int r)
    {
        if(H[r]==-1)
            return;

        for(int i=U[H[r]];i!=H[r];i=U[i])
        {
            if(H[row[i]]==i)            // !!!
            {
                if(R[i]==i)
                    H[row[i]]=-1;
                else
                    H[row[i]]=R[i];
            }

            L[R[i]]=L[i];
            R[L[i]]=R[i];
        }

        for(int i=R[H[r]];i!=H[r];i=R[i])
            for(int j=U[i];j!=i;j=U[j])
            {
                if(H[row[j]]==j)
                {
                    if(R[j]==j)
                        H[row[j]]=-1;
                    else
                        H[row[j]]=R[j];
                }

                L[R[j]]=L[j];
                R[L[j]]=R[j];
            }
    }

#include <cstdio>
#include <cmath>
#include <iostream>
#include <vector>
#include <cstring>
using namespace std;
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const int N = 222;
const int M = 222;
struct node{
    int n,m,id;
    int U[N * M],D[N * M],R[N * M],L[N * M],Row[N * M],Col[N * M];
    int H[N];/// 行头结点
    int S[M];
    bool v[N * M];
    int ansd,ans[N];
    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;
        }
        L[0] = m;
        R[m] = 0;
        id = m;
        for (int i = 1; i <= n; i++){
            H[i] = -1;
        }
    }
    void link(int r,int c)
    {
        Col[++id] = c;
        S[c]++;
        Row[id] = r;
        D[id] = D[c];
        U[D[c]] = id;
        U[id] = c;
        D[c] = id;
        if (H[r] < 0){
            H[r] = L[id] = R[id] = id;
        }
        else {
            R[id] = R[H[r]];
            L[R[H[r]]] = id;
            L[id] = H[r];
            R[H[r]] = id;
        }
    }
    void Remove(int c)
    {
        for (int i = D[c]; i != c; i = D[i]){
            L[R[i]] = L[i];
            R[L[i]] = R[i];
        }
    }
    void Resume(int c)
    {
        for (int i = U[c]; i != c; i = U[i]){
            L[R[i]] = R[L[i]] = i;
        }
    }
    int calc()
    {
        int cnt = 0;
        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]){
                cnt++;
                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 cnt;
    }
    void dance(int deep)
    {
        if  (deep + calc() >= ansd) return ;
        if (R[0] == 0) {
            ansd = min(ansd,deep);
            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]){
            Remove(i);
            for (int j = R[i]; j != i; j = R[j]){
                Remove(j);
            }
            dance(deep + 1);
            for (int j = L[i]; j != i; j = L[j]){
                Resume(j);
            }
            Resume(i);
        }
    }
}DLX;
int id[66][66];
int num1[6] = {0,4,12,24,40,60};
int num2[6] = {0,1,5,14,30,55};
bool vis[66];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        int n,m;
        scanf("%d %d",&n,&m);
        int gap = 2 * n + 1;
        int cnt = 0;
        memset(id,0,sizeof(id));
        for (int len = 1; len <= n; len++){     /// 正方形边长
            for (int i = 1; i <= (n - len) * gap + 1; i += gap){   /// 正方形的一层中的第一个火柴编号
                for (int j = i; j - i <= n - len; j++){           /// 遍历正方形的一层
                    ++cnt;
                    for (int k = j; k - j + 1 <= len; k++){        /// 把正方形的上下火柴标记
                        id[k][cnt] = 1;
                        id[k + len * gap][cnt] = 1;
                    //    cout << "cnt = " << cnt << " " << k << " " << k + len * gap << endl;
                    }
                    for (int k = j + n; k <= j + n + gap * (len - 1); k += gap){        /// 把正方形的左右火柴标记
                        id[k][cnt] = 1;
                        id[k + len][cnt] = 1;
                   //     cout << "cnt = " << cnt << " " << k << " " << k + len << endl;
                    }
                }
            }
        }
        int sum = 2 * n * (n + 1);
        DLX.init(sum,cnt);
        memset(vis,true,sizeof(vis));
        for (int i = 0; i < m; i++){
            int x;
            scanf("%d",&x);
            for (int j = 1; j <= num2[n]; j++){
                if (id[x][j] && vis[j]){
                    vis[j] = false;
                    DLX.R[DLX.L[j]] = DLX.R[j];
                    DLX.L[DLX.R[j]] = DLX.L[j];
                    DLX.R[j] = DLX.L[j] = 0;
                }
            }
        }
        for (int i = 1; i <= num1[n]; i++){
            for (int j = 1; j <= num2[n]; j++){
                if (id[i][j] && vis[j]) {
                    DLX.link(i,j);
                }
            }
        }
        DLX.ansd = INF;
        DLX.dance(0);
        printf("%d\n",DLX.ansd);
    }
    return 0;
}

POJ 3074 题目链接

题意

9个3*3的数独

思路

在这里插入图片描述
转化成DLX精准覆盖问题

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
const int N = 1111 * 4;
const int M = 1111;
struct node{
    int n,m,id;
    int U[N * M],D[N * M],R[N * M],L[N * M],Row[N * M],Col[N * M];
    int H[N];/// 行头结点
    int S[M];
    int ansd,ans[N];
    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;
        }
        L[0] = m;
        R[m] = 0;
        id = m;
        for (int i = 1; i <= n; i++){
            H[i] = -1;
        }
    }
    void link(int r,int c){
        Col[++id] = c;
        S[c]++;
        Row[id] = r;
        D[id] = D[c];
        U[D[c]] = id;
        U[id] = c;
        D[c] = id;
        if (H[r] < 0){
            H[r] = L[id] = R[id] = id;
        }
        else {
            R[id] = R[H[r]];
            L[R[H[r]]] = id;
            L[id] = H[r];
            R[H[r]] = id;
        }
    }
    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 = 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]){
                U[D[j]] = D[U[j]] = j;
                S[Col[j]]++;
            }
        }
        L[R[c]] = R[L[c]] = c;
    }
    bool dance(int deep)
    {
        if (R[0] == 0){
            ansd = deep;
            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);
        for (int i = D[c]; i != c; i = D[i]){
            ans[deep] = Row[i];
            for (int j = R[i]; j != i; j = R[j]){
                Remove(Col[j]);
            }
            if (dance(deep + 1)) return true;
            for (int j = L[i]; j != i; j = L[j]){
                Resume(Col[j]);
            }
        }
        Resume(c);
        return false;
    }
}DLX;
char str[99];
int main()
{
    while(scanf("%s",str) != EOF && str[0] != 'e'){
        DLX.init(81 * 9,81 * 4);
        for (int i = 0; i < 9; i++){
            for (int j = 0; j < 9; j++){
                int x = i, y = j,z = i / 3 * 3 + j / 3;
                int id = i * 9 + j;
                if (str[id] == '.'){
                    for (int k = 1; k <= 9; k++){     /// 每一个位置有九种情况(连接对应的数字和行列方格)
                        DLX.link(id * 9 + k,id + 1);             /// 数字
                        DLX.link(id * 9 + k,81 + x * 9 + k);     /// 行
                        DLX.link(id * 9 + k,162 + y * 9 + k);    /// 列
                        DLX.link(id * 9 + k,243 + z * 9 + k);    /// 小方格
                    }
                }
                else {
                    int k = str[id] - '0';
                    DLX.link(id * 9 + k,id + 1);             /// 数字
                    DLX.link(id * 9 + k,81 + x * 9 + k);     /// 行
                    DLX.link(id * 9 + k,162 + y * 9 + k);    /// 列
                    DLX.link(id * 9 + k,243 + z * 9 + k);    /// 小方格
                }
            }
        }
        DLX.dance(0);
        for (int i = 0; i < DLX.ansd; i++){
            int k = DLX.ans[i];
            int a = (k - 1) / 9;  
            int b = (k - 1) % 9 + '1';
            str[a / 9 * 9 + a % 9] = b;
        }
        puts(str);
    }
    return 0;
}

HDU 4069 题目链接

题意

变形版数独，之前的3*3小格变成的连通块
输入的数字为五个数的和，代表那一个块的上下左右是否有墙

思路

先跑一个dfs把每一个块标记出来
注意第一次找到的时候保存结果（因为后面寻找会改变结果）
找到第二个就立刻退出，不然会超时

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
const int N = 10;
const int NM = N * N * N * 4 + N * N * 4 + N;
const int M = N * N * N + N;
struct node{
    int n,m,id;
    int U[NM],D[NM],R[NM],L[NM],Row[NM],Col[NM];
    int H[NM];/// 行头结点
    int S[NM];
    int ansd,ans[M],cnt,real[N * N];
    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;
        }
        L[0] = m;
        R[m] = 0;
        id = m;
        cnt = 0;
        for (int i = 1; i <= n; i++){
            H[i] = -1;
        }
    }
    void link(int r,int c){
        Col[++id] = c;
        S[c]++;
        Row[id] = r;
        D[id] = D[c];
        U[D[c]] = id;
        U[id] = c;
        D[c] = id;
        if (H[r] < 0){
            H[r] = L[id] = R[id] = id;
        }
        else {
            R[id] = R[H[r]];
            L[R[H[r]]] = id;
            L[id] = H[r];
            R[H[r]] = id;
        }
    }
    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 = 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]){
                U[D[j]] = D[U[j]] = j;
                S[Col[j]]++;
            }
        }
        L[R[c]] = R[L[c]] = c;
    }
    void dance(int deep)
    {
        if (R[0] == 0){
            cnt++;
            if (cnt > 1) return ;
            ansd = deep;
            for (int i = 0; i < deep; i++){
                real[(ans[i] - 1) / 9] = (ans[i] - 1) % 9 + 1;
            }
            return ;
        }
        int c = R[0];
        for (int i = R[0]; i != 0; i = R[i]){
            if (S[i] < S[c]) {
                c = i;
            }
        }
        Remove(c);
        for (int i = D[c]; i != c; i = D[i]){
            ans[deep] = Row[i];
            for (int j = R[i]; j != i; j = R[j]){
                Remove(Col[j]);
            }
            dance(deep + 1);
            if (cnt > 1) return ;
            for (int j = L[i]; j != i; j = L[j]){
                Resume(Col[j]);
            }
        }
        Resume(c);
    }
}DLX;
int g[N][N];
int id[N][N];
int hinder[N][N][4];
int to[4][2] = {0,-1,1,0,0,1,-1,0};
int num;
void dfs(int x,int y)
{
    id[x][y] = num;
    for (int i = 0; i < 4; i++){
        int xx = x + to[i][0];
        int yy = y + to[i][1];
        if (id[xx][yy] || hinder[x][y][i]) continue;
        dfs(xx,yy);
    }
}
int main()
{

    int t,Case = 1;
    scanf("%d",&t);
    while(t--){
        memset(hinder,0,sizeof(hinder));
        for (int i = 0; i < 9; i++){
            for (int j = 0; j < 9; j++){
                scanf("%d",&g[i][j]);
                if (g[i][j] >= 128) {
                    hinder[i][j][0] = 1;
                    g[i][j] -= 128;
                }
                if (g[i][j] >= 64){
                    hinder[i][j][1] = 1;
                    g[i][j] -= 64;
                }
                if (g[i][j] >= 32) {
                    hinder[i][j][2] = 1;
                    g[i][j] -= 32;
                }
                if (g[i][j] >= 16){
                    hinder[i][j][3] = 1;
                    g[i][j] -= 16;
                }
            }
        }
        num = 1;
        memset(id,0,sizeof(id));
        for (int i = 0; i < 9; i++){
            for (int j = 0; j < 9; j++){
                if (!id[i][j]) {
                    dfs(i,j);
                    num++;
                }
            }
        }
        DLX.init(81 * 9,81 * 4);
        for (int i = 0; i < 9; i++){
            for (int j = 0; j < 9; j++){
                int x = i,y = j,z = id[i][j] - 1;
                int tem = i * 9 + j;
                if (!g[i][j]){
                    for (int k = 1; k <= 9; k++){
                        DLX.link(tem * 9 + k,tem + 1);
                        DLX.link(tem * 9 + k,81 + x * 9 + k);
                        DLX.link(tem * 9 + k,162 + y * 9 + k);
                        DLX.link(tem * 9 + k,243 + z * 9 + k);
                    }
                }
                else {
                    int k = g[i][j];
                    DLX.link(tem * 9 + k,tem + 1);
                    DLX.link(tem * 9 + k,81 + x * 9 + k);
                    DLX.link(tem * 9 + k,162 + y * 9 + k);
                    DLX.link(tem * 9 + k,243 + z * 9 + k);
                }
            }
        }
        DLX.dance(0);
        printf("Case %d:\n",Case++);
        if (DLX.cnt == 0) printf("No solution\n");
        else if (DLX.cnt > 1) printf("Multiple Solutions\n");
        else {
            for (int i = 0; i < DLX.ansd; i++){
                printf("%d",DLX.real[i]);
                if (i % 9 == 8) printf("\n");
            }
        }
    }
    return 0;
}

HDU 3335 题目链接

题意

给出n个数，找出最多的两两不能相除的数

思路

DLX最大可重复覆盖，num[i]与num[j]可以相除就在i行j列和j行i列标1
(我也不知道为什么最大可重复覆盖可以解)
（这道题用二分图匹配也可以解，但是建图的时候是有向图）

for (int i = 0; i < n; i++){
            for (int j = 0; j < i; j++){
                if (a[i] % a[j] == 0 || a[j] % a[i] == 0){
                    g[i][j] = true;
                }
            }
        }

#include <cstdio>
#include <cmath>
#include <iostream>
#include <cstring>
using namespace std;
const double eps = 1e-8;
const int NM = 1000010;
const int N = 1111;
const int M = 1111;
struct node{
    int n,m,id;
    int U[NM],D[NM],R[NM],L[NM],Row[NM],Col[NM];
    int H[N];/// 行头结点
    int S[N];
    bool v[NM];
    int ansd,ans[N];
    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;
        }
        L[0] = m;
        R[m] = 0;
        id = m;
        for (int i = 1; i <= n; i++){
            H[i] = -1;
        }
    }
    void link(int r,int c)
    {
        Col[++id] = c;
        S[c]++;
        Row[id] = r;
        D[id] = D[c];
        U[D[c]] = id;
        U[id] = c;
        D[c] = id;
        if (H[r] < 0){
            H[r] = L[id] = R[id] = id;
        }
        else {
            R[id] = R[H[r]];
            L[R[H[r]]] = id;
            L[id] = H[r];
            R[H[r]] = id;
        }
    }
    void Remove(int c)
    {
        for (int i = D[c]; i != c; i = D[i]){
            L[R[i]] = L[i];
            R[L[i]] = R[i];
        }
    }
    void Resume(int c)
    {
        for (int i = U[c]; i != c; i = U[i]){
            L[R[i]] = R[L[i]] = i;
        }
    }
    int calc()
    {
        int cnt = 0;
        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]){
                cnt++;
                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 cnt;
    }
    void dance(int deep)
    {
        if (deep + calc() <= ansd) return ;
        if (R[0] == 0) {
            ansd = deep;
            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]){
            Remove(i);
            for (int j = R[i]; j != i; j = R[j]){
                Remove(j);
            }
            dance(deep + 1);
            for (int j = L[i]; j != i; j = L[j]){
                Resume(j);
            }
            Resume(i);
        }
    }
}DLX;
long long a[N];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        int n;
        scanf("%d",&n);
        DLX.init(n,n);
        for (int i = 1; i <= n; i++){
            scanf("%I64d",&a[i]);
        }
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= i; j++){
                if ((a[i] % a[j] == 0) || (a[j] % a[i] == 0)){
                    DLX.link(i,j);
                    DLX.link(j,i);
                }
            }
        }
        DLX.ansd = 0;
        DLX.dance(0);
        printf("%d\n",DLX.ansd);
    }
    return 0;
}

HDU 4979 题目链接

题意

n选m彩票中,至少买几张彩票保证至少能中r个数.

思路

使用二进制代表选择的号码
C(n,m)当作行，C(n,r)当作列
要打表,8,5,4这个有点慢

///打表主函数
int main()
{
    int t,Case = 1;
    scanf("%d",&t);
    while(t--){
        int n,m,r;
      //  scanf("%d %d %d",&n,&m,&r);
        for (int i = 1; i <= 8; i++){
            for (int j = 1; j <= i; j++){
                for (int k = 1; k <= j; k++){
                    n = i;
                    m = j;
                    r = k;
                    if (n == 8 && m == 5 && r == 4) continue;
                    int sum1 = fac(n) / fac(m) / fac(n - m);
                    int sum2 = fac(n) / fac(r) / fac(n - r);
                    DLX.init(sum1,sum2);
                    int cnt1 = 0,cnt2 = 0;
                    for (int i = 1; i < pow(2,n); i++){
                        if (calc(i,n) == m) num1[++cnt1] = i;
                        if (calc(i,n) == r) num2[++cnt2] = i;
                    }
                    for (int i = 1; i <= cnt1; i++){
                        for (int j = 1; j <= cnt2; j++){
                            if ((num1[i] & num2[j]) == num2[j]){
                                DLX.link(i,j);
                            }
                        }
                    }
                    DLX.ansd = INF;
                    DLX.dance(0);
                    printf("n = %d m = %d r = %d 总数为:",n,m,r);
                    printf("%d\n",DLX.ansd);
                }
            }
        }
    }
    return 0;
}

#include <cstdio>
#include <cmath>
#include <iostream>
#include <cstring>
using namespace std;
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const int NM = 1000010;
const int N = 1111;
const int M = 1111;
struct node{
    int n,m,id;
    int U[NM],D[NM],R[NM],L[NM],Row[NM],Col[NM];
    int H[N];/// 行头结点
    int S[N];
    bool v[NM];
    int ansd,ans[N];
    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;
        }
        L[0] = m;
        R[m] = 0;
        id = m;
        for (int i = 1; i <= n; i++){
            H[i] = -1;
        }
    }
    void link(int r,int c)
    {
        Col[++id] = c;
        S[c]++;
        Row[id] = r;
        D[id] = D[c];
        U[D[c]] = id;
        U[id] = c;
        D[c] = id;
        if (H[r] < 0){
            H[r] = L[id] = R[id] = id;
        }
        else {
            R[id] = R[H[r]];
            L[R[H[r]]] = id;
            L[id] = H[r];
            R[H[r]] = id;
        }
    }
    void Remove(int c)
    {
        for (int i = D[c]; i != c; i = D[i]){
            L[R[i]] = L[i];
            R[L[i]] = R[i];
        }
    }
    void Resume(int c)
    {
        for (int i = U[c]; i != c; i = U[i]){
            L[R[i]] = R[L[i]] = i;
        }
    }
    int calc()
    {
        int cnt = 0;
        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]){
                cnt++;
                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 cnt;
    }
    void dance(int deep)
    {
        if (deep + calc() >= ansd) return ;
        if (R[0] == 0) {
            ansd = min(ansd,deep);
            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]){
            Remove(i);
            for (int j = R[i]; j != i; j = R[j]){
                Remove(j);
            }
            dance(deep + 1);
            for (int j = L[i]; j != i; j = L[j]){
                Resume(j);
            }
            Resume(i);
        }
    }
}DLX;
int fac(int n)
{
    int ans = 1;
    for (int i = 1; i <= n; i++){
        ans *= i;
    }
    return ans;
}
int calc(int x,int n)
{
    int ans = 0;
    for (int i = 0; i < n; i++){
        if ((1 << i) & x) ans++;
    }
    return ans;
}
int num1[111];
int num2[111];
int ans[]{
0,8,4,28,3,11,56,2,6,14,70,2,4,8,20,56,2,3,4,7,12,28,
2,3,4,5,6,7,8,1,1,1,1,1,1,1,1
};
int main()
{
    int t,Case = 1;
    scanf("%d",&t);
    while(t--){
        int n,m,r;
        scanf("%d %d %d",&n,&m,&r);
        if (n == 8){
            int num = 1,res;
            bool flag = false;
            for (int i = 1; i <= 8; i++){
                for (int j = 1; j <= i; j++){
                    if (m == i && r == j){
                        res = ans[num];
                        flag = true;
                    }
                    if (flag) break;
                    num++;
                }
            }
            printf("Case #%d: %d\n",Case++,res);
            continue;
        }
        int sum1 = fac(n) / fac(m) / fac(n - m);
        int sum2 = fac(n) / fac(r) / fac(n - r);
        DLX.init(sum1,sum2);
        int cnt1 = 0,cnt2 = 0;
        for (int i = 1; i < pow(2,n); i++){
            if (calc(i,n) == m) num1[++cnt1] = i;
            if (calc(i,n) == r) num2[++cnt2] = i;
        }
        for (int i = 1; i <= cnt1; i++){
            for (int j = 1; j <= cnt2; j++){
                if ((num1[i] & num2[j]) == num2[j]){
                    DLX.link(i,j);
                }
            }
        }
        DLX.ansd = INF;
        DLX.dance(0);
        printf("Case #%d: %d\n",Case++,DLX.ansd);
    }
    return 0;
}

HDU 5046 题目链接

题意

n个城市,建立k个机场，求所有城市到机场的最小距离

思路

二分，类似HDU2295，注意long long

#include <cstdio>
#include <cmath>
#include <iostream>
#include <cstring>
using namespace std;
typedef long long ll;
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const int NM = 1000010;
const int N = 1111;
const int M = 1111;
int limit;
struct dlx{
    int n,m,id;
    int U[NM],D[NM],R[NM],L[NM],Row[NM],Col[NM];
    int H[N];/// 行头结点
    int S[N];
    bool v[NM];
    int ansd,ans[N];
    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;
        }
        L[0] = m;
        R[m] = 0;
        id = m;
        for (int i = 1; i <= n; i++){
            H[i] = -1;
        }
    }
    void link(int r,int c)
    {
        Col[++id] = c;
        S[c]++;
        Row[id] = r;
        D[id] = D[c];
        U[D[c]] = id;
        U[id] = c;
        D[c] = id;
        if (H[r] < 0){
            H[r] = L[id] = R[id] = id;
        }
        else {
            R[id] = R[H[r]];
            L[R[H[r]]] = id;
            L[id] = H[r];
            R[H[r]] = id;
        }
    }
    void Remove(int c)
    {
        for (int i = D[c]; i != c; i = D[i]){
            L[R[i]] = L[i];
            R[L[i]] = R[i];
        }
    }
    void Resume(int c)
    {
        for (int i = U[c]; i != c; i = U[i]){
            L[R[i]] = R[L[i]] = i;
        }
    }
    int calc()
    {
        int cnt = 0;
        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]){
                cnt++;
                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 cnt;
    }
    bool dance(int deep)
    {
        if (deep + calc() > limit) return false;
        if (R[0] == 0) {
            return deep <= limit;
        }
        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]){
            Remove(i);
            for (int j = R[i]; j != i; j = R[j]){
                Remove(j);
            }
            if (dance(deep + 1)) return true;
            for (int j = L[i]; j != i; j = L[j]){
                Resume(j);
            }
            Resume(i);
        }
        return false;
    }
}DLX;
struct node{
    ll x,y;
}s[N];
ll dis(int i,int j)
{
    return (ll)abs(s[i].x - s[j].x) + (ll)abs(s[i].y - s[j].y);
}
int main()
{
    int t,Case = 1;
    scanf("%d",&t);
    while(t--){
        int n;
        scanf("%d %d",&n,&limit);
        for (int i = 1; i <= n; i++){
            scanf("%I64d %I64d",&s[i].x,&s[i].y);
        }
        ll l = 0,r = 100000000000,ans;
        while(l <= r){
            ll mid = (l + r) >> 1;
            DLX.init(n,n);
            for (int i = 1; i <= n; i++){
                for (int j = 1; j <= n; j++){
                    if (dis(i,j) <= mid){
                        DLX.link(i,j);
                    }
                }
            }
            if (DLX.dance(0)) {
                ans = mid;
                r = mid - 1;
            }
            else l = mid + 1;
        }
        printf("Case #%d: %I64d\n",Case++,ans);
    }
    return 0;
}
zhe_zhenbuhui_a
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
夜深人静写算法（五十）- Dancing Links X（跳舞链）
英雄哪里出来
01-31 32万+
双向十字交叉循环链表求解精确覆盖、重复覆盖。 骨牌覆盖、N皇后问题的高效解法。
dancing links X的相关资料
10-26
是解决数独问题的一种比较好的算法。。NOIP2009就考察到了这种算法。。比较好！
dancing links x（舞蹈链算法）详解
dajiangyou123456的博客
01-31 4055
dancing links x 详解 大佬万仓一黍的blog 夜深人静写算法（九）- Dancing Links X（跳舞链） /* Dancing Links 高效搜索算法 1) 如果矩阵A没有列（即空矩阵），则当前记录的解为一个可行解；算法终止，成功返回； 2) 否则选择矩阵A中“1”的个数最少的列c；（确定性选择） 3) a.如果存在A[r][c]=1的行r，将行r放...
浅入 dancing links x（舞蹈链算法）
weixin_30885111的博客
08-13 243
abastract：利用dancing links 解决精确覆盖问题，例如数独，n皇后问题；以及重复覆盖问题。 要学习dacning links 算法，首先要先了解该算法适用的问题，精确覆盖问题和重复覆盖问题等，下面先了解精确覆盖问题和重复覆盖问题。 精确覆盖问题 何为精确覆盖问题 　　在一个全集X中若干子集的集合为S，精确覆盖（Exactcover）是指，S的子集S*，满足X中的每一个元...
dancing links详解
huobengluantiao8
08-06 468
Dancing links是一种能高效实现Knuth的X算法的技术，它可以使很多搜索问题得到极大的优化。 假设x是一个双向链表中的一个节点，L[x]表示X的前驱，R[x]表示x的后继， 则R[L[x]] = R[x], L[R[x]] = L[x]这一操作可以把x从链表中移除，这是众所周知的， 当然，一个细致的程序员还会用 L[x] = R[x] = x或 L[x] = R[x] = NUL...
算法参考资料DLXcn-DancingLinks中文版
04-15
算法参考资料DLXcn -- Dancing Links 中文版提取方式是百度网盘分享地址
算法参考资料DancingLinks在搜索中的应用
最新发布
04-15
算法参考资料Dancing Links在搜索中的应用提取方式是百度网盘分享地址
基于舞蹈链的数独算法，以Python实现
12-26
舞蹈链算法，又称Dancing Links（DLX）算法，是由日本数学家和计算机科学家Donald Knuth提出的一种用于解决完全多归类问题的有效方法。在数独求解中，我们可以将每个空格看作一个“列”，每个可能填入的数字看作一个...
Dancing Links 精确覆盖算法的Rust实现_rust_代码_下载
06-12
Dancing Links算法的核心思想是利用链表数据结构来表示问题的约束矩阵，并通过一种特殊的链接方式——“舞蹈链接”来高效地进行回溯搜索。在Rust编程语言中，我们可以利用其强大的类型系统和内存管理特性来实现这一...
舞蹈链数独求解算法
04-10
舞蹈链算法求解数独
对跳舞链(Dancing Links)和精确覆盖(DLX)的理解运用
Mouse_liang的博客
11-13 215
DLX
简单易懂的Dancing links讲解（1）
热门推荐
mu399的专栏
06-03 2万+
最早接触Dancing Links的时候，是在csdn论坛上逛的时候，发现有人在研究数独程序，由于本人开发过数独游戏，就进去看了看，发现有人说用Dancing Links来求解数独最快了，于是我就决定去了解一下Dancing Links。 1.   Dancing Links是什么？ Dancing Links是一类搜索问题的通用优化,对精确覆盖问题有奇效，也可解决重复覆盖问题，D
跳跃的舞者，舞蹈链（Dancing Links）算法——求解精确覆盖问题
weixin_33843409的博客
06-30 780
精确覆盖问题的定义：给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1 例如：如下的矩阵 就包含了这样一个集合（第1、4、5行）   如何利用给定的矩阵求出相应的行的集合呢？我们采用回溯法   矩阵1：   先假定选择第1行，如下所示： 如上图中所示，红色的那行是选中的一行，这一行中有3个1，分别是第3、5、6列。 由于这3列已经包含了...
HDU_3335_Divisibility（DancingLinksX重复覆盖||dfs||暴力）
OTTFF的博客
05-02 794
题意给一个数组 让从中选出尽可能多的数字，他们之间两两不存在整除关系 这题目貌似正经做法应该是最小路径覆盖 但是这题DancingLinksX甚至DFS甚至直接for循环暴力都可以过……
python跳舞的线_舞蹈链（Dance Link X)算法详解及python实现
weixin_36480303的博客
02-21 911
这两天打算做个数独玩玩，查了一下解数独最好的算法叫舞蹈链：Dance Link X该算法主要是解决精确覆盖问题：比如有个集合X，以及其若干子集的集合Y，要求出一个Y的子集Y*，能够恰好分割X。举个例子，有集合X = [1,2,3,4,5,6,7]，以及其子集的集合Y：集合1：[3,5,6]集合2：[1,4,7]集合3：[2,3,6]集合4：[1,4]集合5：[2,7]集合6：[4,5,6]要从Y的...
浅谈 Dancing Links X 算法
bifanwen的博客
04-09 668
前置知识： 一维链表。（单向，双向，循环） 部分集合运算，如 ⋂\bigcap⋂，⋃\bigcup⋃. 前言 在计算机科学中，X算法可用来求解精确覆盖问题。 精确覆盖问题 是哪一类问题呢？ XXX 算法又是什么高深的算法呢？ 背景 你的同学通过某种算法迅速 AC\text{AC}AC 了 P1784 数独，然后他兴致勃勃地 带领学生 1s1s1s 搞定数独竞赛 。 小时候，你玩数独；...
舞蹈链 （dancing links X）
rgndao的博客
08-15 270
舞蹈链算法，用于求解精确覆盖或者重复覆盖问题，目的是保证每一列的值最后为1或大于1，搜索中选用某一行后就将这一行以及它所解决的所有列删去，最后如果发现有列无法删去则失败，回溯并将之前删去的都恢复；如果最后发现所有列都被删去了，则说明问题解决。 它首先可以用来解决数独问题：转化为每行，每列，每个宫都有1~9，每格只有一个数字这个条件。是精确覆盖问题。 HDU3111题目链接 #include...
数据结构4——浅谈DancingLinks的思想及应用
frankchenfu的博客
01-13 277
在学习DancingLinks之前，我们先来回顾一下我们以前学过的回溯法。 我们学习基础的回溯法的时候，我们都是先判断是否达到解，然后继续搜索。 对于搜到的下一个点，将他标记为使用过（ vis[i]=1; ），然后进入下一层搜索。 当解决精确覆盖问题（给定几个集合，使得找出其中一个或几个集合，满足这些集合中的元素互不重复，然后覆盖$[1,n]$的每一个数）的时候，我们发现普通的回溯算法不好写...
dancing links解决X问题的C++实现
xanxus46的专栏
11-13 1620
X问题，也称精确覆盖问题，就是给定一个01矩阵，需要从中选取一些行组成一个子矩阵，这个子矩阵的每一列有且仅有一个1。这个问题听起来就知道很难，必须使用回溯算法来解决，但是我们知道回溯算法要提高效率，就必须做好剪枝和回溯恢复的工作。这时算法大师Donald E.Knoth给出了一个巧妙的数据结构，十字链表，每个节点都有上下左右的指针。其实这个结构参考的是双链表删除和恢复的便利性，思考一下，在双链表中
用舞蹈链算法（Dancing Links）求解俄罗斯方块覆盖问题matlab代码
06-07
dl = DancingLinks(max_nodes); % 构建 Dancing Links 矩阵 for i = 1:m for j = 1:n for k = 1:numel(blocks) block = blocks{k}; if i + size(block, 1) - 1 > m || j + size(block, 2) - 1 > n continue; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值