poj 1273Drainage Ditches(简单网络流（用dinic）)

//poj 1273Drainage Ditches(简单网络流（用dinic）)
#include<iostream>
#include<cstdio>
#include<vector>
#include<string.h>
#include<queue>
using namespace std;
const int N=500;
const int INF=1<<30;
int Min(int a,int b){return a<b?a:b;}
//==============邻接表==================
struct Edge
{
    int from,to,cap,flow;
};
struct Dinic
{
    int start,end,n,m;
    vector<Edge> edges;
    vector<int> G[N];//邻接表
    void AddEdge(int from,int to,int cap)
   {
       Edge e;
       e.from=from;e.cap=cap;e.to=to;e.flow=0;
       edges.push_back(e);
       e.from=to;e.cap=0;e.to=from;e.flow=0;
       edges.push_back(e);
       int m1=edges.size();
       G[from].push_back(m1-2);
       G[to].push_back(m1-1);
   }
//===============================
   int vis[N];
   int d[N];
   int cur[N];
//=========分层次==================
   bool BFS()
   {
       memset(vis,0,sizeof(vis));
       queue<int> q;
       q.push(start);
       d[start]=0;
       vis[start]=1;
        while(!q.empty())
        {
            int x=q.front();q.pop();
            for(int i=0;i<G[x].size();i++)
            {
                Edge &e=edges[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow)
                {
                    vis[e.to]=1;
                    d[e.to]=d[x]+1;
                    q.push(e.to);
                }
            }
        }
        return vis[end];
    }
//===============================
    int DFS(int x,int a)
    {
        if(x==end||a==0) return a;
        int flow=0,f;
        for(int i=0;i<G[x].size();i++)
        {
            Edge& e=edges[G[x][i]];
            if(d[x]+1==d[e.to]&&(f=DFS(e.to,Min(a,e.cap-e.flow)))>0)
            {
                e.flow+=f;
                edges[G[x][i]^1].flow-=f;
                flow+=f;
                a-=f;
                if(a==0) break;
            }
        }
        return flow;
    }
    int Maxflow(int s,int t)
    {
        start=s;end=t;
        int flow=0;
        while(BFS())
        {
            memset(cur,0,sizeof(cur));
            flow+=DFS(s,INF);
        }
        return flow;
    }
};
int main()
{
    Dinic flo,te;
    while(scanf("%d%d",&flo.m,&flo.n)!=EOF)
    {
        int a,b,c;
        for(int i=0;i<flo.m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            flo.AddEdge(a,b,c);
        }
        printf("%d\n",flo.Maxflow(1,flo.n));
        flo=te;
        //cout<<INF<<endl;
    }
    return 0;
}