TYVJ1035 棋盘覆盖

时间: 1000ms / 空间: 131072KiB / Java类名: Main

描述

给出一张n*n(n<=100)的国际象棋棋盘，其中被删除了一些点，问可以使用多少1*2的多米诺骨牌进行掩盖。

输入格式

第一行为n，m（表示有m个删除的格子）
第二行到m+1行为x,y，分别表示删除格子所在的位置
x为第x行
y为第y列 

输出格式

一个数，即最大覆盖格数

测试样例1

输入

8 0

输出

32

备注

经典问题

最大点独立集 二分图匹配

匈牙利算法 || 网络流

匈牙利算法：

 /*by SilverN*/
 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<cstdio>
 #include<cmath>
 using namespace std;
 const int mxn=;
 const int mx[]={,,,-,};
 const int my[]={,,,,-};
 int read(){
     int x=,f=;char ch=getchar();
     while(ch<'' || ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>='' && ch<=''){x=x*+ch-'';ch=getchar();}
     return x*f;
 }
 int n,m;
 int mp[mxn][mxn];
 int link[mxn][mxn][];
 bool vis[mxn][mxn];
 bool DFS(int x,int y){
     for(int k=;k<=;k++){
         int nx=x+mx[k];
         int ny=y+my[k];
         if(nx< || nx>n || ny< || ny>n)continue;
         if(mp[nx][ny])continue;
         if(!vis[nx][ny]){
             vis[nx][ny]=;
             if((!link[nx][ny][] && !link[nx][ny][]) || DFS(link[nx][ny][],link[nx][ny][])){
                 link[nx][ny][]=x;
                 link[nx][ny][]=y;
                 return ;
             }
         }
     }
     return ;
 }
 int ans=;
 void solve(){
     for(int i=;i<=n;i++)
      for(int j=;j<=n;j++){
          if(mp[i][j])continue;
          if((i+j)&){
              memset(vis,,sizeof vis);
              if(DFS(i,j))ans++;
          }
      }
     return;
 }
 int main(){
     int i,j,x,y;
     n=read();m=read();
     for(i=;i<=m;i++){
         x=read();y=read();
         mp[x][y]=;//障碍
     }
     solve();
     printf("%d\n",ans);
     return ;
 }

网络流：

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<queue>
 #include<vector>
 using namespace std;
 const int mx[]={,,,-,};
 const int my[]={,,,,-};
 const int mxn=;
 int read(){
     int x=,f=;char ch=getchar();
     while(ch<'' || ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>='' && ch<=''){x=x*-''+ch;ch=getchar();}
     return x*f;
 }
 struct edge{int v,nxt,f;}e[mxn<<];
 int hd[mxn],mct=;
 void add_edge(int u,int v,int f){
     e[++mct].v=v;e[mct].f=f;e[mct].nxt=hd[u];hd[u]=mct;return;
 }
 int n,m;
 int S,T;
 int d[mxn];
 int id[][];
 int mp[][];
 bool BFS(int s,int t){
     queue<int>q;
     memset(d,,sizeof d);
     d[s]=;
     q.push(s);
     while(!q.empty()){
         int u=q.front();q.pop();
         for(int i=hd[u];i;i=e[i].nxt){
             int v=e[i].v;
             if(!d[v] && e[i].f){
                 d[v]=d[u]+;
                 q.push(v);
             }
         }
     }
     return d[t];
 }
 int DFS(int u,int lim){
     if(u==T)return lim;
     int tmp,f=;
     for(int i=hd[u];i;i=e[i].nxt){
         int v=e[i].v;
         if(d[v]==d[u]+ && e[i].f){
             tmp=DFS(v,min(lim,e[i].f));
             e[i].f-=tmp;
             e[i^].f+=tmp;
             lim-=tmp;
             f+=tmp;
             if(!lim)return f;
         }
     }
     d[u]=;
     return f;
 }
 inline int Dinic(){
     int res=;
     while(BFS(S,T))res+=DFS(S,1e9);
     return res;
 }
 void solve(){
     int i,j;
     for(i=;i<=n;i++)
      for(j=;j<=n;j++)
          id[i][j]=(i-)*n+j;
     for(i=;i<=n;i++)
      for(j=;j<=n;j++){
          if(mp[i][j])continue;
          if((i+j)%==)
         {
             add_edge(S,id[i][j],);
             add_edge(id[i][j],S,);
              for(int k=;k<=;k++){
                  int nx=i+mx[k],ny=j+my[k];
                  if(nx< || nx>n || ny< || ny>n || mp[nx][ny])continue;
                  add_edge(id[i][j],id[nx][ny],);
                  add_edge(id[nx][ny],id[i][j],);
              }
         }
         else{
             add_edge(id[i][j],T,);
             add_edge(T,id[i][j],);
         }
      }
     return;
 }
 int main()
 {
     n=read();m=read();
     int i,j,u,v;
     for(i=;i<=m;i++){
         u=read();v=read();
         mp[u][v]=;//标记障碍
     }
     S=;T=n*n+;
     solve();
     int ans=Dinic();
     printf("%d\n",ans);
     return ;
 }