学步园

以poj1273为例，代码参考白书训练指南，略有修改

Dinic主要思想就是将残留网络中的点分层，然后dfs搜索可行流，搜没了之后再分层，再搜可行流，直到分层时已经达不到t为止。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<map>
#include<vector>
#include<queue>
#include<cmath>
#define maxn 1<<29
using namespace std;
struct edge
{
    int from,to,cap,flow;
};
vector<int>g[222];
vector<edge>edges;
int m,n;
bool vis[222];
int d[222];
int cur[222];
void init()
{
    edges.clear();
    for(int i=1;i<=m;i++)g[i].clear();
}
void add(int u,int v,int c)
{
    edges.push_back((edge){u,v,c,0});
    g[u].push_back(edges.size()-1);
    edges.push_back((edge){v,u,0,0});
    g[v].push_back(edges.size()-1);
}
bool bfs(int s,int t)
{
    memset(vis,0,sizeof(vis));
    queue<int>q;
    q.push(s);
    d[s]=0;
    vis[s]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        int size=g[u].size();
        for(int i=0;i<size;i++)
        {
            edge &e=edges[g[u][i]];
            if(!vis[e.to]&&e.cap>e.flow)
            {
                vis[e.to]=1;
                d[e.to]=d[u]+1;
                q.push(e.to);
            }
        }
    }
    return vis[t];
}
int dfs(int u,int t,int mi)
{
    if(u==t||mi==0)return mi;
    int flow=0,f;
    int size=g[u].size();
    for(int &i=cur[u];i<size;i++)
    {
        edge &e=edges[g[u][i]];
        if(d[u]+1==d[e.to]&&(f=dfs(e.to,t,min(mi,e.cap-e.flow)))>0)
        {
            e.flow+=f;
            edges[g[u][i]^1].flow-=f;
            flow+=f;
            mi-=f;
            if(mi==0)break;
        }
    }
    return flow;
}
int dinic(int s,int t)
{
    int flow=0;
    while(bfs(s,t))
    {
        memset(cur,0,sizeof(cur));
        flow+=dfs(s,t,maxn);
    }
    return flow;
}
int main()
{
    int u,v,c;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init();
        for(int i=0;i<n;i++)
        {
            scanf("%d%d%d",&u,&v,&c);
            add(u,v,c);
        }
        printf("%d\n",dinic(1,m));
    }
    return 0;
}