洛谷 P2763 试题库问题（网络流24题之一）

题目描述

«问题描述：

假设一个试题库中有n道试题。每道试题都标明了所属类别。同一道题可能有多个类别属性。现要从题库中抽取m 道题组成试卷。并要求试卷包含指定类型的试题。试设计一个满足要求的组卷算法。

«编程任务：

对于给定的组卷要求，计算满足要求的组卷方案。

输入输出格式

输入格式：

第1行有2个正整数k和n (2 <=k<= 20, k<=n<= 1000)

k 表示题库中试题类型总数，n 表示题库中试题总数。第2 行有k 个正整数，第i 个正整数表示要选出的类型i的题数。这k个数相加就是要选出的总题数m。接下来的n行给出了题库中每个试题的类型信息。每行的第1 个正整数p表明该题可以属于p类，接着的p个数是该题所属的类型号。

输出格式：

第i 行输出 “i：”后接类型i的题号。如果有多个满足要求的方案，只要输出1个方案。如果问题无解，则输出“No Solution!”。

输入输出样例

输入样例#1：

3 15
3 3 4
2 1 2
1 3
1 3
1 3
1 3
3 1 2 3
2 2 3
2 1 3
1 2
1 2
2 1 2
2 1 3
2 1 2
1 1
3 1 2 3

输出样例#1：

1: 1 6 8
2: 7 9 10
3: 2 3 4 5

Solution：

　　题意容易理解，大致求的是n到题能不能组成k种类型且满足每种类型的数量要求。

　　仔细思考，不难发现该题类似于匹配，因为一道题只能属于一种类型，那么这不就是类似于二分图匹配呀，只不过这里的类型能匹配多道题罢了，万变不离其宗嘛！所以我们可以用匈牙利算法来做，当然我还是弱弱地用最大流做做吧！

　　首先，先统计所有类型包含的题目总数m，然后我们直接建立源点S连向每种类型，容量为该类型所含的题目个数，再每种类型连向可以匹配的题目，容量为1,最后每道题都连向汇点T。最后跑最大流，若ans！=m，说明没有匹配完全，若ans==m，输出时直接判断与每种类型相连的边容量是否为0（说明该边连接的题匹配过）且连向的点不为源点S（因为容量为0的边也有可能是源点连向某一类型的边的反向边）。输出的方法有许多种，若按我上述的方法输出，则加黑部分一定要写上，不然理论上可能爆0（但是洛谷数据水，最先没删调试语句有90分，开始以为是调试语句的问题，后来发现是没写加黑部分的语句，结果都有90分～神奇啊）

代码：

 // luogu-judger-enable-o2
 #include<bits/stdc++.h>
 #define il inline
 #define debug printf("%d %s\n",__LINE__,__FUNCTION__)
 using namespace std;
 il int gi()
 {
     int a=;char x=getchar();bool f=;
     while((x>''||x<'')&&x!='-')x=getchar();
     if(x=='-')x=getchar(),f=;
     while(x>=''&&x<='')a=a*+x-,x=getchar();
     return f?-a:a;
 }
 const int N=,inf=;
 int n,m,k,s,t=,dis[N],h[N],cnt=,ans;
 struct edge{
 int to,net,v;
 }e[N*];
 il void add(int u,int v,int w)
 {
     e[++cnt].to=v,e[cnt].net=h[u],e[cnt].v=w,h[u]=cnt;
     e[++cnt].to=u,e[cnt].net=h[v],e[cnt].v=,h[v]=cnt;
 }
 queue<int>q;
 il bool bfs()
 {
     memset(dis,-,sizeof(dis));
     q.push(s);dis[s]=;
     while(!q.empty())
     {
         int u=q.front();q.pop();
         for(int i=h[u];i;i=e[i].net)
         if(dis[e[i].to]==-&&e[i].v>)dis[e[i].to]=dis[u]+,q.push(e[i].to);
     }
     return dis[t]!=-;
 }
 il int dfs(int u,int op)
 {
     if(u==t)return op;
     int flow=,used=;
     for(int i=h[u];i;i=e[i].net)
     {
         int v=e[i].to;
         if(dis[v]==dis[u]+&&e[i].v>)
         {
             used=dfs(v,min(op,e[i].v));
             if(!used)continue;
             flow+=used,op-=used;
             e[i].v-=used,e[i^].v+=used;
             if(!op)break;
         }
     }
     if(!flow)dis[u]=-;
     return flow;
 }
 int main()
 {
     k=gi(),n=gi();int num,p;
     for(int i=;i<=k;i++)num=gi(),m+=num,add(s,i,num);
     for(int i=;i<=n;i++){
         num=gi();
         while(num--){
             p=gi();add(p,i+k,);
         }
         add(i+k,t,);
     }
     while(bfs())ans+=dfs(s,inf);
     if(ans!=m)printf("No Solution!");
     else {
             for(int i=;i<=k;i++)
             {
                 printf("%d: ",i);
                 for(int j=h[i];j;j=e[j].net)
                 if(!e[j].v&&e[j].to)printf("%d ",e[j].to-k);
                 printf("\n");
             }
     }
     return ;
 }