(color{#0066ff}{题目描述})
«问题描述：
假设一个试题库中有n道试题。每道试题都标明了所属类别。同一道题可能有多个类别属性。现要从题库中抽取m 道题组成试卷。并要求试卷包含指定类型的试题。试设计一个满足要求的组卷算法。
«编程任务：
对于给定的组卷要求，计算满足要求的组卷方案。
(color{#0066ff}{输入格式})
第1行有2个正整数k和n (2<=k<=20, k<=n<=1000),k 表示题库中试题类型总数，n 表示题库中试题总数。
第2 行有k 个正整数，第i 个正整数表示要选出的类型i的题数。这k个数相加就是要选出的总题数m。
接下来的n行给出了题库中每个试题的类型信息。每行的第1 个正整数p表明该题可以属于p类，接着的p个数是该题所属的类型号。。
(color{#0066ff}{输出格式})
第i 行输出 “i：”后接类型i的题号。如果有多个满足要求的方案，只要输出1个方案。如果问题无解，则输出“No Solution!”。
有spj
(color{#0066ff}{输入样例})
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
(color{#0066ff}{输出样例})
1: 1 6 8
2: 7 9 10
3: 2 3 4 5
(color{#0066ff}{题解})
这题主要是建模，其实挺好想的
注意有spj
建立超级源s和超级汇t
(color{#00ccff}{每个类型})向(color{#00ccff}{t})连容量为(color{red}{该类型所需题数})的边，以保证每个类型得到应有题数
(color{#00ccff}{每个题})向(color{#00ccff}{其所属类型})连容量为(color{red}{1})的边，因为它对每个类型只能产生1的贡献
(color{#00ccff}{s})向(color{#00ccff}{每个题})连容量为(color{red}{1})的边，因为一个题被分且仅被分到一个集合中去
给他限制分配量1，让它最多流向一个集合
#include<cstdio>
#include<queue>
#include<vector>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cctype>
#include<cmath>
#define _ 0
#define LL long long
#define Space putchar(' ')
#define Enter putchar('
')
#define fuu(x,y,z) for(int x=(y);x<=(z);x++)
#define fu(x,y,z) for(int x=(y);x<(z);x++)
#define fdd(x,y,z) for(int x=(y);x>=(z);x--)
#define fd(x,y,z) for(int x=(y);x>(z);x--)
#define mem(x,y) memset(x,y,sizeof(x))
#ifndef olinr
inline char getc()
{
static char buf[100001],*p1=buf,*p2=buf;
return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,100001,stdin),p1==p2)? EOF:*p1++;
}
#else
#define getc() getchar()
#endif
template<typename T>inline void in(T &x)
{
int f=1; char ch; x=0;
while(!isdigit(ch=getc()))(ch=='-')&&(f=-f);
while(isdigit(ch)) x=x*10+(ch^48),ch=getc();
x*=f;
}
struct node
{
int to;
int nxt;
int cap,flow;
}e[5050505];
int head[10505],cur[10505],dep[10505];
bool vis[10505];
int cnt=1;
int s,t;
int n,k;
std::queue<int> q;
const int inf=0x7fffffff;
inline void add(int from,int to,int cap)
{
cnt++;
e[cnt].to=to;
e[cnt].cap=cap;
e[cnt].flow=0;
e[cnt].nxt=head[from];
head[from]=cnt;
}
inline bool bfs()
{
fuu(i,0,n+k+1) cur[i]=head[i],dep[i]=0;
q.push(s);
while(!q.empty())
{
int tp=q.front(); q.pop();
for(int i=head[tp];i;i=e[i].nxt)
{
int go=e[i].to;
if(!dep[go]&&e[i].cap>e[i].flow)
{
dep[go]=dep[tp]+1;
q.push(go);
}
}
}
return dep[t];
}
inline int dfs(int x,int change)
{
if(!change||x==t) return change;
int flow=0,ls=0;
for(int i=head[x];i;i=e[i].nxt)
{
int go=e[i].to;
if(dep[go]==dep[x]+1&&(ls=dfs(go,std::min(change,e[i].cap-e[i].flow))))
{
flow+=ls;
change-=ls;
e[i].flow+=ls;
e[i^1].flow-=ls;
if(!change) break;
}
}
return flow;
}
inline void maxflow()
{
while(bfs()) dfs(s,inf);
}
int main()
{
in(n),in(k);
s=0,t=n+k+1;
int x,y;
fuu(i,1,n) in(x),add(i+k,t,x),add(t,k+i,0);
fuu(i,1,k)
{
in(x);
fuu(j,1,x) in(y),add(i,k+y,1),add(k+y,i,0);
add(s,i,1),add(i,s,0);
}
maxflow();
fuu(i,1,n)
{
printf("%d:",i);
for(int j=head[i+k];j;j=e[j].nxt)
{
int go=e[j].to;
if(go>=1&&go<=k&&e[j].flow==-1) printf(" %d",go);
}
Enter;
}
return ~~(0^_^0);
}