题目背景
滚粗了的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

显而易见的最大流，我们要限制这三种物品的使用，所以我们采用把书放练习册和答案的中间，然后拆点使得每本书只会被用一次，然后源点S到练习册的流量为1，使得练习册只会被用一次，答案到汇点T的流量为1，使得答案只会被用一次，然后跑一次最大流就可以了，比较裸的题了。

AC代码：

#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=2e5+10;
int n1,n2,n3,s,t,m1,m2,h[N];
int head[N],nex[N<<4],to[N<<4],w[N<<4],tot=1;
inline void ade(int a,int b,int c){
	to[++tot]=b; w[tot]=c; nex[tot]=head[a]; head[a]=tot;
}
inline void add(int a,int b,int c){
	ade(a,b,c);	ade(b,a,0);
}
int bfs(){
	memset(h,0,sizeof h);	queue<int>q;	q.push(s);	h[s]=1;
	while(q.size()){
		int u=q.front();	q.pop();
		for(int i=head[u];i;i=nex[i]){
			if(w[i]&&!h[to[i]]){
				h[to[i]]=h[u]+1;	q.push(to[i]);
			}
		}
	}
	return h[t];
}
int dfs(int x,int f){
	if(x==t)	return f;
	int fl=0;
	for(int i=head[x];i&&f;i=nex[i]){
		if(w[i]&&h[to[i]]==h[x]+1){
			int mi=dfs(to[i],min(w[i],f));
			w[i]-=mi;	w[i^1]+=mi;	fl+=mi;	f-=mi;
		}
	}
	if(!fl)	h[x]=-1;
	return fl;
}
int dinic(){
	int res=0;
	while(bfs())	res+=dfs(s,0x3f3f3f3f);
	return res;
}
signed main(){
	cin>>n1>>n2>>n3>>m1; s=0; t=n1*2+n2+n3+2;
	while(m1--){
		int a,b;	cin>>a>>b;	add(b,a+n2,1);
	}
	cin>>m2;
	while(m2--){
		int a,b;	cin>>a>>b;	add(n2+n1+a,b+n2+n1*2,1);
	}
	for(int i=1;i<=n1;i++)	add(n2+i,n2+n1+i,1);
	for(int i=1;i<=n2;i++)	add(s,i,1);
	for(int i=1;i<=n3;i++)	add(n2+2*n1+i,t,1);
	cout<<dinic()<<endl;
	return 0;
}