最大网络流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 Queue[MAXV];   //求最短增广路算法需要用到的队列

int MaxFlow_Dinic(int src, int des, int n);
bool BFS(int src, int des, int n); //广度优先搜索构造分层网络
void DFS(int src, int des, int n, int v, int &sumFlow);//深度优先搜索寻找增广路

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;
DFS(src, des, n, src, sumFlow);//深度优先搜索寻找增广路
}

return sumFlow;
}

void DFS(int src, int des, int n, int v, int &sumFlow)//深度优先搜索寻找增广路
{
if (v == des) //逆向调整增广路（即修改对应残流网络的容量）
{
int inc = flow[des];
sumFlow += inc;

while (v != src)
{
int u = pre[v];
capacity[u][v] -= inc;
capacity[v][u] += inc;
flow[u] -= inc; //更新结点u的实际可用流量
v = u;
}
}
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];
DFS(src, des, n, i, sumFlow);//继续深度优先搜索下层节点寻找增广路
}
}
}
}

bool BFS(int src, int des, int n)//广度优先搜索构造分层网络，若不存在增广路，则返回false
{
int u, front = 0, rear = 0; //清空队列

for(int i=0; i<n; ++i) //初始化列表
{
dis[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;
}