EF算法中的最短长度增值算法（MPLA）

EF算法中的最短长度增值算法（MPLA）

（1）初始化一条容量为0的流f和剩余网络R，第一个剩余网络为原图G,每条边的剩余容量初始化为每条边的初始容量r（u，v）=c（u, v）。

（2）在剩余网络R中寻找增广路径P，取增广路径P中边的剩余容量r最小值作为流的增量修改剩余网络（正向边，反向边都修改）
在剩余网络里搜索有s到t的最短路径视为增广路径.

（3）重复（2）直到找不到一条增广路径。

增广路径

如果一个可行流不是最大流，那么当前网络中一定存在一条增广路经。

从源点S到汇点T的一条路径中，如果边(u,v)与该路径的方向一致就称为正向边，否则就记为逆向边，如果在这条路径上的所有边满足

正向边f(u,v)<c(u,v)
逆向边f(u,v)>0

则该路径是增广路径增广路径是算法扩增流的关键

建立反向边

反向建立边的作用相当于让之前的路径有可以反悔的余地。这样即使一开始走错也没有关系，因为可以通过反向边来反悔，最终一定能得到正确答案

增广路径

#include<iostream>
using namespace std;
int n, m, np, nc;
int cap[10][10];
int s, t;

int EKarp(int s, int t)
{
	int que[10];
	int num;
	int flow[10][10];
	int pre[10];
	int node[10];
	int max = 0;
	int u, v;


	

memset(flow, 0, sizeof(flow));
	while (1)
	{
		num = 1;
		que[num] = s;
		memset(node, 0, sizeof(node));
		node[s] = 10000;
		while (num != 0)
		{
			u = que[num--];
			for (v = 0; v <= t; v++)
			{
				if (!node[v] && cap[u][v] > flow[u][v])
				{
					int temp = cap[u][v] - flow[u][v];
					que[++num] = v;
					node[v] = node[u] < temp ? node[u] : temp;
					pre[v] = u;
				}
			}

		}
		if (node[t] == 0)
		{
			break;
		}

		for (u = t; u != s; u = pre[u])
		{
			flow[pre[u]][u] += node[t];
			flow[u][pre[u]] -= node[t];
		}
		max += node[t];

	}
	return max;

}

int main()
{
	cin >> n >> nc >> np >> m;

	s = n;
	t = n + 1;

	int u, v, c;
	for (int i = 0; i < m; i++)
	{
		cin >> u >> v >> c;
		cap[u][v] = c;
	}

	for (int i = 0; i < nc; i++)
	{
		cin >> v >> c;
		cap[s][v] = c;
	}

	for (int i = 0; i < np; i++)
	{
		cin >> u >> c;
		cap[u][t] = c;
	}


	/*for (int i = 0; i <= t; i++)
	{
		for (int j = 0; j <= t; j++)
		{
			cout << cap[i][j] << ' ';
		}
		cout << endl;
	}*/

	cout << EKarp(s, t);

	system("pause");

	return 0;
}