最大流dinic模板

循环版,点的编号从0开始：

 const int MAXN = ;
 const int MAXM = ;
 const int INF = 0x3f3f3f3f;
 struct Edge
 {
     int to, next, cap, flow;
 }edge[MAXM];
 int tol;
 int head[MAXN];
 void init()
 {
     tol = ;
     memset(head, -, sizeof(head));
 }
 void addedge(int u, int v, int w, int rw=)
 {
     edge[tol].to = v; edge[tol].cap = w; edge[tol].flow = ;
     edge[tol].next = head[u]; head[u] = tol++;
     edge[tol].to = u; edge[tol].cap = rw; edge[tol].flow = ;    //存反向边
     edge[tol].next = head[v]; head[v] = tol++;
 }
 int Q[MAXN];
 int dep[MAXN], cur[MAXN], sta[MAXN];
 bool bfs(int s, int t, int n)
 {
     int front = , tail = ;
     memset(dep, -, sizeof(dep[])*(n+));
     dep[s] = ;
     Q[tail++] = s;
     while(front < tail)
     {
         int u = Q[front++];
         for(int i = head[u]; i != -; i = edge[i].next)
         {
             int v = edge[i].to;
             if(edge[i].cap > edge[i].flow && dep[v] == -)                 
　　　　　　　　　{
                 dep[v] = dep[u] + ;
                 if(v == t) return true;
                 Q[tail++] = v;
             }
         }
     }
     return false;
 }
 int dinic(int s, int t, int n) {          //s是源点编号，t是汇点编号，n是点的总数，返回最大流
     int maxflow = ;
     while(bfs(s, t, n)) {
         for(int i = ; i < n; i++) cur[i] = head[i];
         int u = s, tail = ;
         while(cur[s] != -)
         {
             if(u == t)
             {
                 int tp = INF;
                 for(int i = tail-; i >= ; i--)
                     tp = min(tp, edge[sta[i]].cap-edge[sta[i]].flow);
                 maxflow+=tp;
                 for(int i = tail-; i >= ; i--) {
                     edge[sta[i]].flow+=tp;
                     edge[sta[i]^].flow-=tp;
                     if(edge[sta[i]].cap-edge[sta[i]].flow==)
                         tail = i;
                 }
                 u = edge[sta[tail]^].to;
             }
             else
                 if(cur[u] != - && edge[cur[u]].cap > edge[cur[u]].flow && dep[u] +  == dep[edge[cur[u]].to])
                 {
                     sta[tail++] = cur[u];
                     u = edge[cur[u]].to;
                 }
                 else
                 {
                     while(u != s && cur[u] == -)
                         u = edge[sta[--tail]^].to;
                     cur[u] = edge[cur[u]].next;
                 }
         }
     }
     return maxflow;
 }

dfs增广路版，点的编号从0开始：

 const int MAXN = ;
 const int MAXM = ;
 const int INF = 0x3f3f3f3f;
 struct Edge
 {
     int to, next, cap, flow;
 }edge[MAXM];
 int tol;
 int head[MAXN];
 void init()
 {
     tol = ;
     memset(head, -, sizeof(head));
 }
 void addedge(int u, int v, int w, int rw=)
 {
     edge[tol].to = v; edge[tol].cap = w; edge[tol].flow = ;
     edge[tol].next = head[u]; head[u] = tol++;
     edge[tol].to = u; edge[tol].cap = rw; edge[tol].flow = ;      //存反向边
     edge[tol].next = head[v]; head[v] = tol++;
 }
 int Q[MAXN];
 int dep[MAXN], cur[MAXN], sta[MAXN];
 bool bfs(int s, int t, int n)
 {
     int front = , tail = ;
     memset(dep, -, sizeof(dep[])*(n+));
     dep[s] = ;
     Q[tail++] = s;
     while(front < tail)
     {
         int u = Q[front++];
         for(int i = head[u]; i != -; i = edge[i].next)
         {
             int v = edge[i].to;
             if(edge[i].cap > edge[i].flow && dep[v] == -)
                         {
                 dep[v] = dep[u] + ;
                 if(v == t) return true;
                 Q[tail++] = v;
             }
         }
     }
     return false;
 }

 int dfs(int u,int t,int f)                             //dfs寻找增广路
 {
     if(u==t) return f;
     for(int i=head[u];i!=-;i=edge[i].next)
     {
         int v=edge[i].to;
         if(edge[i].cap > edge[i].flow && dep[v]==dep[u]+)
         {
             int d=dfs(v,t,min(f,edge[i].cap-edge[i].flow));
             if(d>)
             {
                 edge[i].flow+=d;
                 edge[i^].flow-=d;
                 return d;
             }
         }
     }
     return ;
 }

 int dinic(int s, int t, int n) {      //s是源点编号，t是汇点编号，n是点的总数，返回最大流
     int maxflow =  , f;
     while(bfs(s, t, n))
     {
         while(f=dfs(s,t,INF))
             maxflow+=f;
     }
     return maxflow;
 }                

不建反向边（一般用不到），点的编号从0开始：

 const int MAXN = ;
 const int MAXM = ;
 const int INF = 0x3f3f3f3f;
 struct Edge
 {
     int from,to, next, cap, flow;
 }edge[MAXM];
 int tol;
 int head[MAXN];
 void init()
 {
     tol = ;
     memset(head, -, sizeof(head));
 }
 int min(int a,int b)
 {
 return a>b?b:a;
 }
 void addedge(int u, int v, int w, int rw=)
 {
     edge[tol].from=u;                            //记录起点
     edge[tol].to = v; edge[tol].cap = w; edge[tol].flow = ;
     edge[tol].next = head[u]; head[u] = tol++;
 }
 int Q[MAXN];
 int dep[MAXN], cur[MAXN], sta[MAXN];
 bool bfs(int s, int t, int n)
 {
     int front = , tail = ;
     memset(dep, -, sizeof(dep[])*(n+));
     dep[s] = ;
     Q[tail++] = s;
     while(front < tail)
     {
         int u = Q[front++];
         for(int i = head[u]; i != -; i = edge[i].next)
         {
             int v = edge[i].to;
             if(edge[i].cap > edge[i].flow && dep[v] == -)
                         {
                 dep[v] = dep[u] + ;
                 if(v == t) return true;
                 Q[tail++] = v;
             }
         }
     }
     return false;
 }
 int dinic(int s, int t, int n) {       //s是源点编号，t是汇点编号，n是点的总数，返回最大流
     int maxflow = ;
     while(bfs(s, t, n)) {
         for(int i = ; i < n; i++) cur[i] = head[i];
         int u = s, tail = ;
         while(cur[s] != -)
         {
             if(u == t)
             {
                 int tp = INF;
                 for(int i = tail-; i >= ; i--)
                     tp = min(tp, edge[sta[i]].cap-edge[sta[i]].flow);
                 maxflow+=tp;
                 for(int i = tail-; i >= ; i--) {
                     edge[sta[i]].flow+=tp;
                     edge[sta[i]^].flow-=tp;
                     if(edge[sta[i]].cap-edge[sta[i]].flow==)
                         tail = i;
                 }
                 u = edge[sta[tail]].from;
             }
             else
                 if(cur[u] != - && edge[cur[u]].cap > edge[cur[u]].flow && dep[u] +  == dep[edge[cur[u]].to])
                 {
                     sta[tail++] = cur[u];
                     u = edge[cur[u]].to;
                 }
                 else
                 {
                     while(u != s && cur[u] == -)
                         u = edge[sta[--tail]].from;
                     cur[u] = edge[cur[u]].next;
                 }
         }
     }
     return maxflow;
 }