洛谷2763 试题库问题

题目链接：试题库问题

在写过几道网络流的题目之后，这一道题目就显得比较常规了

建立一个超级源点(s)和超级汇点(t)。我们从题目的性质入手

题目是会影响一种或多种类型，但是只会产生1的贡献，因此由题目向它对应的类型连一条容量为1的边

为了满足对各种类型的需求，我们由每种类型向最终汇点连一条容量为当前对该种类型的试题的需求的容量的边

最后就是由源点向每个题目连一条容量为1的边

然后直接跑网络流，只有在容量为(m)时才会是有解（由上面建图知流最大也为(m)），小于(m)时说明需求向汇点连的边中有一部分未被满足，明显此时无解

输出方案的话直接找残量网络中的0流边即可（其实在残量网络中这些边已经不存在了）

#include<iostream>
#include<string>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<math.h>
#include<vector>
#include<queue>
#include<map>
using namespace std;
#define maxd 1e9+7

int n,k,m=0,s,t,need[1010];
struct network_flows{
    struct node{
        int from,to,nxt,flow;
    }sq[100100];
    int all,dep[100100],head[100100],cur[100100],n,m,s,t;
    bool vis[100100];

   void init(int n,int k)
    {
        this->s=n+k+1;this->t=n+k+2;
        this->n=n+k+2;this->all=1;
        memset(head,0,sizeof(head));
    }

    void add(int u,int v,int w)
    {
        all++;sq[all].from=u;sq[all].to=v;sq[all].nxt=head[u];sq[all].flow=w;head[u]=all;
        all++;sq[all].from=v;sq[all].to=u;sq[all].nxt=head[v];sq[all].flow=0;head[v]=all;
    }

    bool bfs()
    {
        queue<int> q;int i;
        memset(vis,0,sizeof(vis));
        vis[s]=1;q.push(s);dep[s]=0;
        while (!q.empty())
        {
            int u=q.front();q.pop();
            for (i=head[u];i;i=sq[i].nxt)
            {
                int v=sq[i].to;
                if ((!vis[v]) && (sq[i].flow))
                {
                    vis[v]=1;dep[v]=dep[u]+1;q.push(v);
                }
            }
        }
        if (!vis[t]) return 0;
        for (i=1;i<=n;i++) cur[i]=head[i];
        return 1;
    }

    int dfs(int now,int to,int lim)
    {
        if ((!lim) || (now==to)) return lim;
        int i,sum=0;
        for (i=head[now];i;i=sq[i].nxt)
        {
            int v=sq[i].to;
            if (dep[now]+1==dep[v])
            {
                int f=dfs(v,to,min(lim,sq[i].flow));
                if (f)
                {
                    lim-=f;sum+=f;
                    sq[i].flow-=f;
                    sq[i^1].flow+=f;
                    if (!lim) break;
                }
            }
        }
        return sum;
    }

    int work()
    {
        int ans=0;
        while (bfs()) ans+=dfs(s,t,maxd);
        return ans;
    }

    void out(int n)
    {
       vector<int> ans[30];
       int i,j;
       for (i=1;i<=n;i++)
       {
           for (j=head[i];j;j=sq[j].nxt)
           {
               if ((!sq[j].flow) && (sq[j].to!=s)) {ans[sq[j].to-n].push_back(i);}
           }
           //cout << endl;
       }
       for (i=1;i<=k;i++)
       {
           printf("%d: ",i);
           int len=ans[i].size();
           for (j=0;j<len;j++) printf("%d ",ans[i][j]);
           printf("
");
       }
    }
}dinic;

int read()
{
    int x=0,f=1;char ch=getchar();
    while ((ch<'0') || (ch>'9')) {if (ch=='-') f=-1;ch=getchar();}
    while ((ch>='0') && (ch<='9')) {x=x*10+(ch-'0');ch=getchar();}
    return x*f;
}

void init()
{
    k=read();n=read();int i,j;s=n+k+1;t=n+k+2;
    for (i=1;i<=k;i++) {need[i]=read();m+=need[i];}
    dinic.init(n,k);
    for (i=1;i<=n;i++) dinic.add(s,i,1);
    for (i=1;i<=k;i++) dinic.add(n+i,t,need[i]);
    for (i=1;i<=n;i++)
    {
        int kind=read();
        for (j=1;j<=kind;j++)
        {
            int p=read();
            dinic.add(i,n+p,1);
        }
    }
}

void work()
{
    int ans=dinic.work();
    if (ans<m) {printf("No Solution!");return;}
    dinic.out(n);
}

int main()
{
    init();
    work();
    return 0;
}