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 = ;
 const int INF = 0x3f3f3f3f;
 int m,n,tot;
 int head[N],level[N];
 struct node
 {
     int t,next,w;
 }edge[N<<];

 void init()
 {
     tot=-;
     memset(head,-, 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=,edge[tot].next=head[t],head[t]=tot;
 }

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

 int dfs(int s,int t, int flow)
 {
     if(s==t)return flow;
     for(int i=head[s];i!=-;i=edge[i].next)
     {
         if(edge[i].w>&&level[edge[i].t]==level[s]+)
         {
             int k = dfs(edge[i].t,t,min(flow,edge[i].w));
             if(k>)
             {
                 edge[i].w-=k;
                 edge[i^].w+=k;
                 return k;
             }
         }
     }
     return ;
 }
 //
 void dinic()
 {
     int flow=;
     while(bfs()) // 寻找最短增广路，分层图
     {
         int f=;
         while((f=dfs(,m,INF))>)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 ;
 }

建图的另一种方法，上面有两种邻接表的方法，一种是单纯用数组模拟，可以运用异或操作反向边；另一个是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,,g[from].size()-});
 }

Ford_Fulkerson