解题：BZOJ 2673 World Final 2011 Chips Challenge

题面

数据范围看起来很像网络流诶(滚那

因为限制多而且强，数据范围也不大，我们考虑不直接求答案，而是转化为判定问题

可以发现第二个限制相对好满足，我们直接枚举这个限制就可以。具体来说是枚举所有行中的最大值$x$，然后下面那个式子移项就可以得到$a*tot>=b*x$，其中tot表示芯片的总数

然后发现第一个限制还是很强，不好满足。怎么办呢？正难则反，转化成补集的问题：先把所有能安的芯片都安了，然后扣出来合法的答案

那么现在我们要扣掉的芯片尽量少，同时还要先保证扣出来的结果合法，那考虑用最小费用最大流，用最大流的限制使得答案合法，用最小费用求答案

具体来说我们这样建图(下面再解释)：

①把原图拆成行和列共n个点

②记录每行每列最多的芯片个数(包括已经有的和空位)，从原点向一边连边，另一边向汇点连边(这里为了方便我默认原点向行连，汇点向列连)。容量为芯片个数，费用为零(这个不用解释吧)

③第i行向第i列连容量为我们枚举的答案的边，表示至多留下这些芯片，费用仍然为零

④对于每个空位(x,y)，从第x行向第y列连流量为1费用为1的边，表示同时从这一行一列扣掉一个芯片

然后跑最小费用最大流，当且仅当最大流等于芯片的最大总数(包括已经有的和空位))时更新答案，为什么？

因为最小费用最大流会优先保证满流，所以我们③中连的边相当于限制了每行每列的芯片个数一样，就满足了第一个限制，然后扣掉的加上剩下的等于总数才是合法的，所以这时候更新答案

大概就是这样，我觉得这题还是有点意思的=。=

 #include<queue>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 const int B=,N=,M=,inf=1e9;
 int mxr[B],mxc[B],mapp[B][B]; char rd[B];
 int mflw[N],mcst[N],pren[N],pree[N],queu[N];
 int p[N],noww[*M],goal[*M],flow[*M],cost[*M];
 int n,a,b,s,t,id,ocp,tot,num,cnt,ans,maxf,minc; queue<int> qs;
 void Link(int f,int t,int v,int c)
 {
     noww[++cnt]=p[f],p[f]=cnt;
     goal[cnt]=t,flow[cnt]=v,cost[cnt]=c;
     noww[++cnt]=p[t],p[t]=cnt;
     goal[cnt]=f,flow[cnt]=,cost[cnt]=-c;
 }
 void Setit()
 {
     memset(mxr,,sizeof mxr);
     memset(mxc,,sizeof mxc);
     ocp=tot=,ans=-,s=n*+,t=s+;
     for(int i=;i<=n;i++)
     {
         scanf("%s",rd+);
         for(int j=;j<=n;j++)
         {
             mapp[i][j]=rd[j],ocp+=rd[j]=='C';
             if(rd[j]!='/') mxr[i]++,mxc[j]++,tot++;
         }
     }
 }
 void Init(int st,int ed)
 {
     memset(mflw,0x3f,sizeof mflw);
     memset(mcst,0x3f,sizeof mcst);
     memset(queu,,sizeof queu),pren[ed]=-;
     qs.push(st),queu[st]=true,mcst[st]=;
 }
 bool SP(int st,int ed)
 {
     Init(st,ed);
     while(!qs.empty())
     {
         int tn=qs.front();
         qs.pop(),queu[tn]=false;
         for(int i=p[tn],g;i;i=noww[i])
             if(mcst[g=goal[i]]>mcst[tn]+cost[i]&&flow[i])
             {
                 pree[g]=i,pren[g]=tn;
                 mcst[g]=mcst[tn]+cost[i];
                 mflw[g]=min(mflw[tn],flow[i]);
                 if(!queu[g]) qs.push(g),queu[g]=true;
             }
     }
     return ~pren[ed];
 }
 void MCMF(int st,int ed)
 {
     while(SP(st,ed))
     {
         maxf+=mflw[ed],id=ed;
         minc+=mflw[ed]*mcst[ed];
         while(id!=st)
         {
             flow[pree[id]]-=mflw[ed];
             flow[pree[id]^]+=mflw[ed];
             id=pren[id];
         }
     }
 }
 int Solve(int x)
 {
     memset(p,,sizeof p),cnt=,maxf=minc=;
     for(int i=;i<=n;i++)
         Link(s,i,mxr[i],),Link(i+n,t,mxc[i],),Link(i,i+n,x,);
     for(int i=;i<=n;i++)
         for(int j=;j<=n;j++)
             if(mapp[i][j]=='.') Link(i,j+n,,); MCMF(s,t);
     return maxf==tot?(a*(tot-minc)>=b*x?tot-ocp-minc:-):-;
 }
 int main()
 {
     while(scanf("%d%d%d",&n,&a,&b)!=EOF)
         if(n||a||b)
         {
             Setit();
             for(int i=;i<=n;i++)
                 ans=max(ans,Solve(i));
             printf("Case %d: ",++num);
             ~ans?printf("%d\n",ans):printf("impossible\n");
         }
         else break;
     return ;
 }