DLX算法合集 I

最新推荐文章于 2024-01-11 00:14:02 发布
最新推荐文章于 2024-01-11 00:14:02 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： DLX
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/solotzg/article/details/43883169
版权

DLX是一种相当神奇的数据结构，通常用于解决矩阵（多为稀疏矩阵）的 重复|精确 覆盖的问题。不过一般这类问题的难点是抽出转化关系，剩下的几乎就是套模板

hdu 3663 Power Stations

#include<cstdio>
#include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
typedef long long LL;
const int MAXN = 65;
const int MAXM = MAXN*MAXN*200;
const int MAXD = 16;
int n, m, day;
int res[MAXN];
const int mmp[6][6] =
{
    0,0,0,0,0,0,
    0,1,2,3,4,5,
    0,0,6,7,8,9,
    0,0,0,10,11,12,
    0,0,0,0,13,14,
    0,0,0,0,0,15
};
int tar[20][2];
struct DLX
{
    int L[MAXM],R[MAXM],U[MAXM],D[MAXM];
    int sz,row[MAXM],col[MAXM],S[MAXN*10],H[MAXN*20];
    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 add(int c)
    {
        R[L[c]]=L[R[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]];
    }
    void init(int m)
    {
        for(int i=0; i<=m; i++)
        {
            S[i]=0;
            L[i]=i-1;
            R[i]=i+1;
            U[i]=D[i]=i;
        }
        L[0]=m;
        R[m]=0;
        sz=m+1;
        memset(H,-1,sizeof(H));
    }
    void link(int x,int y)
    {
        ++S[col[sz]=y];
        row[sz]=x;
        D[sz]=D[y];
        U[D[y]]=sz;
        U[sz]=y;
        D[y]=sz;
        if(H[x]<0)H[x]=L[sz]=R[sz]=sz;
        else
        {
            R[sz]=R[H[x]];
            L[R[H[x]]]=sz;
            L[sz]=H[x];
            R[H[x]]=sz;
        }
        sz++;
    }
    bool dfs()
    {
        if(!R[0])
            return 1;
        int c=R[0];
        for(int i=R[0]; i; i=R[i])if(S[c]>S[i])c=i;
        del(c);
        for(int i=D[c]; i!=c; i=D[i])
        {
            res[(row[i]-1)/MAXD + 1] = i;
            for(int j=R[i]; j!=i; j=R[j])del(col[j]);
            if(dfs())
                return 1;
            for(int j=L[i]; j!=i; j=L[j])add(col[j]);
            res[(row[i]-1)/MAXD + 1] = 0;
        }
        add(c);
        return 0;
    }
    void cal()
    {
        if (dfs())
        {
            for (int i = 1, j; i<= n; ++i)
            {
                j = (row[res[i]]-1)%MAXD + 1;
                printf("%d %d\n", tar[j][0], tar[j][1]);
            }
        }
        else
            puts("No solution");
        puts("");
    }
} dlx;
int edge[MAXN][MAXN];
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
#endif
    for (int i = 1; i<= 5; ++i)
        for (int j = i; j<= 5; ++j)
            tar[mmp[i][j]][0] = i, tar[mmp[i][j]][1] = j;
    tar[MAXD][0] = 0;
    tar[MAXD][1] = 0;
    while (scanf("%d%d%d", &n, &m, &day) != EOF)
    {
        dlx.init(n*day+n);
        memset(res, 0, sizeof res);
        memset(edge, 0, sizeof edge);
        for (int i = 1; i<= n; ++i) edge[i][i] = 1;
        for (int i = 0, u, v; i< m; ++i)
        {
            scanf("%d%d", &u, &v);
            edge[u][v] = edge[v][u] = 1;
        }
        for (int i = 1, b, e, da; i<= n; ++i)
        {
            scanf("%d%d", &b, &e);
            da = (i-1)*MAXD;
            dlx.link(da+MAXD, n*day+i);
            for (int q = b; q<= e; ++q)
            {
                for (int w = q; w<= e; ++w)
                {
                    dlx.link(mmp[q][w]+da, n*day+i);
                    for (int k = q; k<= w; ++k)
                    {
                        for (int o = 1; o<= n; ++o)
                            if (edge[i][o])
                            {
                                dlx.link(mmp[q][w]+da, (o-1)*day+k);
                            }
                    }
                }
            }
        }
        dlx.cal();
    }
    return 0;
}

hdu 5046 Airport

二分+DLX 
#include<cstdio>
#include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
using namespace std;
typedef long long LL;
const int MAXN = 65;
const int MAXM = MAXN*MAXN;
int n, m;
int vis[MAXN], nlen;
LL dis[MAXN][MAXN], len[MAXM];
inline LL mabs(LL a)
{
    return a<0?-a:a;
}
struct _point
{
    LL x, y;
    LL gt_dis(const _point & a)
    {
        return mabs(x-a.x) + mabs(y-a.y);
    }
}pt[MAXN];
struct _node
{
    int U[MAXM], D[MAXM], L[MAXM], R[MAXM], COL[MAXM], ROW[MAXM];
    int H[MAXN], S[MAXN];
    int sz, ans;
    void init()
    {
        memset(H, -1, sizeof H);
        for (int i = 0; i<= n; ++i)
        {
            S[i] = 0;
            U[i] = D[i] = i;
            L[i+1] = i;
            R[i] = i+1;
        }
        R[n] = 0;
        sz = n+1;
    }
    void link(int r, int c)
    {
        ++S[c];
        COL[sz] = c; ROW[sz] = r; U[sz] = U[c]; D[sz] = c; U[c] = sz; D[U[sz]] = sz;
        if (H[r] == -1)
            H[r] = L[sz] = R[sz] = sz;
        else
        {
            L[sz] = L[H[r]]; R[sz] = H[r];
            R[L[sz]] = sz; L[R[sz]] = sz;
        }
        ++sz;
    }
    void remv(int dx)
    {
        for (int i = D[dx]; i!=dx; i = D[i])
            L[R[i]] = L[i], R[L[i]] = R[i];
    }
    void resum(int dx)
    {
        for (int i = D[dx]; i!=dx; i = D[i])
            L[R[i]] = R[L[i]] = i;
    }
    int h()
    {
        int cnt = 0;
        memset(vis, 0, sizeof vis);
        for (int i = R[0]; i; i = R[i])
        {
            if (vis[i]) continue;
            ++cnt;
            for (int j = D[i]; j!=i; j=D[j])
            {
                for (int k = R[j]; k!=j; k=R[k])
                    vis[COL[k]] = 1;
            }
        }
        return cnt;
    }
    void dance(int k)
    {
        int mn, dx;
        if (ans || k + h() > m ) return ;
        if (!R[0])
        {
            ans = 1;
            return;
        }
        mn = MAXN;
        for (int i = R[0]; i; i = R[i])
            if (mn > S[i]) mn = S[i], dx = i;
        for (int i = D[dx]; i != dx; i = D[i])
        {
            remv(i);
            for (int j = R[i]; j != i; j = R[j])
                remv(j);
            dance(k+1);
            for (int j = R[i]; j != i; j = R[j])
                resum(j);
            resum(i);
        }
    }
    int cal(LL mxlen)
    {
        init();
        for (int i = 1; i<= n; ++i)
        {
            for (int j = 1; j<= n; ++j)
            {
                if (dis[i][j] <= mxlen)
                    link(i, j);
            }
        }
        ans = 0;
        dance(0);
        return ans;
    }
}node;
LL solve()
{
    int bg = 0, ed = nlen-1, mm;
    LL dd;
    while (bg < ed)
    {
        mm = (bg+ed)>>1;
        dd = len[mm];
        if (node.cal(dd))
            ed = mm;
        else
            bg = mm+1;
    }
    return len[bg];
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
#endif
    int t;
    scanf("%d", &t);
    for (int _ = 1; _ <= t; ++_)
    {
        printf("Case #%d: ", _);
        scanf("%d%d", &n, &m);
        for (int i = 1; i<= n; ++i)
            scanf("%I64d%I64d", &pt[i].x, &pt[i].y);
        nlen = 0;
        for (int i = 1; i<= n; ++i)
            for (int j = i; j<= n; ++j)
                dis[i][j] = dis[j][i] = pt[i].gt_dis(pt[j]),
                len[nlen++] = dis[i][j];
        sort(len, len+nlen);
        nlen = unique(len, len+nlen) - len;
        printf("%I64d\n", solve());
    }
    return 0;
}

hdu 4735 Little Wish~ lyrical step~

在一棵无向有边权的树上，每个节点表示男或女，可挑选任意两点交换，是每个女的距离D之内至少有一个男的，求交换的最小次数。
明显同性之间没有交换的必要，可以用DLX枚举可能的最后状态，找出与最初状态差别最小的 
#include<cstdio>
#include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
using namespace std;
const int MAXN = 55;
const int MAXM = MAXN*MAXN;
int n, m;
int vis[MAXN];
int dis[MAXN][MAXN], boy[MAXN], boys;
struct _node
{
    int U[MAXM], D[MAXM], L[MAXM], R[MAXM], COL[MAXM], ROW[MAXM];
    int H[MAXN], S[MAXN];
    int sz, ans;
    void init()
    {
        memset(H, -1, sizeof H);
        for (int i = 0; i<= n; ++i)
        {
            S[i] = 0;
            U[i] = D[i] = i;
            L[i+1] = i;
            R[i] = i+1;
        }
        R[n] = 0;
        sz = n+1;
    }
    void link(int r, int c)
    {
        ++S[c];
        COL[sz] = c; ROW[sz] = r; U[sz] = U[c]; D[sz] = c; U[c] = sz; D[U[sz]] = sz;
        if (H[r] == -1)
            H[r] = L[sz] = R[sz] = sz;
        else
        {
            L[sz] = L[H[r]]; R[sz] = H[r];
            R[L[sz]] = sz; L[R[sz]] = sz;
        }
        ++sz;
    }
    void remv(int dx)
    {
        for (int i = D[dx]; i!=dx; i = D[i])
            L[R[i]] = L[i], R[L[i]] = R[i];
    }
    void resum(int dx)
    {
        for (int i = D[dx]; i!=dx; i = D[i])
            L[R[i]] = R[L[i]] = i;
    }
    int h()
    {
        int cnt = 0;
        memset(vis, 0, sizeof vis);
        for (int i = R[0]; i; i = R[i])
        {
            if (vis[i]) continue;
            ++cnt;
            for (int j = D[i]; j!=i; j=D[j])
            {
                for (int k = R[j]; k!=j; k=R[k])
                    vis[COL[k]] = 1;
            }
        }
        return cnt;
    }
    void dance(int k, int p)
    {
        int mn, dx;
        if (p >= ans || p > boys || k + h() > boys) return ;
        if (!R[0])
        {
            ans = p;
            return;
        }
        mn = MAXN;
        for (int i = R[0]; i; i = R[i])
            if (mn > S[i]) mn = S[i], dx = i;
        for (int i = D[dx]; i != dx; i = D[i])
        {
            remv(i);
            for (int j = R[i]; j != i; j = R[j])
                remv(j);
            dance(k+1, p + !boy[ROW[i]]);
            for (int j = R[i]; j != i; j = R[j])
                resum(j);
            resum(i);
        }
    }
    int cal()
    {
        for (int i = 1; i<= n; ++i)
        {
            for (int j = 1; j<= n; ++j)
            {
                if (dis[i][j] <= m)
                    link(i, j);
            }
        }
        ans = 100000000;
        dance(0, 0);
        return ans>boys?-1:ans;
    }
}node;
void init_local()
{
    memset(dis, 0x3f, sizeof dis);
    boys = 0;
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
#endif
    int t;
    scanf("%d", &t);
    for (int _ = 1; _ <= t; ++_)
    {
        printf("Case #%d: ", _);
        scanf("%d%d", &n, &m);
        init_local();
        node.init();
        for (int i = 1; i<= n; ++i)
            scanf("%d", boy+i), boys += boy[i], dis[i][i] = 0;
        for (int i = 1, a, b, c; i< n; ++i)
        {
            scanf("%d%d%d", &a, &b, &c);
            dis[a][b] = dis[b][a] = c;
        }
        for (int k = 1; k<= n; ++k)
            for (int i = 1; i<= n; ++i)
                for (int j = 1; j<= n; ++j)
                    dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
        printf("%d\n", node.cal());
    }
    return 0;
}

hdu 3498 whosyourdaddy

比较裸的重复覆盖问题 
#include<cstdio>
#include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
using namespace std;
const int MAXN = 60;
const int MAXM = MAXN*MAXN;
int n, m;
int mmp[MAXN][MAXN], vis[MAXN];
struct _node
{
    int U[MAXM], D[MAXM], L[MAXM], R[MAXM], C[MAXM];
    int H[MAXN], S[MAXN];
    int sz, ans;
    void init()
    {
        memset(mmp, 0, sizeof mmp);
        memset(H, -1, sizeof H);
        for (int i = 0; i<= n; ++i)
        {
            S[i] = 0;
            U[i] = D[i] = i;
            L[i+1] = i;
            R[i] = i+1;
        }
        R[n] = 0;
        sz = n+1;
    }
    void link(int r, int c)
    {
        ++S[c];
        C[sz] = c; U[sz] = U[c]; D[sz] = c; U[c] = sz; D[U[sz]] = sz;
        if (H[r] == -1)
            H[r] = L[sz] = R[sz] = sz;
        else
        {
            L[sz] = L[H[r]]; R[sz] = H[r];
            R[L[sz]] = sz; L[R[sz]] = sz;
        }
        ++sz;
    }
    void remv(int dx)
    {
        for (int i = D[dx]; i!=dx; i = D[i])
            L[R[i]] = L[i], R[L[i]] = R[i];
    }
    void resum(int dx)
    {
        for (int i = D[dx]; i!=dx; i = D[i])
            L[R[i]] = R[L[i]] = i;
    }
    int h()
    {
        int cnt = 0;
        memset(vis, 0, sizeof vis);
        for (int i = R[0]; i; i = R[i])
        {
            if (vis[i]) continue;
            ++cnt;
            for (int j = D[i]; j!=i; j=D[j])
            {
                for (int k = R[j]; k!=j; k=R[k])
                    vis[C[k]] = 1;
            }
        }
        return cnt;
    }
    void dance(int k)
    {
        int mn, dx;
        if (k + h() >= ans) return ;
        if (!R[0])
        {
            if (k < ans) ans = k;
            return;
        }
        mn = MAXN;
        for (int i = R[0]; i; i = R[i])
            if (mn > S[i]) mn = S[i], dx = i;
        for (int i = D[dx]; i != dx; i = D[i])
        {
            remv(i);
            for (int j = R[i]; j != i; j = R[j])
                remv(j);
            dance(k+1);
            for (int j = R[i]; j != i; j = R[j])
                resum(j);
            resum(i);
        }
    }
    int cal()
    {
        for (int i = 1; i<= n; ++i)
        {
            for (int j = 1; j<= n; ++j)
            {
                if (mmp[i][j] || i == j)
                    link(i, j);
            }
        }
        ans = n;
        dance(0);
        return ans;
    }
}node;
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
#endif
    while (scanf("%d%d", &n, &m) != EOF)
    {
        node.init();
        for (int i = 0, a, b; i< m; ++i)
        {
            scanf("%d%d", &a, &b);
            mmp[a][b] = mmp[b][a] = 1;
        }
        printf("%d\n", node.cal());
    }
    return 0;
}

hdu 3111 Sudoku

把每个点的覆盖、横 纵轴上数字的覆盖、每个块的覆盖 状态罗列出来共有 9*9*4 种状态作为横轴，用每个点填充数字1-9共 9*9*9 种状态作为纵轴 

#include<cstdio>
#include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
const int MAXC = 330;
const int MAXR = 735;
const int MAXM = MAXR*MAXC;
int res[100], check[MAXC], nr;
struct DLX
{
    int L[MAXM],R[MAXM],U[MAXM],D[MAXM];
    int sz,row[MAXM],col[MAXM],S[MAXC],H[MAXR];
    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 add(int c)
    {
        R[L[c]]=L[R[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]];
    }
    void init(int m)
    {
        for(int i=0; i<=m; i++)
        {
            S[i]=0;
            L[i]=i-1;
            R[i]=i+1;
            U[i]=D[i]=i;
        }
        L[0]=m;
        R[m]=0;
        sz=m+1;
        memset(H,-1,sizeof(H));
    }
    void link(int x,int y)
    {
        ++S[col[sz]=y];
        row[sz]=x;
        D[sz]=D[y];
        U[D[y]]=sz;
        U[sz]=y;
        D[y]=sz;
        if(H[x]<0)H[x]=L[sz]=R[sz]=sz;
        else
        {
            R[sz]=R[H[x]];
            L[R[H[x]]]=sz;
            L[sz]=H[x];
            R[H[x]]=sz;
        }
        sz++;
    }
    bool dfs()
    {
        if(!R[0])
            return 1;
        int c=R[0];
        for(int i=R[0]; i; i=R[i])if(S[c]>S[i])c=i;
        del(c);
        for(int i=D[c]; i!=c; i=D[i])
        {
            res[nr++] = i;
            for(int j=R[i]; j!=i; j=R[j])del(col[j]);
            if(dfs())
                return 1;
            for(int j=L[i]; j!=i; j=L[j])add(col[j]);
            --nr;
        }
        add(c);
        return 0;
    }
} dlx;
char mmp[20][20];
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
#endif
    int T, ans;
    scanf("%d", &T);
    for (int t = 0; t< T; ++t)
    {
        ans = 1;
        nr = 0;
        memset(check, 0, sizeof check);
        if (t) scanf("%s", mmp[0]), printf("---\n");
        dlx.init(9*9*4);
        memset(res, -1, sizeof res);
        for (int i = 1, k = 1, p, u, r, c; i<= 9; ++i)
        {
            scanf("%s", mmp[i]+1);
            for (int j = 1; j<= 9; ++j, ++k)
                if (mmp[i][j] != '?')
                {
                    p = mmp[i][j] - '0';
                    r = (i-1)/3+1;
                    c = (j-1)/3+1;
                    c = (r-1)*3+c;
                    dlx.link(u=(k-1)*9+p, k);
                    dlx.link(u, r=(i-1)*9+p+81);
                    if (check[r])
                        ans = 0;
                    check[r] = 1;
                    dlx.link(u, r=(j-1)*9+p+162);
                    if (check[r])
                        ans = 0;
                    check[r] = 1;
                    dlx.link(u, r=(c-1)*9+p+243);
                    if (check[r])
                        ans = 0;
                    check[r] = 1;
                }
                else
                {
                    for (p = 1; p <= 9; ++p)
                    {
                        r = (i-1)/3+1;
                        c = (j-1)/3+1;
                        c = (r-1)*3+c;
                        dlx.link(u=(k-1)*9+p, k);
                        dlx.link(u, (i-1)*9+p+81);
                        dlx.link(u, (j-1)*9+p+162);
                        dlx.link(u, (c-1)*9+p+243);
                    }
                }
        }
        if (!ans || !dlx.dfs())
            printf("impossible\n");
        else
        {
            for (int i = 0, o; i< nr; ++i)
            {
                o = dlx.row[res[i]];
                int r = (o-1)/81+1;
                int c = (o-1)%81/9+1;
                int p = (o-1)%9+1;
                mmp[r][c] = '0'+p;
            }
            for (int i = 1; i<= 9; ++i)
                printf("%s\n", mmp[i]+1);
        }
    }
    return 0;
}


deprecated_tzg
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DLX算法一览
蒟蒻QMQ
11-04 1万+
首先了解DLX是什么？ DLX是一种多元未饱和型指令集结构，DLX 代表中级车、加长轴距版本、内饰改款、尊贵车豪华版车型。—百科百度 不不不，我不讲这些明明就是不懂 DLX是什么，一种解决精准覆盖问题的做法，一般不叫算法，下面讲。 模版题： 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 小Ho最近遇到一个难题，他需要破解一个棋局。 棋局分成了n行，m列，每行有若干个...
链表上的舞者——舞蹈链（DLX算法）
m0_52447591的博客
09-12 3897
在整个求解过程中，指针在数据间跳跃着，就像精巧设计的舞蹈一样，故Donald E.Knuth把它称为Dancing Links（中文译名舞蹈链）。 目录 1.1一类被称为精确覆盖的问题 1.2经典的精确覆盖问题举例——矩阵覆盖 1.2.1问题描述 1.2.2从暴力算法到X算法 第二部分：精确覆盖问题的X算法 2.1X算法分析——矩阵覆盖问题的解决 第三部分：用于X算法的数据结构——双向十字循环链表 3.1主角登场——双向十字循环链表概览 3.2详细分析——双向十字循环链表的操作 ...
DLX算法
dianzhenquan3519的博客
09-05 420
理解DLX算法之前首先了解精确覆盖问题和重复覆盖问题 精确覆盖问题 何为精确覆盖问题 　　在一个全集X中若干子集的集合为S，精确覆盖（Exactcover）是指，S的子集S*，满足X中的每一个元素在S*中恰好出现一次。 定义　 　　满足以下条件的集合为一个精确覆盖：　　　　S*中任意两个集合没有交集，即X中的元素在S*中出现最多一次　　　　S*中集合的全集为X，即X中的元素...
D* Lite路径规划算法
热门推荐
云水禅心的博客
12-19 3万+
D* Lite路径规划算法D* Lite算法简述 D* Lite算法简述 D_star Lite算法是Koenig S和Likhachev M基于LPA_star 算法基础上提出的路径规划算法。 D_star Lite 算法之于 LPA_star 算法犹如 D_star 算法之于 A_star 算法。与 LPA_star 采用的正向搜索算法不同，D_star Lite 采用反向搜索方式，效果与D_...
舞蹈链，DLX算法详解，OJ精讲，详细代码
EQUINOX1的博客
01-11 1249
如何将实际问题抽象为精确覆盖问题？
DLX.zip_DLX_dlx算法
09-20
**DLX算法详解** DLX（ Dancing Links ）算法，由计算机科学家Donald Knuth提出，是一种在图论中用于解决完全多对一匹配问题的高效算法。它在回溯搜索中展现出优秀的性能，尤其适用于解决0-1背包、 Exact Cover 和...
JavaFX和DLX算法实现的数独游戏.zip
最新发布
05-26
JavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏....
sudoku-solver:使用DLX算法的快速数独难题求解器:puzzle_piece:
05-07
DLX算法是由日本数学家和程序员Hakuo Okada发明的，它是基于一种称为"Exact Cover"问题的解决方法，也被称作Algorithm X。 首先，让我们深入了解数独。数独是一种逻辑游戏，玩家需要在9x9的格子中填入数字1到9，...
精确覆盖问题和DLX算法.ppt
07-14
集覆盖问题研究满足覆盖所有需求点顾客的前提下，服务站总的建站个数或建设费用最小的问题。集覆盖问题最早是由 Roth和 Toregas等提出的，用于解决消防中心和救护车等的应急服务设施的选址问题，他们分别建立了服务...
基于JavaFX和DLX算法实现的数独游戏，可快速生成和解出数独.zip
05-13
数独游戏 上述方法称为基础解法（Basic Techniques），其他所有的解法称为进阶解法（Advanced Techniques），是在补基本解法之不足，所以又称辅助解法。 进阶解法包括：区块摒除法（Locked Candidates）、数组...
【笔记】DLX算法及常见应用
weixin_30268921的博客
11-02 312
参考资料 精确覆盖问题讲解——grenet 数独模型转换——bl0ss0m DLX算法求解数独——grenet 问题引入 精确覆盖问题： 有ｒ个由１～ｎ组成的集合S1,S2,S3....Sr,要求选择若干集合，使得１～ｎ恰好只在一个集合里出现。 数独问题： 在９×９的矩阵里填数，使得每一行每一列每一个九宫格里１～９都恰好出现一次 解法分析 先考虑精确覆盖问题，我们将其...
DLX算法介绍
多看多听多总结
01-23 1万+
在介绍DLX算法前，先说下X算法，通过比较才 知道DLX算法的好。 X算法是一种常规的回溯算法，我们可以用一个递归过程求精确覆盖问题。 递归过程描述为：选择一个没有被删除的列，然后枚举该列为1的行，将该行作为解的一部分，删除所选择的行中为1的列（在删除列时，将对应的行也删除）。用伪代码表示如下,其中A表示覆盖时的矩阵 if A is empty, the problem is solved;
精确覆盖问题、Algorithm X 与 Dancing Links（DLX）
继科杂货店
01-07 3501
精确覆盖（Exact Cover）问题 精确覆盖 S 为集合 X 的若干个子集构成的集合，若存在 S 的一个子集 S*，满足 X 中的元素有且只有一次包含在 S* 的一个元素中，那么称 S* 为 X 的一个精确覆盖。 S*属性 根据定义 S* 具有以下属性： 1. S* 中任意两个元素交集为空。 2. S* 中所有元素并集为 X。 例子 假定 S = { A, B, C
完成数独的算法 python_一个利用DLX算法的Python解数独程序
weixin_39591720的博客
12-18 304
源程序sudokusolver.py#!/usr/bin/env python# Copyright (C) 2012 Daogan Ao # Permission is hereby granted, free of charge, to any person obtaining a copy# of this software and associated documentation file...
基于DLX指令集的5级流水线CPU设计与实现
ww_zidongkong的专栏
02-26 6267
一、渊源... 1 二、基础... 2 1、从系统角度和程序执行角度体会CPU概貌... 2 2、CPU设计的重点：指令集和流水线，指令集就是协议... 3 3、流水线—20世纪最伟大的发明... 10 4、流水线带来的烦恼—相关... 16 5、流水线结构的颠覆：记分牌与tomasulo算法（与设计无关）... 21 三、设计与实现... 26 一、渊源 诞
DLX专题
nike0good |Oier&ACMer | 熟能生巧
07-12 751
[toc] 一下题目可以套白书模板UVA 1309 Sudoku把Sudoku上的点拆成如下信息 (r,c)(r,c)是否填了 (r,v),(c,v),(s,v)(r,v),(c,v),(s,v)第r行/c列/s块是否填了v#include<bits/stdc++.h> using namespace std; #define For(i,n) for(int i=1;i<=n;i++) #d
【计算机体系结构】Tomasulo算法
轩轩是只胖企鹅的企鹅窝
12-09 793
计算机体系结构实验指导手册V1.01
08-08
模拟器的界面包含了CPU寄存器、流水线、I/O和内存的图形表示，以便直观理解DLX处理器的工作原理。它还具备统计功能，帮助分析流水线性能。 WINDLX汇编语言的介绍包括了伪指令的使用，这些指令用于简化编程，比如...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值