洛谷 P1231 教辅的组成

题目背景

滚粗了的HansBug在收拾旧语文书，然而他发现了什么奇妙的东西。

题目描述

蒟蒻HansBug在一本语文书里面发现了一本答案，然而他却明明记得这书应该还包含一份练习题。然而出现在他眼前的书多得数不胜数，其中有书，有答案，有练习册。已知一个完整的书册均应该包含且仅包含一本书、一本练习册和一份答案，然而现在全都乱做了一团。许多书上面的字迹都已经模糊了，然而HansBug还是可以大致判断这是一本书还是练习册或答案，并且能够大致知道一本书和答案以及一本书和练习册的对应关系（即仅仅知道某书和某答案、某书和某练习册有可能相对应，除此以外的均不可能对应）。既然如此，HansBug想知道在这样的情况下，最多可能同时组合成多少个完整的书册。

输入输出格式

输入格式：

 

第一行包含三个正整数N1、N2、N3，分别表示书的个数、练习册的个数和答案的个数。

第二行包含一个正整数M1，表示书和练习册可能的对应关系个数。

接下来M1行每行包含两个正整数x、y，表示第x本书和第y本练习册可能对应。（1<=x<=N1，1<=y<=N2）

第M1+3行包含一个正整数M2，表述书和答案可能的对应关系个数。

接下来M2行每行包含两个正整数x、y，表示第x本书和第y本答案可能对应。（1<=x<=N1，1<=y<=N3）

 

输出格式：

 

输出包含一个正整数，表示最多可能组成完整书册的数目。

 

输入输出样例

输入样例#1：

5 3 4
5
4 3
2 2
5 2
5 1
5 3
5
1 3
3 1
2 2
3 3
4 3

输出样例#1：

2

说明

样例说明：

如题，N1=5，N2=3，N3=4，表示书有5本、练习册有3本、答案有4本。

M1=5，表示书和练习册共有5个可能的对应关系，分别为：书4和练习册3、书2和练习册2、书5和练习册2、书5和练习册1以及书5和练习册3。

M2=5，表示数和答案共有5个可能的对应关系，分别为：书1和答案3、书3和答案1、书2和答案2、书3和答案3以及书4和答案3。

所以，以上情况的话最多可以同时配成两个书册，分别为：书2+练习册2+答案2、书4+练习册3+答案3。

数据规模：

对于数据点1, 2, 3，M1，M2<= 20

对于数据点4~10，M1，M2 <= 20000

 

最大流

屠龙宝刀点击就送

#include <ctype.h>
#include <cstring>
#include <cstdio>
#include <queue>
#define M 200000
#define INF 0x7fffffff

using namespace std;
void read(int &x)
{
    x=0;bool f=0;
    register char ch=getchar();
    for(;!isdigit(ch);ch=getchar()) if(ch=='-') f=1;
    for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';
    x=f?(~x)+1:x;
}
int n1,n2,n3,m1,m2;
class TypeNetwork
{
    private:
        int head[M],dep[M],cnt;
        struct Edge
        {
            int next,to,flow;
            Edge (int next=0,int to=0,int flow=0) : next(next),to(to),flow(flow) {}
        }edge[M<<1];
    public:
        void ins(int u,int v,int w)
        {
            if(cnt==0) cnt=1;
            edge[++cnt]=Edge(head[u],v,w);
            head[u]=cnt;
        }
        bool bfs(int s,int t)
        {
            memset(dep,-1,sizeof(dep));
            dep[s]=0;
            queue<int>Q;
            Q.push(s);
            while(!Q.empty())
            {
                int now=Q.front();Q.pop();
                for(int i=head[now];i;i=edge[i].next)
                {
                    int v=edge[i].to;
                    if(dep[v]==-1&&edge[i].flow)
                    {
                        dep[v]=dep[now]+1;
                        Q.push(v);
                    }
                }
            }
            return dep[t]!=-1;
        }
        int min(int a,int b) {return a>b?b:a;}
        int dfs(int now,int t,int limit)
        {
            int ret=0,f;
            if(now==t||limit==0) return limit;
            for(int i=head[now];i;i=edge[i].next)
            {
                int v=edge[i].to;
                if(dep[v]==dep[now]+1&&edge[i].flow&&(f=dfs(v,t,min(limit,edge[i].flow))))
                {
                    edge[i].flow-=f;
                    edge[i^1].flow+=f;
                    ret+=f;
                    limit-=f;
                    if(limit==0) break;
                }
            }
            if(ret!=limit) dep[now]=-1;
            return ret;
        }
        int dinic(int s,int t)
        {
            int ans=0;
            for(;bfs(s,t);ans+=dfs(s,t,INF));
            return ans;
        }
};
class TypeNetwork syl;
int main()
{
    read(n1);
    read(n2);
    read(n3);
    read(m1);
    for(int x,y;m1--;)
    {
        read(x);read(y);
        syl.ins(y,x+n2,1);
        syl.ins(x+n2,y,0);
    }
    read(m2);
    for(int x,y;m2--;)
    {
        read(x);read(y);
        syl.ins(x+n2+n1,y+n1+n1+n2,1);
        syl.ins(y+n1+n1+n2,x+n2+n1,0);  
    }
    for(int i=1;i<=n1;i++)
    {
        syl.ins(n2+i,n2+n1+i,1);
        syl.ins(n2+n1+i,n2+i,0);  
    }
    int s=0,t=n1+n1+n2+n3+1;
    for(int i=1;i<=n2;i++)
    {
        syl.ins(s,i,1);
        syl.ins(i,s,0);
    }
    for(int i=1;i<=n3;i++)
    {
        syl.ins(n1+n1+n2+i,t,1);
        syl.ins(t,n1+n1+n2+i,0); 
    }
    printf("%d\n",syl.dinic(s,t));
    return 0;
}