网络流ISAP模板

ISAP算法模板（hdu 4289）

//HDU4289 ISAP模板
//复杂度O(E*V^2)
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<map>
#include<string>
#include<queue>
#include<vector>
#include<list>
//#pragma comment(linker,"/STACK:1024000000,1024000000")
using namespace std;
#define INF 0x3f3f3f3f
#define MAX_V 405
struct edge{int to,cap,rev;};
vector<edge> G[MAX_V];
int V;
int prevv[MAX_V],preve[MAX_V];
int iter[MAX_V],num[MAX_V],level[MAX_V];//当前弧、每一层点数、层数
void add_edge(int from,int to,int cap)
{
    G[from].push_back((edge){to,cap,G[to].size()});
    G[to].push_back((edge){from,0,G[from].size()-1});
}
//构造分层图
void bfs(int s,int t)
{
    memset(level,-1,sizeof level);
    memset(num,0,sizeof num);
    queue<int> que;
    que.push(t);
    level[t]=0;
    num[0]=1;
    while(!que.empty())
    {
        int u=que.front();que.pop();
        for(int i=0;i<G[u].size();i++)
        {
            edge e=G[u][i];
            edge rev=G[e.to][e.rev];
            if(rev.cap>0&&level[e.to]<0)
            {
                level[e.to]=level[u]+1;
                num[level[e.to]]++;
                que.push(u);
            }
        }
    }
}
//增广路
int augment(int s,int t)
{
    int f=INF;
    for(int v=t;v!=s;v=prevv[v])
    {
        edge e=G[prevv[v]][preve[v]];
        f=min(f,e.cap);
    }
    for(int v=t;v!=s;v=prevv[v])
    {
        edge &e=G[prevv[v]][preve[v]];
        e.cap-=f;
        G[e.to][e.rev].cap+=f;
    }
    return f;
}
int max_flow(int s,int t)
{
    int flow=0;
    int u=s;
    memset(iter,0,sizeof iter);
    bfs(s,t);
    while(level[u]<V)
    {
//        cout<<u<<endl;
        if(u==t)
        {
            int d=augment(s,t);
            flow+=d;
            //cout<<d<<endl;
            u=s;
        }
        int rebuild=0;
        for(int &i=iter[u];i<G[u].size();i++)//从当前弧开始遍历
        {
            edge e=G[u][i];
            if(e.cap>0&&level[u]==level[e.to]+1)
            {
                prevv[e.to]=u;
                preve[e.to]=i;
                u=e.to;
                rebuild=1;
                break;
            }
        }
        if(!rebuild)
        {
            int d=V-1;
            for(int i=0;i<G[u].size();i++)
            {
                edge e=G[u][i];
                if(e.cap>0) d=min(d,level[e.to]);
            }
            iter[u]=0;
            num[level[u]]--;
            if(num[level[u]]==0) break;//GAP优化
            level[u]=d+1;
            num[level[u]]++;
            if(u!=s) u=prevv[u];
        }
    }
    return flow;
}
int n,m;
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0;i<MAX_V;i++) G[i].clear();
        int s,t;
        V=2*n;
        scanf("%d%d",&s,&t);
        for(int i=1;i<=n;i++)
        {
            int cc;
            scanf("%d",&cc);
            add_edge(2*i-1,2*i,cc);
            add_edge(2*i,2*i-1,cc);
        }
        for(int i=1;i<=m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(2*u,2*v-1,INF);
            add_edge(2*v,2*u-1,INF);
        }
        printf("%d\n",max_flow(2*s-1,t*2));
    }
    return 0;
}