UVA - 1603 Square Destroyer (DLX可重复覆盖+IDA*)

题目链接

给你一个n*n的由火柴组成的正方形网格，从中预先拿掉一些火柴，问至少还需要拿掉多少火柴才能破坏掉所有的正方形。

看到这道题，我第一反应就是——把每根火柴和它能破坏掉的正方形连边，不就是个裸的DLX了吗？二话不说直接把我以前写过的DLX板子拿了过来。不过这个问题是可重复覆盖而不是精确覆盖，其实只需要在精确覆盖的基础上稍作修改就行了。

建图方法：枚举出网格完整时所有的火柴和正方形，给它们编上号，除了被拿掉的火柴和已经被破坏掉的正方形，其余的所有火柴和它能破坏掉的正方形连边。

注意跑DLX前要先把所有的空列清掉，否则会死循环。

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int N=,inf=0x3f3f3f3f;
 struct D {
     int x[],y[];
     bool isbound(D& b) {
         for(int i=; i<; ++i) {
             if(x[i]>b.x[]&&x[i]<b.x[]&&y[i]>b.y[]&&y[i]<b.y[])return ;
             if(x[i]<b.x[]||x[i]>b.x[]||y[i]<b.y[]||y[i]>b.y[])return ;
         }
         return ;
     }
 } rod[N],sqr[N];
 int n,nrod,nsqr,delrod[N],delsqr[N],m;
 struct DLX {
     static const int N=;
     static const int M=;
     static const int MX=;
     int n,tot,S[M],H[N],vis[M],ans;
     int row[MX],col[MX],L[MX],R[MX],U[MX],D[MX];
     void init(int _n) {
         n=_n;
         for(int i=; i<=n; ++i) {
             U[i]=D[i]=i;
             L[i]=i-,R[i]=i+;
         }
         L[]=n,R[n]=;
         tot=n+;
         memset(S,,sizeof S);
         memset(H,-,sizeof H);
         memset(vis,,sizeof vis);
         ans=inf;
     }
     void link(int r,int c) {
         int u=tot++;
         S[c]++;
         row[u]=r,col[u]=c;
         U[u]=U[c],D[u]=c;
         U[D[u]]=D[U[u]]=u;
         if(!~H[r])H[r]=L[u]=R[u]=u;
         else {
             R[u]=H[r],L[u]=L[H[r]];
             L[R[u]]=R[L[u]]=u;
         }
     }
     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 restore(int c) {
         for(int i=U[c]; i!=c; i=U[i])L[R[i]]=R[L[i]]=i;
     }
     int h() {
         int ret=;
         for(int c=R[]; c!=; c=R[c])vis[c]=;
         for(int c=R[]; c!=; c=R[c])if(vis[c]) {
                 ++ret,vis[c]=;
                 for(int i=D[c]; i!=c; i=D[i])
                     for(int j=R[i]; j!=i; j=R[j])vis[col[j]]=;
             }
         return ret;
     }
     void check() {
         for(int c=; c<=n; ++c)if(!S[c]) {
                 for(int i=D[c]; i!=c; i=D[i])L[R[i]]=L[i],R[L[i]]=R[i];
                 L[R[c]]=L[c],R[L[c]]=R[c];
             }
     }
     void dfs(int dep) {
         if(R[]==) {ans=dep; return;};
         if(dep+h()>ans)return;
         int c=R[];
         for(int i=R[]; i!=; 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);
             dfs(dep+);
             for(int j=L[i]; j!=i; j=L[j])restore(j);
             restore(i);
         }
     }
 } dlx;

 int main() {
     int T;
     for(scanf("%d",&T); T--;) {
         scanf("%d",&n);
         nrod=nsqr=;
         for(int i=; i<=n; ++i) {
             for(int j=; j<=n; ++j)if(j+<=n)rod[nrod++]= {i,i,j,j+};
             for(int j=; j<=n; ++j)if(i+<=n)rod[nrod++]= {i,i+,j,j};
         }
         for(int i=; i<=n; ++i)
             for(int j=; j<=n; ++j)
                 for(int w=; w<=n; ++w)
                     if(i+w<=n&&j+w<=n)sqr[nsqr++]= {i,i+w,j,j+w};
         memset(delrod,,sizeof delrod);
         memset(delsqr,,sizeof delsqr);
         scanf("%d",&m);
         while(m--) {
             int x;
             scanf("%d",&x);
             delrod[x-]=;
             for(int j=; j<nsqr; ++j)
                 if(rod[x-].isbound(sqr[j]))delsqr[j]=;
         }
         dlx.init(nsqr);
         for(int i=; i<nrod; ++i)if(!delrod[i])
                 for(int j=; j<nsqr; ++j)if(!delsqr[j])
                         if(rod[i].isbound(sqr[j]))
                             dlx.link(i+,j+);
         dlx.check();
         dlx.dfs();
         printf("%d\n",dlx.ans);
     }
     return ;
 }

以上是普通DLX可重复覆盖的代码，也可以用IDA*优化一下，代码基本一致：

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int N=;
 struct D {
     int x[],y[];
     bool isbound(D& b) {
         for(int i=; i<; ++i) {
             if(x[i]>b.x[]&&x[i]<b.x[]&&y[i]>b.y[]&&y[i]<b.y[])return ;
             if(x[i]<b.x[]||x[i]>b.x[]||y[i]<b.y[]||y[i]>b.y[])return ;
         }
         return ;
     }
 } rod[N],sqr[N];
 int n,nrod,nsqr,delrod[N],delsqr[N],m;
 struct DLX {
     static const int N=;
     static const int M=;
     static const int MX=;
     int n,tot,S[M],H[N],vis[M];
     int row[MX],col[MX],L[MX],R[MX],U[MX],D[MX];
     void init(int _n) {
         n=_n;
         for(int i=; i<=n; ++i) {
             U[i]=D[i]=i;
             L[i]=i-,R[i]=i+;
         }
         L[]=n,R[n]=;
         tot=n+;
         memset(S,,sizeof S);
         memset(H,-,sizeof H);
         memset(vis,,sizeof vis);
     }
     void link(int r,int c) {
         int u=tot++;
         S[c]++;
         row[u]=r,col[u]=c;
         U[u]=U[c],D[u]=c;
         U[D[u]]=D[U[u]]=u;
         if(!~H[r])H[r]=L[u]=R[u]=u;
         else {
             R[u]=H[r],L[u]=L[H[r]];
             L[R[u]]=R[L[u]]=u;
         }
     }
     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 restore(int c) {
         for(int i=U[c]; i!=c; i=U[i])L[R[i]]=R[L[i]]=i;
     }
     int h() {
         int ret=;
         for(int c=R[]; c!=; c=R[c])vis[c]=;
         for(int c=R[]; c!=; c=R[c])if(vis[c]) {
                 ++ret,vis[c]=;
                 for(int i=D[c]; i!=c; i=D[i])
                     for(int j=R[i]; j!=i; j=R[j])vis[col[j]]=;
             }
         return ret;
     }
     void check() {
         for(int c=; c<=n; ++c)if(!S[c]) {
                 for(int i=D[c]; i!=c; i=D[i])L[R[i]]=L[i],R[L[i]]=R[i];
                 L[R[c]]=L[c],R[L[c]]=R[c];
             }
     }
     bool dfs(int dep,int mxd) {
         if(R[]==)return ;
         if(dep+h()>mxd)return ;
         int c=R[];
         for(int i=R[]; i!=; 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(dfs(dep+,mxd))return ;
             for(int j=L[i]; j!=i; j=L[j])restore(j);
             restore(i);
         }
         return ;
     }
     int IDAStar() {for(int mxd=;; ++mxd) {if(dfs(,mxd))return mxd;}}
 } dlx;

 int main() {
     int T;
     for(scanf("%d",&T); T--;) {
         scanf("%d",&n);
         nrod=nsqr=;
         for(int i=; i<=n; ++i) {
             for(int j=; j<=n; ++j)if(j+<=n)rod[nrod++]= {i,i,j,j+};
             for(int j=; j<=n; ++j)if(i+<=n)rod[nrod++]= {i,i+,j,j};
         }
         for(int i=; i<=n; ++i)
             for(int j=; j<=n; ++j)
                 for(int w=; w<=n; ++w)
                     if(i+w<=n&&j+w<=n)sqr[nsqr++]= {i,i+w,j,j+w};
         memset(delrod,,sizeof delrod);
         memset(delsqr,,sizeof delsqr);
         scanf("%d",&m);
         while(m--) {
             int x;
             scanf("%d",&x);
             delrod[x-]=;
             for(int j=; j<nsqr; ++j)
                 if(rod[x-].isbound(sqr[j]))delsqr[j]=;
         }
         dlx.init(nsqr);
         for(int i=; i<nrod; ++i)if(!delrod[i])
                 for(int j=; j<nsqr; ++j)if(!delsqr[j])
                         if(rod[i].isbound(sqr[j]))
                             dlx.link(i+,j+);
         dlx.check();
         printf("%d\n",dlx.IDAStar());
     }
     return ;
 }

感觉对于这种裸的可重复覆盖而言，DLX除了板子代码长了点外就没什么缺点了，直接无脑建图就行了~~