最大流的Ford-Fulkerson方法方法

流网络：

流网络：给出有向图G=（V，E，C）c：非负的容量值；
s为网络的源点，t为汇点。最大流便是该流网络能通过的最大流量。

流网络在应用时的改造：

• 流网络中不存在双向边。但在应用场景中，有时会存在双向运输，此时需要改造流网络；
  通过改造成包含反平行边的图，引入一个虚拟的中转结点。
• 超级源点/超级汇点：有多个源点与汇点时用一个流量为∞的超级源点/超级汇点将其联合起来。

残存网络：如何增大原始流网络中的流的一种指示

在流网络的基础上：定义f为G中的一个流；

• 残存容量：cf(u,v)=c-f；
• 对(u,v)的增量：f '(u,v)=c-f与反向增量f '(v,u)=c（反向流其实不存在，只是用来减小f(u,v)的值）;

增广路径：增广路径p是残存网络中一条从源结点s到汇点t的简单路径

• 定义函数fp 是残存网络中的一个流，由f+fp得到p中的一个更大的流

流网络的切割：G=（V，E）切割：（S，T）T=~S

Ford- Fulkerson方法

数据结构

struct ad(){
int x,y,C,F;//表示从x到y的容量是C,流量是F。
}a[2*MAXE];//因为有反向边，所以边数*2
vector<int> G[MAXN];//建立边表，存的是[x,y]这条边在a中的ID
int que[MAXN];//队列
int upd[MAXN];//用于更新当前最小的残量，如果upd[x]=0，表示这个点没被遍历过。
int fa[MAXN];//存储路径，从fa[y]走向y，方便增加流量
void Add(int x,int y,int c,int i)初始化流网络。
bool BFS()遍历图得到每一条增广路径
Edmonds_Karp();//找最大流

#include<iostream>
#include<stdio.h>
#include<vector>
#include<queue>
#include<string.h>
#define MAXN 20010
#define MAXE 100000
#define MAXC 1e9
using namespace std;
int s,t,n,m;
struct ad{
 int x,y,C,F;//表示从x到y的容量是C,流量是F
 ad(){x=0,y=0,C=0,F=0;}
 ad(int a,int b,int c,int d){x=a,y=b,C=c,F=d;}
}a[2*MAXE];
vector<int> G[MAXN];//存的是x到某条边的i值，用来找边
int upd[MAXE];//用于更新当前最小的残量
int fa[MAXE];//前驱边的值
void Add(int x,int y,int c,int i);//建立图的边与边与点的关系
bool BFS();//寻找增广路径
int Edmonds_Karp();//找最大流
void creat_map();
queue<int> que;
void clear(queue<int> &q){
    queue<int> empty;
    swap(empty, q);
}
int E_temp;
int main(){
    while(~scanf("%d",&n)){
        s=0;t=2*n+1;
        creat_map();
        printf("%d\n",n-Edmonds_Karp());
        memset(a,0,E_temp);
        for(int i=0;i<=2*n+1;i++){
            G[i].clear();
        }
    }
}
void creat_map(){
    int x,y;
    E_temp=0;
    for(int i=1;i<=n;i++){
        Add(s,i,1,E_temp++);
        scanf("%d",&y);
        if(y)
            Add(i,n+y,1,E_temp++);
    }
    for(int i=n+1;i<=2*n;i++){
        Add(i,t,1,E_temp++);
        scanf("%d",&x);
        if(x)
            Add(x,i,1,E_temp++);
    }
}
void Add(int x,int y,int c,int i){
    a[i<<1]=ad(x,y,c,0),G[x].push_back(i<<1);
    a[(i<<1)+1]=ad(y,x,0,0),G[y].push_back((i<<1)+1);
}
bool BFS(){
    clear(que);
    memset(upd,0,sizeof(upd));
    upd[s]=MAXC;
    que.push(s);
    while(!que.empty()){
        int x=que.front();
        que.pop();
        int l=G[x].size();
        for(int i=0;i<l;i++){
            ad E=a[G[x][i]];
            if(!upd[E.y]&&E.C>E.F){
                que.push(E.y);
                upd[E.y]=min(upd[x],E.C-E.F);
                fa[E.y]=G[x][i];
            }
        }
        if(upd[t])
            return 1;
    }
    return 0;
}
int Edmonds_Karp(){
    int Flow=0;
    while(BFS()){
        for(int y=t;y!=s;y=a[fa[y]].x){
            a[fa[y]].F+=upd[t];
            a[fa[y]^1].F-=upd[t];
        }
        Flow+=upd[t];
    }
    return Flow;
}