Power OJ 1742试题库问题

Description

假设一个试题库中有n道试题。每道试题都标明了所属类别。同一道题可能有多个类别
属性。现要从题库中抽取m 道题组成试卷。并要求试卷包含指定类型的试题。试设计一个
满足要求的组卷算法。
编程任务：
对于给定的组卷要求，计算满足要求的组卷方案。
Input

由文件input.txt提供输入数据。文件第1行有2个正整数k和n (2 <=k<= 20, k<=n<= 1000)
k 表示题库中试题类型总数，n 表示题库中试题总数。第2 行有k 个正整数，第i 个正整数
表示要选出的类型i 的题数。这k个数相加就是要选出的总题数m。接下来的n行给出了题
库中每个试题的类型信息。每行的第1 个正整数p表明该题可以属于p类，接着的p个数是
该题所属的类型号。
Output

程序运行结束时，将组卷方案输出到文件output.txt 中。文件第i 行输出 “i：”后接类
型i的题号。如果有多个满足要求的方案，只要输出1 个方案。如果问题无解，则输出“No Solution!”。
Sample Input
Raw
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
Sample Output
Raw
1: 1 6 8
2: 7 9 10
3: 2 3 4 5

网络流板题

#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;

const int maxn = 1200+5;
const int INF = 0x3f3f3f3f;
const int maxm = 20000+5;

int head[maxn],level[maxn],read[25],s,e,no;           
int K,N,M;
struct Edge{
    Edge(){};
    Edge(int sta,int end,int n,int f):u(sta),v(end),flow(f),next(n){};
    int u,v,flow,next;
}edge[maxm];

inline void add(int x,int y,int z){
    edge[no] = Edge(x,y,head[x],z);
    head[x] = no++;
    edge[no] = Edge(y,x,head[y],0);    
    head[y] = no++;
}

inline void Init(){
    memset(head,-1,sizeof(head));
    no = 0;
    scanf("%d %d",&K,&N);
    s = 0; e = N + K + 1;
    for(int i = 1;i <= K;++i){
        scanf("%d",&read[i]);
        M += read[i];
        add(s,i,read[i]);
    }
    for(int i = 1;i <= N;++i){
        int temp_num,temp_end;
        scanf("%d",&temp_num);
        while(temp_num--){
            scanf("%d",&temp_end);
            add(temp_end,K+i,1);
        }
        add(K+i,e,1);
    }
    return;
}

bool bfs(int s,int e){
    int tempx,tempy;
    memset(level,0,sizeof(level));
    queue <int> E;
    E.push(s);
    level[s] = 1;
    while(!E.empty()){
        tempx = E.front(); E.pop();
        if(tempx == e)
            return true;
        for(int i = head[tempx];i != -1;i = edge[i].next){
            if(edge[i].flow > 0 && !level[tempy = edge[i].v]){
                level[tempy] = level[tempx] + 1;
                E.push(tempy);
            }
        }
    }
    return false;
}

int dfs(int u,int maxf,int e){
    if(u == e)
        return maxf;
    int retf = 0;
    for(int i = head[u];i != -1;i = edge[i].next){
        int v = edge[i].v,f = edge[i].flow;
        if(level[u] + 1 == level[v] && f > 0){
            int Min = min(maxf - retf,f);
            f = dfs(v,Min,e);
            edge[i].flow -= f;
            edge[i^1].flow += f;
            retf += f;
            if(retf == maxf)
                return retf;
        }
    }
    return retf;
}

inline void Dinic(){
    int ans = 0;
    while(bfs(s,e))
        ans += dfs(s,INF,e);
    int tmp[maxn],total = 0;
    if(ans == M)
        for(int i = 1;i <= K;++i){
            memset(tmp,0,sizeof(tmp));
            total = 0;
            printf("%d:",i);
            for(int j = head[i];j != -1;j = edge[j].next){
                if(edge[j].flow == 0 && edge[j].v != s)
                    tmp[total++] = edge[j].v - K;
            }
            sort(tmp,tmp+total);
            for(int j = 0;j < total;++j)
                printf(" %d",tmp[j]);
            printf("\n");
        }
    else
        printf("No Solution!\n");
    return;
}

int main(){
    Init();
    Dinic();
    return 0;
}