洛谷 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
",__LINE__,__FUNCTION__)
using namespace std;
il int gi()
{
    int a=0;char x=getchar();bool f=0;
    while((x>'9'||x<'0')&&x!='-')x=getchar();
    if(x=='-')x=getchar(),f=1;
    while(x>='0'&&x<='9')a=a*10+x-48,x=getchar();
    return f?-a:a;
}
const int N=100005,inf=23333333;
int n,m,k,s,t=5200,dis[N],h[N],cnt=1,ans;
struct edge{
int to,net,v;
}e[N*2];
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=0,h[v]=cnt;
}
queue<int>q;
il bool bfs()
{
    memset(dis,-1,sizeof(dis));
    q.push(s);dis[s]=0;
    while(!q.empty())
    {
        int u=q.front();q.pop();
        for(int i=h[u];i;i=e[i].net)
        if(dis[e[i].to]==-1&&e[i].v>0)dis[e[i].to]=dis[u]+1,q.push(e[i].to);
    }
    return dis[t]!=-1;
}
il int dfs(int u,int op)
{
    if(u==t)return op;
    int flow=0,used=0;
    for(int i=h[u];i;i=e[i].net)
    {
        int v=e[i].to;
        if(dis[v]==dis[u]+1&&e[i].v>0)
        {
            used=dfs(v,min(op,e[i].v));
            if(!used)continue;
            flow+=used,op-=used;
            e[i].v-=used,e[i^1].v+=used;
            if(!op)break;
        }
    }
    if(!flow)dis[u]=-1;
    return flow;
}
int main()
{
    k=gi(),n=gi();int num,p;
    for(int i=1;i<=k;i++)num=gi(),m+=num,add(s,i,num);
    for(int i=1;i<=n;i++){
        num=gi();
        while(num--){
            p=gi();add(p,i+k,1);
        }
        add(i+k,t,1);
    }
    while(bfs())ans+=dfs(s,inf);
    if(ans!=m)printf("No Solution!");
    else {
            for(int i=1;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("
");
            }
    }
    return 0;
}