FZU 1686 dlx重复覆盖

 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #include <algorithm>
 #include <queue>
 #include <climits>
 #include <cmath>

 using namespace std;
 #define N 230
 #define MAXNODE 60000
 const int INF = INT_MAX;
 const double eps = 1e-;

 int n,m,n1,m1;

 struct DLX{
     int n,m,size;
     int U[MAXNODE] , D[MAXNODE] , L[MAXNODE] , R[MAXNODE];
     int col[MAXNODE] , row[MAXNODE];
     int first[N] , cnt_col[N] , ans;
     bool v[MAXNODE];

     void init(int _n , int _m)
     {
         n = _n , m = _m , size = _m;
         for(int i= ; i<=m ; i++){
             U[i] = D[i] = i;
             L[i] = i- , R[i] = i+;
             col[i] = i , row[i] = ;
         }
         L[] = m , R[m] = ;
         for(int i= ; i<=n ; i++) first[i] = -;
         for(int i= ; i<=m ; i++) cnt_col[i] = ;
         ans = INF;
     }

     void link(int r , int c)
     {
         ++size;
         U[D[c]] = size , D[size] = D[c];
         U[size] = c , D[c] = size;
         cnt_col[c]++;

         if(first[r]<) first[r] = L[size] = R[size] = size;
         else{
             R[size] = R[first[r]] , L[R[first[r]]] = size;
             L[size] = first[r] , R[first[r]] = size;
         }
         row[size] = r , col[size] = c;
     }

     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 f()
     {
         int ret = ;
         for(int c=R[] ; c!= ; c=R[c]) v[c]=true;
         for(int c=R[] ; c!= ; c=R[c])
             if(v[c]){
                 ret++;
                 v[c] = false;
                 for(int i=D[c] ; i!=c ; i=D[i])
                     for(int j=R[i] ; j!= i ; j=R[j])
                         v[col[j]]=false;
             }
         return ret;
     }

     void Dance(int d)
     {
         if(d+f() >= ans) return;
         if(!R[]){
             ans = min(ans , d);
             return;
         }
         int st = R[];
         for(int i=R[] ; i!= ; i=R[i])
             if(cnt_col[st]>cnt_col[i]) st=i;

         for(int i=D[st] ; i!=st ; i=D[i]){
             Remove(i);
             for(int j=R[i] ; j!=i ; j=R[j]) Remove(j);
             Dance(d+);
             for(int j=L[i] ; j!=i ; j=L[j]) Resume(j);
             Resume(i);
         }
         return;
     }
 }dlx;

 int mat[N][N] , id[N][N];

 int main()
 {
   //  freopen("a.in" , "r" , stdin);
     while(~scanf("%d%d" , &n , &m))
     {
         int size = ;
         for(int i= ; i<n ; i++)
             for(int j= ; j<m ; j++)
             {
                 scanf("%d" , &mat[i][j]);
                 //这里可以适当加优化，只保留那些有怪兽存在的位置
                 if(mat[i][j]) size++ , id[i][j] = size;
             }
         scanf("%d%d" , &n1 , &m1);
         int t = (n-n1+)*(m-m1+);

         dlx.init(t , size);
         for(int k= ; k<t ; k++){
             int row = k/(m-m1+);
             int col = k%(m-m1+);
             for(int i=row ; i<row+n1 ; i++)
                 for(int j=col ; j<col+m1 ; j++)
                     if(mat[i][j]) dlx.link(k+ , id[i][j]);
         }
         dlx.Dance();
         printf("%d\n" , dlx.ans);
     }
     return ;
 }