luogu P2763 试题库问题(最大流)

luogu P2763 试题库问题(最大流)

题目大意

«问题描述：

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

«编程任务：

对于给定的组卷要求，计算满足要求的组卷方案。

解题思路

建一个源点，向所有的试题连边，容量为1，试题向其所属的类连边，容量1，所有的类向汇点连接容量为其需求量的边，最后跑一下最大流，若最大流量等于m则有解，遍历所有试题并将其加入所属的类的数组中，再针对试题类输出即可.反之则没有答案

AC代码

// luogu-judger-enable-o2
#include<bits/stdc++.h>
using namespace std;
const int maxn=2005;
const int maxm=4e6+5;
const int inf=0x3f3f3f3f;
struct Edge{
    int to,nxt,cap,flow;
}edge[maxm];
int tol;
int head[maxn];
void init(){
    tol=2;
    memset(head,-1,sizeof(head));
}
void AddEdge(int u,int v,int w,int rw=0){
    edge[tol].to=v;edge[tol].cap=w;edge[tol].flow=0;
    edge[tol].nxt=head[u];head[u]=tol++;
    edge[tol].to=u;edge[tol].cap=rw;edge[tol].flow=0;
    edge[tol].nxt=head[v];head[v]=tol++;
}
int Q[maxn];
int dep[maxn],cur[maxn],sta[maxn];
bool bfs(int s,int t,int n){
    int front=0,tail=0;
    memset(dep,-1,sizeof(dep[0])*(n+1));
    dep[s]=0;
    Q[tail++]=s;
    while(front<tail){
        int u=Q[front++];
        for(int i=head[u];i!=-1;i=edge[i].nxt){
            int v=edge[i].to;
            if(edge[i].cap>edge[i].flow&&dep[v]==-1){
                dep[v]=dep[u]+1;
                if(v==t) return true;
                Q[tail++]=v;
            }
        }
    }
    return false;
}
int dinic(int s,int t,int n){
    int maxflow=0;
    while(bfs(s,t,n)){
        for(int i=0;i<n;i++) cur[i]=head[i];
        int u=s,tail=0;
        while(cur[s]!=-1){
            if(u==t){
                int tp=inf;
                for(int i=tail-1;i>=0;i--)
                {
                    tp=min(tp,edge[sta[i]].cap-edge[sta[i]].flow);
                }
                maxflow+=tp;
                for(int i=tail-1;i>=0;i--){
                    edge[sta[i]].flow+=tp;
                    edge[sta[i]^1].flow-=tp;
                    if(edge[sta[i]].cap-edge[sta[i]].flow==0) tail=i;
                }
                u=edge[sta[tail]^1].to;
            }
            else if(cur[u]!=-1&&edge[cur[u]].cap>edge[cur[u]].flow&&dep[u]+1==dep[edge[cur[u]].to]){
                sta[tail++]=cur[u];
                u=edge[cur[u]].to;
            }
            else{
                while(u!=s&&cur[u]==-1) u=edge[sta[--tail]^1].to;
                cur[u] = edge [cur[u]].nxt;
            }
        }
    }
    return maxflow;
}
int cnt[25];
vector<int> ans[25];
int main()
{
    int k,n;
    init();
    scanf("%d%d",&k,&n);
    int s=0,t=k+n+2;
    int m=0;
    for(int i=1;i<=k;i++) scanf("%d",&cnt[i]),m+=cnt[i],AddEdge(n+i,t,cnt[i]);
    int tot=0;
    int ty;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&tot);
        while(tot--)
        {
            scanf("%d",&ty);
            AddEdge(i,n+ty,1);
        }
        AddEdge(s,i,1);
    }
    int tolflow=dinic(s,t,k+n+5);
    if(tolflow==m) 
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=head[i];j!=-1;j=edge[j].nxt)
            {
                if(edge[j].flow==1)
                {
                    ans[edge[j].to-n].push_back(i);
                }
            }
        }
        for(int i=1;i<=k;i++)
        {
            printf("%d: ",i);
            for(auto x:ans[i]) printf("%d ",x);
            puts("");
        }
        
    }
    else printf("No Solution!\n");
}