dancing link 学习资源导航+心得

最新推荐文章于 2018-09-20 22:50:25 发布

dehs8915

最新推荐文章于 2018-09-20 22:50:25 发布

阅读量103

点赞数

原文链接：http://www.cnblogs.com/vb4896/p/3933685.html

版权

dancing link简直是求解数独的神器，NOIP2009最后一题靶形数独，DFS 各种改变搜索顺序都没法过，最后还是用了卡时过得。用dancing link写，秒杀所有数据，总时间才400ms不到。。（虽然还不是很清楚为什么会快）。

一开始还是先看这个blog，图文都非常清晰

http://www.cnblogs.com/grenet/p/3145800.html

上文解释了dancing link的原理，可以用来解决精度覆盖问题，但是求解数独问题还需要一步转化。

见博文：

http://www.cnblogs.com/grenet/p/3163550.html

大致思想是：

1、先遍历数独的格子，把那些有数字的格子转换为行，插入到矩阵中。在插入的同时，把包含1的列的列首元素的Count分量设置为-1（起到后面判别的作用）。

由于这些行一定能被选中，是答案的一部分，那么把这些行的行号置入到答案列表中，并把这些列的列首元素从水平双向链中移除（手动移除比调用RemoveCol方法快）

2、在遍历没有数字的格子，转换为若干行（1个格子9行）插入到矩阵中。在插入到矩阵的时候，判断包含1的列的列首元素的Count分量。如果是-1，说明新插入的行和第1步中的某些行相冲，是个无效行，没有必要插入到矩阵中；如果不是-1，说明是个有效行，插入到矩阵中。

这样把就数独转化成一个729*324的精度覆盖问题；

看了这个大致有些明白，但要是自己写还是无从下手，先看一个模板（注释比较清晰易懂）：

http://blog.csdn.net/weiguang_123/article/details/7935003

看完后可以尝试着做一做裸的精度覆盖问题poj3740，然后再去做靶形数独。

另外第一篇文章中有个地方：

在函数中有个很聪明的设计，在标示列首元素时，顺序是从I元素的右侧元素开始；而在回标列首元素时，顺序是从I元素的左侧元素开始，正好顺序和标示列首元素的顺序相反。

这里非常关键，本来以为无关紧要，把poj3740的代码顺序改成一样，还是能AC，不过时间慢了一半，还以为这是个优化时间的地方。但是把靶形数独的代码改成这样，就WA了一半的点，手工模拟下可以发现这个顺序问题不是可有可无的，而是必须的。

贴上我靶形数独的AC代码：

  1 #include<cstdio>
  2 #include<iostream>
  3 #include<cstring>
  4 #include<algorithm>
  5 #include<cmath>
  6 #include<iomanip> 
  7 using namespace std;
  8 
  9 const int n=729,m=324;
 10 bool mx[2000][2000];
 11 int map[10][10],cnt[2000],head,cur,ans;
 12 int sqr[10][10]={{0,0,0,0,0,0,0,0,0,0},
 13                {0,1,1,1,4,4,4,7,7,7},
 14                {0,1,1,1,4,4,4,7,7,7},
 15                {0,1,1,1,4,4,4,7,7,7},
 16                {0,2,2,2,5,5,5,8,8,8},
 17                {0,2,2,2,5,5,5,8,8,8},
 18                {0,2,2,2,5,5,5,8,8,8},
 19                {0,3,3,3,6,6,6,9,9,9},
 20                {0,3,3,3,6,6,6,9,9,9},
 21                {0,3,3,3,6,6,6,9,9,9}};
 22 
 23 int w[10][10]={{0,0,0,0,0,0,0,0,0,0},
 24                {0,6,6,6,6,6,6,6,6,6},
 25                {0,6,7,7,7,7,7,7,7,6},
 26                {0,6,7,8,8,8,8,8,7,6},
 27                {0,6,7,8,9,9,9,8,7,6},
 28                {0,6,7,8,9,10,9,8,7,6},
 29                {0,6,7,8,9,9,9,8,7,6},
 30                {0,6,7,8,8,8,8,8,7,6},
 31                {0,6,7,7,7,7,7,7,7,6},
 32                {0,6,6,6,6,6,6,6,6,6}};
 33                
 34 struct point
 35 {
 36     int row,lc,rc,up,down,col;
 37 }node[2000*2000];
 38 
 39 inline int id(int x,int y)
 40 {
 41     return (x-1)*9+y;
 42 }
 43 
 44 void init(int c)
 45 {
 46     for (int i=0;i<=c;i++)
 47     {
 48         node[i].lc=i-1;
 49         node[i].rc=i+1;
 50         node[i].up=node[i].down=node[i].col=i;
 51     }
 52     node[0].lc=c;
 53     node[c].rc=0;
 54 }
 55 
 56 void build_link()
 57 {
 58     cur=m;
 59     for (int i=1;i<=n;i++)
 60     {
 61         int start,pre;
 62         start=pre=cur+1;
 63         for (int j=1;j<=m;j++)
 64             if (mx[i][j])
 65             {
 66                 cur++;
 67                 cnt[j]++;
 68                 node[cur].row=i;
 69                 
 70                 node[cur].lc=pre;
 71                 node[cur].rc=start;
 72                 node[pre].rc=cur;
 73                 node[start].lc=cur;
 74                 
 75                 node[cur].col=j;
 76                 node[cur].up=node[j].up;
 77                 node[cur].down=j;
 78                 node[node[j].up].down=cur;
 79                 node[j].up=cur;
 80                 pre=cur;
 81             }
 82     }
 83 }
 84 
 85 inline void cover(int c)
 86 {
 87     for (int i=node[c].up;i!=c;i=node[i].up)
 88         for (int j=node[i].rc;j!=i;j=node[j].rc)
 89         {
 90             node[node[j].up].down=node[j].down;
 91             node[node[j].down].up=node[j].up;
 92             cnt[node[j].col]--;
 93         }
 94     node[node[c].lc].rc=node[c].rc;
 95     node[node[c].rc].lc=node[c].lc;
 96 }
 97 
 98 inline void uncover(int c)
 99 {
100     for (int i=node[c].up;i!=c;i=node[i].up)
101         for (int j=node[i].rc;j!=i;j=node[j].rc)
102         {
103             node[node[j].up].down=j;
104             node[node[j].down].up=j;
105             cnt[node[j].col]++;
106         }
107     node[node[c].lc].rc=c;
108     node[node[c].rc].lc=c;
109 }
110 
111 void read_data()
112 {
113     for (int i=1;i<=9;i++)
114         for (int j=1;j<=9;j++)
115         {
116             scanf("%d",&map[i][j]);
117             int c=id(i,j),t,k;
118             if (map[i][j])
119             {
120                 k=map[i][j];
121                 t=(c-1)*9+k;
122                 mx[t][c]=true;
123                 mx[t][81+9*(i-1)+k]=true;
124                 mx[t][162+9*(j-1)+k]=true;
125                 mx[t][243+(sqr[i][j]-1)*9+k]=true;
126             }
127             else
128             {
129                 for (k=1;k<=9;k++)
130                 {
131                     t=(c-1)*9+k;
132                     mx[t][c]=true;
133                     mx[t][81+9*(i-1)+k]=true;
134                     mx[t][162+9*(j-1)+k]=true;
135                     mx[t][243+(sqr[i][j]-1)*9+k]=true;
136                 }
137             }
138         }
139 }
140 
141 bool dfs(int step,int score)
142 {
143     if (node[head].rc==head)
144     {
145         ans=max(score,ans);
146         return true;
147     }
148     
149     int i,j,c,t=210000,x,y,num,flag=0;
150     for (i=node[head].rc;i!=head;i=node[i].rc)
151         if (cnt[i]<t)
152         {
153             t=cnt[i];
154             c=i;
155         }
156     if (t==0)
157         return false;
158     cover(c);
159     
160     for (i=node[c].down;i!=c;i=node[i].down)
161     {
162         for (j=node[i].lc;j!=i;j=node[j].lc)
163             cover(node[j].col);
164         num=(node[i].row-1)/9+1;
165         x=(num-1)/9+1;
166         y=num-9*(x-1);
167         flag|=dfs(step+1,score+w[x][y]*(node[i].row-(num-1)*9));
168         for (j=node[i].rc;j!=i;j=node[j].rc)
169             uncover(node[j].col);
170     }
171     
172     uncover(c);
173     return flag;
174 }
175 
176 void solve()
177 {
178     init(m);
179     build_link();
180     int flag=1;
181     if (!dfs(1,0))
182         printf("-1\n");
183     else printf("%d\n",ans);
184 }
185 
186 int main()
187 {
188     //freopen("in.in","r",stdin);
189     //freopen("out.out","w",stdout);
190     read_data();
191     solve();
192     return 0;
193 }

View Code

如果要输出数独填好之后的结果，且数独的解唯一,代码如下：

  1 #include<cstdio>
  2 #include<iostream>
  3 #include<cstring>
  4 #include<algorithm>
  5 #include<cmath>
  6 #include<iomanip> 
  7 using namespace std;
  8 
  9 const int n=729,m=324;
 10 bool mx[2000][2000];
 11 int map[10][10],cnt[2000],head,cur,ans[10][10];
 12 int sqr[10][10]={{0,0,0,0,0,0,0,0,0,0},
 13                {0,1,1,1,4,4,4,7,7,7},
 14                {0,1,1,1,4,4,4,7,7,7},
 15                {0,1,1,1,4,4,4,7,7,7},
 16                {0,2,2,2,5,5,5,8,8,8},
 17                {0,2,2,2,5,5,5,8,8,8},
 18                {0,2,2,2,5,5,5,8,8,8},
 19                {0,3,3,3,6,6,6,9,9,9},
 20                {0,3,3,3,6,6,6,9,9,9},
 21                {0,3,3,3,6,6,6,9,9,9}};
 22                
 23 struct point
 24 {
 25     int row,lc,rc,up,down,col;
 26 }node[2000*2000];
 27 
 28 inline int id(int x,int y)
 29 {
 30     return (x-1)*9+y;
 31 }
 32 
 33 void init(int c)
 34 {
 35     for (int i=0;i<=c;i++)
 36     {
 37         node[i].lc=i-1;
 38         node[i].rc=i+1;
 39         node[i].up=node[i].down=node[i].col=i;
 40     }
 41     node[0].lc=c;
 42     node[c].rc=0;
 43 }
 44 
 45 void build_link()
 46 {
 47     cur=m;
 48     for (int i=1;i<=n;i++)
 49     {
 50         int start,pre;
 51         start=pre=cur+1;
 52         for (int j=1;j<=m;j++)
 53             if (mx[i][j])
 54             {
 55                 cur++;
 56                 cnt[j]++;
 57                 node[cur].row=i;
 58                 
 59                 node[cur].lc=pre;
 60                 node[cur].rc=start;
 61                 node[pre].rc=cur;
 62                 node[start].lc=cur;
 63                 
 64                 node[cur].col=j;
 65                 node[cur].up=node[j].up;
 66                 node[cur].down=j;
 67                 node[node[j].up].down=cur;
 68                 node[j].up=cur;
 69                 pre=cur;
 70             }
 71     }
 72 }
 73 
 74 inline void cover(int c)
 75 {
 76     for (int i=node[c].up;i!=c;i=node[i].up)
 77         for (int j=node[i].rc;j!=i;j=node[j].rc)
 78         {
 79             node[node[j].up].down=node[j].down;
 80             node[node[j].down].up=node[j].up;
 81             cnt[node[j].col]--;
 82         }
 83     node[node[c].lc].rc=node[c].rc;
 84     node[node[c].rc].lc=node[c].lc;
 85 }
 86 
 87 inline void uncover(int c)
 88 {
 89     for (int i=node[c].up;i!=c;i=node[i].up)
 90         for (int j=node[i].rc;j!=i;j=node[j].rc)
 91         {
 92             node[node[j].up].down=j;
 93             node[node[j].down].up=j;
 94             cnt[node[j].col]++;
 95         }
 96     node[node[c].lc].rc=c;
 97     node[node[c].rc].lc=c;
 98 }
 99 
100 void read_data()
101 {
102     for (int i=1;i<=9;i++)
103         for (int j=1;j<=9;j++)
104         {
105             char g;
106             scanf(" %c",&g);
107             map[i][j]=(int)g-'0';
108             int c=id(i,j),t,k;
109             if (map[i][j])
110             {
111                 k=map[i][j];
112                 t=(c-1)*9+k;
113                 mx[t][c]=true;
114                 mx[t][81+9*(i-1)+k]=true;
115                 mx[t][162+9*(j-1)+k]=true;
116                 mx[t][243+(sqr[i][j]-1)*9+k]=true;
117             }
118             else
119             {
120                 for (k=1;k<=9;k++)
121                 {
122                     t=(c-1)*9+k;
123                     mx[t][c]=true;
124                     mx[t][81+9*(i-1)+k]=true;
125                     mx[t][162+9*(j-1)+k]=true;
126                     mx[t][243+(sqr[i][j]-1)*9+k]=true;
127                 }
128             }
129         }
130 }
131 
132 void print()
133 {
134     for (int i=1;i<=9;i++)
135     {
136         for (int j=1;j<=9;j++)
137             printf("%d",ans[i][j]);
138         printf("\n");
139     }
140 }
141 
142 bool dfs(int step)
143 {
144     if (node[head].rc==head)
145     {
146         print();
147         return true;
148     }
149     
150     int i,j,c,t=210000,x,y,num,flag=0;
151     for (i=node[head].rc;i!=head;i=node[i].rc)
152         if (cnt[i]<t)
153         {
154             t=cnt[i];
155             c=i;
156         }
157     if (t==0)
158         return false;
159     cover(c);
160     
161     for (i=node[c].down;i!=c;i=node[i].down)
162     {
163         for (j=node[i].lc;j!=i;j=node[j].lc)
164             cover(node[j].col);
165         num=(node[i].row-1)/9+1;
166         x=(num-1)/9+1;
167         y=num-9*(x-1);
168         ans[x][y]=node[i].row-(num-1)*9;
169         if (dfs(step+1))
170             return true;
171         for (j=node[i].rc;j!=i;j=node[j].rc)
172             uncover(node[j].col);
173     }
174     
175     uncover(c);
176     return false;
177 }
178 
179 void solve()
180 {
181     init(m);
182     build_link();
183     if (!dfs(1))
184         printf("-1\n");
185 }
186 
187 int main()
188 {
189     freopen("alone.in","r",stdin);
190     freopen("alone.out","w",stdout);
191     read_data();
192     solve();
193     return 0;
194 }