洛谷 P2763 试题库问题 最大流

题目描述

«问题描述：

假设一个试题库中有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

分析：
首先一道题可以是多种类型的(比如说题目1可以是类型1和类型2)，但是最后只属于一个类型(类型1)。
首先源点S向每道题目连一条流量为1的边，然后每道题向所属的类型连一条流量为1的边，每种类型向汇点T连一条流量为这种类型题目需要的个数为流量的边。然后跑最大流，如果最大流等于需要题目的数量，则有解，然后判断每道题向哪个类型的边被流过，即可判断所属类型。

代码：

#include <iostream>
#include <cstdio>
#include <queue>
#include <cmath>

const int maxn=1105;
const int maxe=60007;
const int inf=0x3f3f3f3f;

using namespace std;

struct edge{
    int y,next,c,op;
}g[maxe];

int x,y,cnt,n,m,k,i,s,t,ans,j;
int ls[maxn],dis[maxn];
int f[25][maxn];

queue <int> q;

void add(int x,int y,int w)
{
    g[++cnt].y=y; g[cnt].c=w; g[cnt].op=cnt+1; g[cnt].next=ls[x]; ls[x]=cnt;
    g[++cnt].y=x; g[cnt].c=0; g[cnt].op=cnt-1; g[cnt].next=ls[y]; ls[y]=cnt;
}

bool bfs()
{
    for (int i=s;i<=t;i++) dis[i]=0;
    dis[s]=1;
    while (!q.empty()) q.pop();
    q.push(s);
    while (!q.empty())
    {
        int u=q.front();
        q.pop();
        for (int i=ls[u];i>0;i=g[i].next)
        {
            int v=g[i].y;
            if ((dis[v]==0) && (g[i].c))
            {
                dis[v]=dis[u]+1;
                if (v==t) return true;
                q.push(v);
            }
        }
    }
    return false;
}

int dfs(int x,int maxf)
{
    if ((x==t) || (maxf==0)) return maxf;
    int ret=0;
    for (int i=ls[x];i>0;i=g[i].next)
    {
        int y=g[i].y;
        if ((g[i].c) && (dis[x]+1==dis[y]))
        {
            int flow=dfs(y,min(g[i].c,maxf-ret));
            g[i].c-=flow;
            g[g[i].op].c+=flow;
            ret+=flow;
        }
    }
    return ret;
}

void dinic()
{
    while (bfs()) 
      ans-=dfs(s,inf);
}

int main()
{
    scanf("%d%d",&k,&n);
    s=0;t=n+k+1;
    for (i=1;i<=k;i++)
    {
        scanf("%d",&x);
        ans+=x;
        add(i+n,t,x);
    }   
    for (i=1;i<=n;i++)
    {
        scanf("%d",&m);
        add(s,i,1);
        while (m--)
        {
            scanf("%d",&x);
            add(i,x+n,1);
        }
    }

    dinic();
    if (ans) printf("No Solution!");
    else
    {
        for (i=1;i<=n;i++)
        {
            for (j=ls[i];j>0;j=g[j].next)
            {
                if ((g[j].y!=s) && (g[j].c==0))
                {
                    f[g[j].y-n][i]=1;
                }
            }
        }
        for (i=1;i<=k;i++)
        {
            printf("%d:",i);
            for (j=1;j<=n;j++)
            {
                if (f[i][j]) printf(" %d",j);
            }
            printf("\n");
        }
    }
}