最大网络流Dinic算法（优化版）

/*
  Name: 最大网络流Dinic算法（优化版） 
  Copyright: 
  Author: 巧若拙 
  Date: 10-06-17 22:08
  Description: 优化的Dinic算法。
  先广度优先搜索分层网络，然后深度优先搜索增广路。
  每找到一条增广路，不修改整条增广路，只修改当前节点和其父节点所在边的容量，可以减少操作次数；
  标注不能通往汇点以形成增广路的节点是阻塞节点，下次不再访问它。
  上述两个优化可以减少重复修改容量和搜索操作。  
*/

#include<iostream>  
#include <fstream>
  
using namespace std;  
  
const int MAXV=2000;   //最大顶点数量   
const int MAXE=2000;   //最大边数量  
const int INFINITY = 0x7fffffff;   //无穷大   
int capacity[MAXV][MAXV]; //记录残流网络的容量  
int flow[MAXV];  //标记从源点到当前节点实际还剩多少流量可用  
int pre[MAXV];  //标记在这条路径上当前节点的前驱,同时标记该节点是否在队列中  
int dis[MAXV]; //标记节点所在的层次 
int block[MAXV]; //标记节点是否为阻塞节点 
  
int MaxFlow_Dinic(int src, int des, int n);  
bool BFS(int src, int des, int n); //广度优先搜索构造分层网络  
int DFS(int src, int des, int n, int v);//深度优先搜索寻找增广路  
  
int main()  
{ 
    int  m, n, u, v;  
    ifstream fcin("maxflow.txt");
    
    if (!fcin.is_open())
    {
        cout << "Error opening file"; exit (1);
    }
  
    fcin >> n >> m;
   
    for(int i=0; i<m; ++i)  
    {  
        fcin >> u >> v;  
        fcin >> capacity[u][v];      
    }  
    
    cout << n << " " << m << endl;
    for (int i=0; i<n; i++)
    {
        for (int j=0; j<n; j++)
        {
            cout << capacity[i][j] << " ";
        }
        cout << endl;
    }
      
    cout << MaxFlow_Dinic(0, n-1, n) << endl;  
  
    system("pause");                     
    return 0;  
}  
  
int MaxFlow_Dinic(int src, int des, int n)  
{  
    int sumFlow = 0; //存储 src到des的最大流   
    int u, v;  
  
    while (BFS(src, des, n))  
    { 
        flow[src] = INFINITY;  
        pre[src] = src;  
        sumFlow += DFS(src, des, n, src);//深度优先搜索寻找增广路  
    }  
      
    return sumFlow;  
}  

int DFS(int src, int des, int n, int v)//深度优先搜索寻找增广路，返回节点v和其父节点所在边的流量增量  
{
    int inc = 0; //存储最短增广路的流量增量，实际上分层网络的路径都是‘最短’的 
    
    if (v == des)//不修改整条增广路，只修改当前节点和其父节点所在边的容量 
    {
        int u = pre[v];
        inc = flow[des];
        capacity[u][v] -= inc;  
        capacity[v][u] += inc;  
    }
    else
    {
        int u = v; //始终用u表示弧尾节点 
        bool flag = true; //默认是阻塞节点 
          
        for(int i=0; i<n; ++i)  
        {  
            if (block[i] == 0 && dis[i] == dis[u]+1 && capacity[u][i] != 0) //寻找下一层非阻塞节点 
            {  
                flag = false; //i是非阻塞节点
                pre[i] = u;  
                flow[i] = (flow[u] < capacity[u][i]) ? flow[u] : capacity[u][i];   
                inc += DFS(src, des, n, i);//继续深度优先搜索下层节点寻找增广路，并累计节点v和其父节点所在边的流量增量  
		        flow[u] -= inc; //更新结点u的实际可用流量，一定要及时更新，否则会影响增广路的可增加流量   
		        if (flow[u] == 0) //没流量了就别再找了 
				{
 			        break;
 			    }
            }  
        }  
        
        if (flag)  //标注u是阻塞节点，下次不再访问它 
        {
            block[u] = 1;
        }
        else //不修改整条增广路，只修改当前节点和其父节点所在边的容量 
        {
            capacity[pre[v]][v] -= inc;  
            capacity[v][pre[v]] += inc;  
        }
    }
    
    return inc; //返回节点v和其父节点所在边的流量增量   
}
  
bool BFS(int src, int des, int n)//广度优先搜索构造分层网络，若不存在增广路，则返回false  
{  
    int Queue[MAXV] = {0};   //求最短增广路算法需要用到的队列   
    int u, front = 0, rear = 0; //清空队列   
      
    for(int i=0; i<n; ++i) //初始化列表   
    {  
        dis[i] = 0;  
        block[i] = 0;  
    }  
    //源点加入队列  
    dis[src] = 1;  
    Queue[rear++] = src;  
      
    while (front < rear) //队列非空  
    {  
        u = Queue[front++];  
        for(int i=0; i<n; ++i) //寻找未访问过的邻接点，并设置层数  
        {  
            if (dis[i] == 0 && capacity[u][i] != 0)   
            {  
                dis[i] = dis[u] + 1;  
                
                if (i == des) //找到汇点，直接返回 
                {  
                    return true;  
                }  
                
                Queue[rear++] = i; 
            }  
        }  
    }  
       
    return false;  
}