最短路径算法

最短路径算法

Dijkstra算法_单源最短路径

Dijkstra算法

算法用于在非负加权图中寻找最短路径；

算法思路，从起点辐射式的寻找路径（进入电脑视野的路径及通过已知最短路径的点可到达的点），每次计算后最短的路径可确认我这个点的最短路径，反复多处直至发现终点的最短路径；

int dist[10], prev[10], v = 1, s[10];

dist【】用于记录最短路径；

prev【】用于记录到达此点最短路径的前一个点；

s【】用于记录此点是否已找到最短路径；

int dist[10], prev[10], v = 1, s[10];
for (int i = 1; i <= n; i++)
{
	dist[i] = c[v][i];
	s[i] = 0;
	if (dist[i] >= 99999)prev[i] = 0;
	else prev[i] = v;

}
dist[v] = 0;
s[v] = 1;
prev[v] = 0;
for (int i = 1; i <= n; i++)
{
	int temp = 99999;
	int u = v;
	for (int j = 1; j <= n; j++)
	{
		if (!s[j]&&dist[j] < temp)
		{
			temp = dist[j];
			u = j;
		}

	}
	s[u] = 1;
	for (int j = 1; j <= n; j++)
	{
		if (!s[j] && c[u][j] < 99999)
		{
			int newdist = dist[u] + c[u][j];
			if (newdist < dist[j])
			{
				dist[j] = newdist;
				prev[j] = u;
			}
		}
	}
}

floyd算法_多源最短路径

用于适用于解决多源最短路径，同一图多次求取不同源点，终点最短路径。

Floyd算法适用于APSP(All Pairs Shortest Paths，多源最短路径)，是一种动态规划算法，稠密图效果最佳，边权可正可负。此算法简单有效，由于三重循环结构紧凑，对于稠密图，效率要高于执行|V|次Dijkstra算法，也要高于执行|V|次SPFA算法。

优点：容易理解，可以算出任意两个节点之间的最短距离，代码编写简单。
缺点：时间复杂度比较高，不适合计算大量数据。

	#include<iostream>
using namespace std;

int e[10][10],path[10][10];

int f, en;
int n, m;

void Floyd()
{
	for (int k = 1; k <= n; k++)
	{
		for (int i = 1; i <= n; i++)
		{
			for (int j = 1; j <= n; j++)
			{
				if (e[i][j] > e[i][k] + e[k][j])
				{
					e[i][j] = e[i][k] + e[k][j];
					path[i][j] = path[i][k];
				}
			}
		}
	}
}

int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= n; j++)
		{
			e[i][j] = 1000;
			path[i][j] = j;
		}
	}

	for (int i = 1; i <= n; i++)
	{
		e[i][i] = 0;
	}

	int x, y, c;
	for (int i = 1; i <= m; i++)
	{
		cin >> x >> y >> c;
		e[x][y] = c;
	}

	Floyd();

	cin >> f >> en;
	cout << e[f][en] << endl;

	system("pause");
	return 0;
}

Bellman-Ford算法_计算单源最短路径

与Dijkstra算法相比计算效力很低，计算量大，但是更适用，可以判断负边，可以判断负圈。

松弛
每次松弛操作实际上是对相邻节点的访问，第次松弛操作保证了所有深度为n的路径最短。由于图的最短路径最长不会经过超过条边，所以可知贝尔曼-福特算法所得为最短路径。

负边权操作
与迪科斯彻算法不同的是，迪科斯彻算法的基本操作“拓展”是在深度上寻路，而“松弛”操作则是在广度上寻路，这就确定了贝尔曼-福特算法可以对负边进行操作而不会影响结果。

负权环判定
因为负权环可以无限制的降低总花费，所以如果发现第次操作仍可降低花销，就一定存在负权环。

#include<iostream>
using namespace std;

struct node
{
	int u, v, c;
}link[20];

int n, m;

int dist[20];

int main()
{
	cin >> n >> m;
	for (int i = 0; i < m; i++)
	{
		cin >> link[i].u >> link[i].v >> link[i].c;
	}

	memset(dist, 10000, sizeof(dist));

	dist[0] = 0;

	int flag = 0;
	int j;
	for(j=0;j<n;j++)
	{
		flag = 0;
		for (int i = 0; i < m; i++)
		{
			if (dist[link[i].u] != 10000 && dist[link[i].v] > dist[link[i].u] + link[i].c)
			{
				dist[link[i].v] = dist[link[i].u] + link[i].c;
				flag = 1;
			}
		}
		if (flag == 0)
		{
			break;
		}
	}
	if (j >= n)
	{
		cout << "有负环";
	}

	cout << dist[n - 1] << endl;
	system("pause");
	return 0;
}