最大流ISAP算法模版

最新推荐文章于 2025-09-06 22:33:46 发布

weixin_34128534

最新推荐文章于 2025-09-06 22:33:46 发布

阅读量57

点赞数

CC 4.0 BY-SA版权

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/creativityroom/p/6755197.html

本文详细介绍了一种改进的短路径优先(ISAP)算法实现，用于解决最大流问题。通过使用C++代码示例，展示了如何初始化图结构、进行距离标记、搜索增广路径以及输出最大流值等关键步骤。

唉，说多了都是泪,贴一下ISAP的代码就让初学者参考一下，有问题请指出。

#include<iostream>
#include<vector>
using std::vector;
#include<deque>
#include<stack>
using std::stack;
using std::deque;
#include<algorithm>
using std::cin;
template <typename T>
class ISAP {
public:
	ISAP() {
	};
	template<typename U>
	struct Edge
	{
		Edge(int f, int t, U c, U fl) :from(f), to(t), cap(c), flow(fl) {};
		Edge() {};
		int from, to;
		U cap, flow;
	};

	int N;      //顶点的总数
	int E;      //边的总数
	int s;     //指定源s
	int t;      //指定目的t
	int cE;     //目前边数
	vector<Edge<T>> Ed;   //存放边
	vector<vector<int>> G;//图中一个顶点关联的边的标号
	vector<int>         d;//距离标号
	vector<bool>        vis;//表明是否被访问过
	vector<int>         pre;//父亲结点
	vector<int>         gap;//gap优化
	void Init()
	{
		cin >> N >> E;
		Ed.resize(E);
		G.resize(N + 1);
		d.resize(N + 1);
		pre.resize(N + 1);
		gap.resize(N + 1);
		for (int i = 0; i < N + 1; i++)
			d[i] = 0;
		vis.resize(N + 1);
		for (int i = 0; i < N + 1; i++)
			vis[i] = false;
		for (int i = 0; i < N + 1; i++)
			gap[i] = 0;
		cE = 0;
		s = 1;
		t = N;
		for (int i = 0; i < E; i++)
		{
			int u, v;
			T c;
			cin >> u >> v >> c;
			addedge(u, v, c);
		}
	}

	//生成初始距离标号
	void make_d()
	{
		vis[t] = true;                               //标记终点为访问过
		deque<int> dq;                               //队列,广度优先搜索找标记所有到终点距离
		dq.push_back(t);                             //压入终点
		d[t] = 0;                                    //终点到终点距离为0
		while (!dq.empty())                          //队列为空，退出循环，所有点都被标记了
		{
			int front = dq.front(); dq.pop_front();  //获得队首，并弹出
			int Gsize = G[front].size();             //该结点邻居的数量
			for (int i = 0; i < Gsize; i++)          //遍历该结点有所的邻居
			{
				int Enum = G[front][i];              //找出结点和邻居关联的边的编号
				if (front == Ed[Enum].to)            //如果结点是这条边的终点
				{
					int aim = Ed[Enum].from;         //获得边的起点

					if (Ed[Enum].cap - Ed[Enum].flow>0 && !vis[aim])//邻居有残余流量流向结点，并且邻居没有被访问过
					{
						d[aim] = d[front] + 1;　　　　//标记邻居的距离为结点距离+1
						gap[d[aim]]++;                //有d[aim]距离的结点个数+1
						vis[aim] = true;              //标记邻居为访问过
						dq.push_back(aim);            //将邻居压入队列
					}
				}
				else if (front == Ed[Enum].from)　　　 //结点为边的起点
				{                      
					int aim = Ed[Enum].to;             //获得邻居 
					if (Ed[Enum].flow > 0 && !vis[aim])//邻居有残余流量流向起点，并且邻居没有被访问过
					{
						d[aim] = d[front] + 1;         //更新邻居的距离
						gap[d[aim]]++;　　　　　　　　 //有d[aim]距离的结点个数+1　
						vis[aim] = true;               //标记邻居为访问过
						dq.push_back(aim);             //将邻居压入队列
					}
				}
			}
		}
		for (int i = 0; i < N + 1; i++)
			vis[i] = false;
	}

	void search()
	{
		pre[s] = -1;                                 //特殊处理，起点在增广路径中没有前置边，置为-1
		bool flag = true;                            //是否退出循环的标志
		while (flag)
		{
			//找增广路
			int cur = s;                             //当前结点为起始结点
			T minFlow = 10000000;　　　　　　　　　　//流无穷大
			while (cur != t)                         //当前结点未到达终止结点
			{
				int Gsize = G[cur].size();           //当前结点邻居的数量
				bool find = false;　　　　　　　　　//标记没有找到可行孤
				int Minaimdis = N - 1;              //在找不到可行孤的情况下，标记最小距离的孤
				for (int i = 0; i < Gsize; i++)     //遍历没有邻居
				{
					Edge<T> &e = Ed[G[cur][i]];     //当前邻居关联的边
					if (e.to == cur && e.flow > 0)  //当前结点是终止结点，并且有残余流量流向邻居结点
					{
						int from = e.from;          //邻居结点
						if (d[from] == d[cur] - 1)  //如果满足邻居结点的距离 + 1 = 当前结点的距离
						{
							find = true;            //找到可行孤
							pre[from] = G[cur][i];  //标记邻居结点的前置边
							cur = from;             //当前结点更新为邻居结点
							minFlow = std::min(minFlow, e.flow); //更新增广路的流量
							break;                  //不用再从邻居中找了
						}
						Minaimdis = std::min(Minaimdis, d[from]);　//邻居没有找到，更新最小距离的孤
					}
					else if (e.from == cur && e.cap - e.flow > 0)　//同上
					{
						int to = e.to;
						if (d[to] == d[cur] - 1)
						{
							find = true;
							pre[to] = G[cur][i];
							cur = to;
							minFlow = std::min(minFlow, e.cap - e.flow);
							break;
						}
						Minaimdis = std::min(Minaimdis, d[to]);
					}
				}
				if (!find)           　　　　　　　　　　　　　　　　　　　　//未找到可行孤
				{
					gap[d[cur]]--;                                           //将当前结点距离数量-1
					if (gap[d[cur]] == 0) { flag = false; break; }           //如果该距离数量变为0，则出现断层，已经找到找大流

					d[cur] = Minaimdis + 1;　　　　　　　　//更新最小距离,最在为N
					gap[d[cur]]++;                         //更新gap
					int edgenum = pre[cur];　　　　　　　　//找到当前结点关联的前置边
					if (edgenum == -1)cur = s;             //表示没有前置边,为起点,标记当前结点为起点
					else if (cur == Ed[edgenum].to)        //如果当前结点为前置边的终点
						cur = Ed[edgenum].from;　　　　　　//标记当前结点为前置边的起点
					else
						cur = Ed[edgenum].to;
				}
			}

			if (cur == t)//找到增广路,调整流量
			{
				while (cur != s)
				{
					Edge<T>& e = Ed[pre[cur]];
					if (cur == e.to)
					{
						e.flow += minFlow;
						cur = e.from;
					}
					else
					{
						e.flow -= minFlow;
						cur = e.to;
					}
				}
			}
		}
	}

	void output()
	{
		T ans = 0;
		for (int i = 0; i < G[s].size(); i++)
		{
			ans += Ed[G[s][i]].flow;
		}
		using std::cout;
		cout << ans;
	}

	void addedge(int from, int to, T cap)
	{
		G[from].push_back(cE);
		G[to].push_back(cE);
		Ed[cE++] = Edge<T>(from, to, cap, 0);
	}
};

int main()
{
	ISAP<int> isap;
	isap.Init();
	isap.make_d();
	isap.search();
	isap.output();
	return 0;
}

转载于:https://www.cnblogs.com/creativityroom/p/6755197.html