C++ 基于Dijkstra算法和基于BFS算法的Ford Fulkson算法比较

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<ctime>
#include<cstring>
#include<vector>
#include<queue>
#include<array>
#include<windows.h>

using namespace std;

const int INF = INT_MAX;

//Edmond Karp.
bool EK_bfs(vector<vector<int> > &G, int src, int dest, vector<int> &Pre) {
	vector<int> visited(G.size(), false);
	vector<int> _Pre(G.size(), -1);

	queue<int> Q;
	Q.push(src);
	visited[src] = true;

	while (!Q.empty()) {
		int nd = Q.front();
		if (nd == dest) break;

		Q.pop();

		for (int i = 0; i < G.size(); ++i) {
			if (!visited[i] && G[nd][i] > 0) {
				_Pre[i] = nd;
				Q.push(i);
				visited[i] = true;
			}
		}
	}

	Pre.swap(_Pre);
	if (Pre[dest] == -1) return false;
	else return true;

}

struct Node
{
	int dist;
	bool visited;
	Node() : dist(INF), visited(false) {}
};

bool Dijkstra(vector<vector<int> > &G, int src, int dest, vector<int> & Pre) {
	vector<Node> D(G.size());
	vector<int> _Pre(G.size(), -1);

	D[src].dist = 0;
	for (int i = 0; i < G.size() - 1; ++i) {
		//extract min
		int min = -1;
		for (int j = 0; j < G.size(); ++j) {
			if (!D[j].visited && (min == -1 || D[j].dist < D[min].dist))
				min = j;
		}

		if (D[min].dist == INF) break;
		else D[min].visited = true;

		//relax
		for (int j = 0; j < G.size(); ++j) {
			if (!D[j].visited && G[min][j] > 0
				&& D[j].dist > D[min].dist + G[min][j]) {
				D[j].dist = D[min].dist + G[min][j];
				_Pre[j] = min;
			}
		}
	}

	Pre.swap(_Pre);

	if (D[dest].dist == INF) return false;
	else return true;
}

int Max_flow(vector<vector<int> > & G, int src, int dest) {
	int mxf = 0;
	vector<int> Pre;
	while (Dijkstra(G, src, dest, Pre)) {
	//while (EK_bfs(G, src, dest, Pre)) {
		int minf = INF;

		int e = dest;
		while (Pre[e] != -1) {
			minf = min(minf, G[Pre[e]][e]);
			e = Pre[e];
		}

		e = dest;
		while (Pre[e] != -1) {
			G[Pre[e]][e] -= minf;
			G[e][Pre[e]] += minf;
			e = Pre[e];
		}

		mxf += minf;
	}

	return mxf;
}

int main(void) {
	int N, M;
	while (cin >> N >> M) {
		vector<vector<int> > G(N, vector<int>(N, 0));
		for (int i = 0; i < M; ++i) {
			int s, t;
			cin >> s >> t;
			cin >> G[s][t];		//G[s][t] > 0
		}

		int src, dest;
		cin >> src >> dest;

		int mx_f;

		LARGE_INTEGER t1, t2, tc;
		QueryPerformanceFrequency(&tc);
		QueryPerformanceCounter(&t1);

		mx_f = Max_flow(G, src, dest);

		QueryPerformanceCounter(&t2);
		printf("Use Time:%f\n", (t2.QuadPart - t1.QuadPart)*1.0 / tc.QuadPart);

		cout << "Max_flow: " << mx_f << endl;
	}
	system("pause");
	return 0;
}

输入样本:

6

8

0 1 2

0 2 3

1 3 3

1 4 1

2 3 1

2 4 1

3 5 2

4 5 3

0 5

样本输出:

Use Time:0.000168 (不同情况有不同结果)

Max_flow: 4

时间: 2024-10-07 06:09:45

C++ 基于Dijkstra算法和基于BFS算法的Ford Fulkson算法比较的相关文章

中文分词常用算法之基于词典的双向最大匹配

算法描述: S1为带切分字符串,FMM为S1正向最大匹配切分结果,BMM为S1逆向最大匹配切分结果 如果FMM和BMM长度不相等则输出长度较短的那个否则转3 如果FMM和BMM的结果相同则输出任意一个否则输出单个字字数最少的结果 Java实现代码: 1 public static List<String> SegDouble(String text) { 2 List<String> FMM = FMM(text); 3 List<String> BMM = BMM(t

2维FFT算法实现——基于GPU的基2快速二维傅里叶变换

上篇讲述了一维FFT的GPU实现(FFT算法实现——基于GPU的基2快速傅里叶变换),后来我又由于需要做了一下二维FFT,大概思路如下. 首先看的肯定是公式: 如上面公式所描述的,2维FFT只需要拆分成行FFT,和列FFT就行了,其中我在下面的实现是假设原点在F(0,0),由于我的代码需要原点在中心,所以在最后我将原点移动到了中心. 下面是原点F(0,0)的2维FFT的伪代码: //C2DFFT //被执行2DFFT的是一个N*N的矩阵,在source_2d中按行顺序储存 //水平方向FFT f

最小生成树--Prim算法,基于优先队列的Prim算法,Kruskal算法,Boruvka算法,“等价类”UnionFind

最小支撑树树--Prim算法,基于优先队列的Prim算法,Kruskal算法,Boruvka算法,“等价类”UnionFind 最小支撑树树 前几节中介绍的算法都是针对无权图的,本节将介绍带权图的最小支撑树(minimum spanning tree)算法.给定一个无向图G,并且它的每条边均权值,则MST是一个包括G的所有顶点及边的子集的图,这个子集保证图是连通的,并且子集中所有边的权值之和为所有子集中最小的. 本节中介绍三种算法求解图的最小生成树:Prim算法.Kruskal算法和Boruvk

基于Hama平台的并行Finding a Maximal Independent Set 算法的设计与实现

作者:白松 西工大研究生.转载请注明出处:http://blog.csdn.net/xin_jmail/article/details/32101483. 本文参加了2014年CSDN博文大赛,如果您觉得此文对您有所帮助,就请为我投上您宝贵的一票,不胜感激.投票地址:http://vote.blog.csdn.net/Article/Details?articleid=32101483 . 本文目的:讲解并行Finding a Maximal Independent Set(寻找最大独立集问题)

推荐算法之基于用户的协同过滤算法

协同过滤是推荐算法中最基本的算法,主要分为基于用户的协同过滤算法和基于物品的协同过滤算法. 这篇文章主要介绍基于用户的协同过滤算法,简单来说,要给用户u作推荐,那么只要找出那些和u之前的行为类似的用户,即和u比较像的用户,把他们的行为推荐给用户u即可.所以基于用户的系统过滤算法包括两个步骤:1)找到和目标用户兴趣相似的用户集合  2)找到这个集合中的用户喜欢的,且目标用户没有听说过的物品推荐给目标用户. 第一步的关键点在于计算用户之间的相似度,相似度一般通过Jaccard公式或者余弦相似度即可求

图论之随机配流02——基于LOGIT的STOCH配流法-改进的dial算法

function dialsuanfaxishujuzhen(T) %程序说明 clc disp('======================================================================================'); disp('                   <基于LOGIT的STOCH配流法--改进的dial算法>'); disp('运行环境:MATLAB 8.3.0.532 '); disp('制 作 人:兰州交通大学

基于空间误差同质区的矢量电子地图快速纠偏算法 Fast Map Rectification Algorithm Based on Spatial Error Homogeneous Region

作 者:蔡文婷刘正坤CAI Wen-tingLIU Zheng-kun(Dingxin Information Technology Co.Ltd,Guangzhou 510623Guangdong Electric Power Design Institute Co.Ltd of China Energy Engineering Group,Guangzhou 510663,China) 作者机构:[1]鼎信信息科技有限责任公司,广东广州510623;[2]中国能源建设集团广东省电力设计研究院

推荐算法之基于物品的协同过滤

基于物品的协同过滤( item-based collaborative filtering )算法是此前业界应用较多的算法.无论是亚马逊网,还是Netflix .Hulu . YouTube ,其推荐算法的基础都是该算法.为行文方便,下文以英文简称ItemCF表示.本文将从其基础算法讲起,一步步进行改进并基于MovieLens 数据集给出代码实现,带你领略这一经典算法的美. 1.基本原理 前面我们简单讲解了一下基于用户的协同过滤推荐(UserCF),并且给出了实现代码.还不了解的朋友可以转到链接

算法笔记_144:有向图强连通分量的Tarjan算法(Java)

目录 1 问题描述 2 解决方案 1 问题描述 引用自百度百科: 如果两个顶点可以相互通达,则称两个顶点强连通(strongly connected).如果有向图G的每两个顶点都强连通,称G是一个强连通图.有向图的极大强连通子图,称为强连通分量(strongly connected components). Tarjan算法是基于对图深度优先搜索的算法,每个强连通分量为搜索树中的一棵子树.搜索时,把当前搜索树中未处理的节点加入一个堆栈,回溯时可以判断栈顶到栈中的节点是否为一个强连通分量. 定义D