劈配 [多省省选] [BZOJ5251] [网络流]

题目链接

分析：

这道题看题都看了我好久...

我们可以容易想到这道题和网络流有关。

首先，从原点向每个学员连一条流量为1的边

然后，要限制每个导师的学员，在每个导师连到汇点的时候流量限制为bi

再接着，按照学员的顺序一个个动态加边，一次性加入同样优先级的边，如果有增广路就记录答案。

（第一问完美解决）

然后第二问怎么做呢？

对于一个学员，如果已经确定了排位，那我们很容易的就能验证是不是满足他的要求。

那么我们就能在[1,i-1]的区间里二分答案去检验，在[1,now-1]的残余网络里面跑即可（注意加上他自己要求范围内的边）

如何优化？

第一问：如果把整个网络都加进去的话边数太多很可能会T，而我们发现有很多边是没用的->不能提供增广路的边

那我们在跑完一个优先级发现找不到增广路的时候就把这些边全删掉。

第二问：显然，二分答案每次都建立残余网络是一个很大的工程，我们可以在第一问依次处理时把残余网络图给存下来，第二问直接用即可。

Code

 #include<bits/stdc++.h>
 #define RG register int
 #define rep(i,a,b)    for(RG i=a;i<=b;++i)
 #define per(i,a,b)    for(RG i=a;i>=b;--i)
 #define ll long long
 #define inf (1<<29)
 #define maxn 210
 #define maxm 10010
 using namespace std;
 int p,c,n,m,cnt,S,T;
 int tmph[maxn][maxn<<],head[maxn<<],hd[maxn<<],step[maxn<<],ans[maxn],cntt[maxn];
 int a[maxn][maxn],Ex[maxn],lmp[maxn][maxn],level[maxn],deal[maxn][maxn][];
 struct E{
     int u,v,next,pre,fl;
 }e[maxm],tmpe[maxn][maxm];

 inline int read()
 {
     int x=,f=;char c=getchar();
     while(c<''||c>''){if(c=='-')f=-;c=getchar();}
     while(c>=''&&c<=''){x=x*+c-'';c=getchar();}
     return x*f;
 }

 void init()
 {
     memset(lmp,,sizeof(lmp));
     memset(head,,sizeof(head));
     cnt=;
 }

 inline void del(int i)
 {
     if(e[i].next)    e[e[i].next].pre=e[i].pre;
     if(e[i].pre)    e[e[i].pre].next=e[i].next;
     if(i==head[e[i].u]) head[e[i].u]=e[i].next;
 }

 inline void add(int u,int v,int w)
 {
     e[++cnt].v=v,e[cnt].u=u,e[cnt].next=head[u];
     if(head[u]) e[head[u]].pre=cnt;
     head[u]=cnt,e[cnt].fl=w;

     swap(u,v);

     e[++cnt].v=v,e[cnt].u=u,e[cnt].next=head[u];
     if(head[u]) e[head[u]].pre=cnt;
     head[u]=cnt,e[cnt].fl=;
 }

 inline void add2(int u,int v,int w)
 {
     e[++cnt].v=v,e[cnt].next=head[u],head[u]=cnt,e[cnt].fl=w;    swap(u,v);
     e[++cnt].v=v,e[cnt].next=head[u],head[u]=cnt,e[cnt].fl=;
 }

 bool bfs()
 {
     queue<int> que;
     memset(step,,(T<<)+);memcpy(hd,head,(T<<)+);
     que.push(S),step[S]=;
     RG u,v;
     while(!que.empty())
     {
         u=que.front(),que.pop();
         for(RG i=head[u];i;i=e[i].next)
         {
             v=e[i].v;
             if(e[i].fl&&!step[v])    step[v]=step[u]+,que.push(v);
         }
     }
     return step[T];
 }

 int dfs(int u,int fl)
 {
     if(u==T) return fl;
     int tp,tt=;
     for(RG &i=hd[u];i;i=e[i].next){
         int v=e[i].v;
         if(e[i].fl&&step[v]==step[u]+)
         {
             tp=dfs(e[i].v,min(e[i].fl,fl));
             tt+=tp;
             e[i].fl-=tp;
             e[i^].fl+=tp;
             if(tt==fl) return tt;
         }
     }
     if(tt!=fl) step[u]=-;
     return tt;
 }

 void work1()
 {
     RG l;
     rep(i,,n)
     {
         ans[i]=m+,add(S,i,);
         rep(j,,m)
         {
             if(!lmp[i][j]) continue;
             l=cnt;
             rep(k,,lmp[i][j])         add(i,deal[i][j][k]+n,);
             if(bfs()&&dfs(S,inf))    {ans[i]=j;break;}
             else                    {rep(k,l,cnt) del(k);cnt=l;}
         }
         rep(j,,T)        tmph[i][j]=head[j];
         rep(j,,cnt)    tmpe[i][j]=e[j];
         cntt[i]=cnt;
     }
     rep(i,,n) printf("%d ",ans[i]);puts("");
 }

 bool judge(int u,int w)
 {
     cnt=cntt[w-];
     rep(i,,T)        head[i]=tmph[w-][i];
     rep(i,,cnt)    e[i]=tmpe[w-][i];

     add(S,u,);

     rep(i,,Ex[u])
     {
         if(!lmp[u][i]) continue;
         rep(j,,lmp[u][i]) add2(u,deal[u][i][j]+n,);
     }

     return (bfs()&&dfs(S,inf));
 }

 void input()
 {
     n=read(),m=read();
     S=n+m+,T=n+m+;
     rep(i,,m)
     {
         level[i]=read();
         add(i+n,T,level[i]);
     }
     cntt[]=cnt;
     rep(i,,cnt)    tmpe[][i]=e[i];
     rep(i,,T)        tmph[][i]=head[i];
     rep(i,,n)    rep(j,,m)
     {
         a[i][j]=read();    if(!a[i][j]) continue;
         deal[i][a[i][j]][++lmp[i][a[i][j]]] = j;
     }
     rep(i,,n) Ex[i]=read();
 }

 void work2()
 {
     RG l,r,mid,ans2;
     rep(i,,n)
     {
         if(ans[i]<=Ex[i]){printf("0 ");continue;}
         l=,r=i-,ans2=;
         while(l<=r)
         {
             mid=l+r>>;
             if(judge(i,mid))    ans2=mid,l=mid+;
             else                r=mid-;
         }
         printf("%d ",i-ans2);
     }
     puts("");
 }

 int main()
 {
     freopen("mentor.in","r",stdin);
     freopen("mentor.out","w",stdout);
     int TT,C;
     TT=read(),C=read();
     while(TT--)
     {
         init();
         input();
         work1();
         work2();
     }
     return ;
 }