最大网络流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)//不修改整条增广路，只修改当前节点和其父节点所在边的容量   
    {  
        inc = flow[des]; 
    }  
    else  
    {  
        int u = v; //始终用u表示弧尾节点   
            
        for(int i=0; i<n; ++i)    
        {    
            if (dis[i] == dis[u]-1 && capacity[u][i] != 0) //寻找下一层节点   
            {    
                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;  
                }  
            }    
        }    
    }
    
    //不修改整条增广路，只修改当前节点和其父节点所在边的容量   
    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];   //求最短增广路算法需要用到的队列     
    int v, front = 0, rear = 0; //清空队列       
          
    for(int i=0; i<n; ++i) //初始化列表       
    {      
        dis[i] = 0;  
        pre[i] = -1;  
    }      
    //汇点加入队列      
    dis[des] = 1;      
    Queue[rear++] = des;      
          
    while (front < rear) //队列非空      
    {      
        v = Queue[front++];     
        for(int i=0; i<n; ++i) //寻找未访问过的邻接点，并设置层数      
        {      
            if (dis[i] == 0 && capacity[i][v] != 0)       
            {      
                dis[i] = dis[v] + 1;  
                if (i == src) //找到源点，直接返回   
                {    
                    return true;    
                }    
                Queue[rear++] = i;      
            }      
        }        
    }      
          
    return false; 
}