P2763 试题库问题

\(\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}{输入样例}\)

\(\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('\n')
#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);
}

秒客网