「网络流 24 题」试题库

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

第 1 1 1 行有 2 2 2 个正整数 k k k 和 n n n。k k k 表示题库中试题类型总数，n n n 表示题库中试题总数。第 2 2 2 行有 k k k 个正整数，第 i i i 个正整数表示要选出的类型 i i i 的题数。这 k k k 个数相加就是要选出的总题数 m m m。

接下来的 n n n 行给出了题库中每个试题的类型信息。每行的第 1 1 1 个正整数 p p p 表明该题可以属于 p p p 类，接着的 p p p 个数是该题所属的类型号。
输出格式

第 i i i 行输出 i: 后接类型 i i i 的题号。如果有多个满足要求的方案，只要输出一个方案。如果问题无解，则输出 No Solution!。
样例
样例输入

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 6 8
2: 7 9 10

3: 2 3 4 5

分析：一个可以匹配多个，二分图的最大匹配，可以用最大流求出。

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
const int inf = 1e9;
const int maxn = 4000;
typedef long long ll;

struct Edge
{
    int fr,to,cap,flow;
};

struct Dinic
{
    int n,m,s,t;
    vector<Edge>edges;
    vector<int>G[maxn+5];
    bool vis[maxn+5];
    int d[maxn+5],cur[maxn+5];

    void Init(int n)
    {
        this->n = n;
        for(int i=0; i<=n; i++) G[i].clear();
        edges.clear();
    }

    void Addedge(int fr,int to,int cap)
    {
        edges.push_back((Edge)
        {
            fr,to,cap,0
        });
        edges.push_back((Edge)
        {
            to,fr,0,0
        });
        m = edges.size();
        G[fr].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool BFS()
    {
        memset(vis,0,sizeof(vis));
        queue<int>Q;
        Q.push(s);
        d[s] = 0, vis[s] = 1;
        while(!Q.empty())
        {
            int x = Q.front();
            Q.pop();
            for(int i=0,l=G[x].size(); i<l; i++)
            {
                Edge &e = edges[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow)
                {
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int DFS(int x,int a)
    {
        if(x==t||a==0) return a;
        int flow = 0,f;
        for(int &i=cur[x],l=G[x].size(); i<l ; i++)
        {
            Edge &e = edges[G[x][i]];
            if(d[x]+1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0)
            {
                e.flow+=f;
                edges[G[x][i]^1].flow -=f;
                flow+=f;
                a-=f;
                if(a==0) break;
            }
        }
        return flow;
    }

    int Maxflow(int s,int t)
    {
        this->s = s, this->t = t;
        int flow = 0;
        while(BFS())
        {
            memset(cur,0,sizeof(cur));
            flow+=DFS(s,inf);
        }
        return flow;
    }

}my;
int n,m,s,t;
int main()
{
    while(~scanf("%d %d",&n,&m))
    {
        int cot = 0;
        s = 0, t = n+m+1;
        my.Init(n+m+1);
        for(int i=1,x;i<=n;i++)
        {
            scanf("%d",&x);
            my.Addedge(i+m,t,x);
            cot+=x;
        }
        for(int i=1,k,x;i<=m;i++)
        {
            scanf("%d",&k);
            while(k--)
            {
                scanf("%d",&x);
                my.Addedge(i,x+m,1);
            }
            my.Addedge(s,i,1);
        }
        int flow = my.Maxflow(s,t);
        if(flow!=cot){
            printf("No Solution!\n");
            continue;
        }
        for(int i=1;i<=n;i++)
        {
            printf("%d:",i);
            for(int j=0,l=my.G[i+m].size();j<l;j++)
            {
                Edge e = my.edges[my.G[i+m][j]];
                if(e.flow==-1&&e.cap==0) printf(" %d",e.to);
            }
            printf("\n");
        }
    }
    return 0;
}