POJ 1273 Drainage Ditches【最大流模版】

题意：现在有m个池塘(从1到m开始编号,1为源点,m为汇点),及n条有向水渠,给出这n条水渠所连接的点和所能流过的最大流量，求从源点到汇点能流过的最大流量

Dinic

#include<iostream>
#include<cstring>
#include<algorithm>
#include <cstdio>
#include <queue>
using namespace std;
const int N = 202;
const int INF = 0x3f3f3f3f;
int m,n,tot;
int head[N],level[N];
struct node
{
    int t,next,w;
}edge[N<<2];


void init()
{
    tot=-1;
    memset(head,-1, sizeof(head));
}

void add(int s,int t,int w)
{
    edge[++tot].t=t,edge[tot].w=w,edge[tot].next=head[s],head[s]=tot;
    edge[++tot].t=s,edge[tot].w=0,edge[tot].next=head[t],head[t]=tot;
}

bool bfs()
{
    memset(level,0,sizeof(level));
    queue<int> q;
    while(!q.empty())q.pop();
    q.push(1);
    level[1]=1;
    while(q.size())
    {
        int u=q.front();q.pop();
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            if(edge[i].w>0&&level[edge[i].t]==0)
            {
                q.push(edge[i].t);
                level[edge[i].t]=level[u]+1;
            }
            if(level[m]!=0)return 1;
        }
    }
    return 0;
}

int dfs(int s,int t, int flow)
{
    if(s==t)return flow;
    for(int i=head[s];i!=-1;i=edge[i].next)
    {
        if(edge[i].w>0&&level[edge[i].t]==level[s]+1)
        {
            int k = dfs(edge[i].t,t,min(flow,edge[i].w));
            if(k>0)
            {
                edge[i].w-=k;
                edge[i^1].w+=k;
                return k;
            }
        }
    }
    return 0;
}
//
void dinic()
{
    int flow=0;
    while(bfs()) // 寻找最短增广路，分层图
    {
        int f=0;
        while((f=dfs(1,m,INF))>0)flow+=f; // 在分层图上增广
    }
    cout<<flow<<endl;
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        init();
        while(n--)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            add(a,b,c);
        }
        dinic();
    }
    return 0;
}

建图的另一种方法，上面有两种邻接表的方法，一种是单纯用数组模拟，可以运用异或操作反向边；另一个是vector模拟，反向边做特别记录

struct edge
{
    int to,cap,rev;// 反向边
};
vector<edge> g[maxn];
int level[maxn];

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});
}

Ford_Fulkerson