简单易懂的Dancing links讲解（3）

Dancing Links除了能解决精确覆盖问题，还能解决重复覆盖问题，这里重点讲重复覆盖

题目：高手做题                                  

描述                                 

SubRaY被布置了n道作业题,可是他一道也不会..但他知道有w位高手,并知道每位高手                             

会做哪些题,请问SubRaY至少请多少位高手,才能把所有的题都做出来?                              

                                  

输入                                 

第一行两个整数n,w表示有n道作业题和w位高手,作业题以1..n编号.接下来w行,第i+1                                 

行第一个数li表示第i位高手会做的题目的数量,接下来li个数表示第i位高手会做哪                                  

些题目.                            

3<=n,w<=60,1<=li<=6                                

                                  

输出                                 

一个数,SubRaY至少要请多少位高手.                                

                                  

样例输入                                

4 4                             

2 1 2                                 

1 4                             

3 2 3 4                              

2 1 3                                                          

样例输出                                

2     

代码参考：http://blog.sina.com.cn/s/blog_51cea4040100gwpv.html      

为了详细讲解Dancing links 重复覆盖的过程，我们先把样例输入转换为如下01矩阵

和精确覆盖一样，先选择含1最少的列，这里选择的1行1列的，选择后，

第1和2列被删除了，第一步， 效果如下：

选择3行3列后，第3,4列也被删除了，至此重复覆盖的一个解已经被找到了，即1,3行，

但还不能确定这个解是最优的（可能只需一行就可以把所有列都覆盖）,还需要继续搜索，

第二步

第三步，开始回溯，选择3行3列的兄弟节点4行3列后的效果如下

上图那样不能得到解，继续回溯到如下效果，第四步

第五步

第六步

至此重复覆盖的另一个解已经被找到了，即3行和4行，    

现在，所有的节点都被遍历过了，这个重复覆盖总共有两个解；1行和3行，3行和4行，每个解都是最优的，都需要两个高手

可供参考的剪枝函数：

 int Hash()
 {
     int ans=0;
     bool hash[maxn]={0};
     for (int c=R[0];c!=0;c=R[c])
  {
         if (!hash[c])
         {
             hash[c]=1;
             ans++;
             for (int i=D[c];i!=c;i=D[i])
                 for (int j=R[i];j!=i;j=R[j])
                     hash[nCol[j]]=1;
         }
  }
     cout << "Hash =>" << ans << endl;
     return ans;
 }

这个函数实际上是在对当前状态进行重复覆盖，只是覆盖列时，不是删除列，而是把相应列的标志位置1       ，这个函数的目的是，预先估计当前这样选择后，还需要多少行才能覆盖所有列。  

函数返回值越大，越可能被剪枝

Dancing links 精确覆盖和重复覆盖的区别

1.精确覆盖更能体现dancing links 的威力，因为在剪枝的时候，精确覆盖不仅对列剪枝，对行也进行了剪枝，                          

       而重复覆盖只对列进行剪枝，要想提高重复覆盖的效率还需要自己写剪枝函数                        

2.重复覆盖问题一般是求解最优解的，不像精确覆盖找到一个解就算完事，因此重复覆盖需要遍历和考察所有的分支，来找到最优的

全部代码：

 #include<iostream>
 using namespace std;
 const int maxn=20;
 int L[maxn],R[maxn],U[maxn],D[maxn];
 int S[maxn]={0};
 int nCol[maxn];
 int nRow[maxn];
 bool answer[4]={0};
 int n,w;
 int best=INT_MAX;

 int sample[4][4] = {
                  {1,1,0,0},
                  {0,0,0,1},
                  {0,1,1,1},
                  {1,0,1,0}
                 };

 void init()
 {
     n=4;
     w=4;
     for (int i=0;i<=n;i++)
     {
         L[i]=i-1; R[i]=i+1;
         U[i]=D[i]=i;
     }
     L[0]=n;
     R[n]=0;
     int cnt=n+1;
     for (int i=0;i<w;i++)
     {
         int head=cnt,tail=cnt;
         for (int j=0;j<n;j++)
         {
             int c = j+1;
             if(sample[i][j]==1)
             {
                 S[c]++;
                 nCol[cnt]=c;
                 nRow[cnt]=i;
                 U[D[c]]=cnt;
                 D[cnt]=D[c];
                 U[cnt]=c;
                 D[c]=cnt;
                 L[cnt]=tail; R[tail]=cnt;
                 R[cnt]=head; L[head]=cnt;
                 tail=cnt;
                 cnt++;
             }
         }
     }
 }
 void Remove(int x)
 {
     cout << "remove=>" << x << endl;
     for (int i=D[x];i!=x;i=D[i])
     {
         L[R[i]]=L[i];
         R[L[i]]=R[i];
         S[nCol[i]]--;
     }
 }
 void Resume(int x)
 {
     cout << "Resume=>" << x << endl;
     for (int i=U[x];i!=x;i=U[i])
     {
         L[R[i]]=R[L[i]]=i;
         S[nCol[i]]++;
     }
 }
 int Hash()
 {
     int ans=0;
     bool hash[maxn]={0};
     for (int c=R[0];c!=0;c=R[c])
     {
         if (!hash[c])
         {
             hash[c]=1;
             ans++;
             for (int i=D[c];i!=c;i=D[i])
                 for (int j=R[i];j!=i;j=R[j])
                     hash[nCol[j]]=1;
         }
     }
     cout << "Hash =>" << ans << endl;
     return ans;
 }
 void dfs(int ans)
 {
     int best2 = ans + Hash();
     if (best2>=best)
         return;
     if (R[0]==0)
     {
         best=ans;
         for (int i = 0; i < 4; i++)
         {
             if ( answer[ i ] )
             {
                for (int j = 0; j < 4; j++) cout << sample[ i ][ j ] << " ";
                cout << endl;
             }
         }
         return;
     }
     int c,minnum=INT_MAX;
     for (int i=R[0];i!=0;i=R[i])
     {
         if (S[i]==0) return;
         if (S[i]<minnum)
         {
             minnum=S[i];
             c=i;
         }
     }
     for (int i=U[c];i!=c;i=U[i])
     {
         answer[nRow[i]]=true;
         Remove(i);
         for (int j=R[i];j!=i;j=R[j])
             Remove(j);
         dfs(ans+1);
         for (int j=L[i];j!=i;j=L[j])
             Resume(j);
         Resume(i);
         answer[nRow[i]]=false;
     }
 }
 int main()
 {
    // freopen("data.in","r",stdin);
    // freopen("data.out","w",stdout);
     init();
     dfs(0);
        printf("%d\n",best);
    // fclose(stdin);
    // fclose(stdout);
     getchar();
     return 0;
 }