最短路经问题

Prim算法：

主要处理问题：最小生成树问题。

算法思想：V表示所有节点集合，首先s进入集合U，然后找出集合U与剩余节点V-U中最小权值的边[u,v]，将v加入集合U，直到U==V截至

时间复杂度：相对与Kruskal需要多次排序，>>O(E)

Kruskal算法：推荐

主要处理问题：最小生成树问题。

算法思想：对所有边按照权值进行排序，然后使用并查集，将所有节点加入到集合中。

时间复杂度：O(E)

Dijkstra算法：推荐

主要处理问题：权值为正，单源点最短路径问题

算法思想：N-1次松弛，每次找出没有被访问过d值最小的节点x，然后对所有与x相连的节点进行松弛

时间复杂度：O(N*N)，比较稳定

Bellman_Ford算法：

主要处理问题：权值为负，无负环，单源点最短路径问题

算法思想：N-1次松弛，每次历遍完所有边进行松弛

时间复杂度：O(N*E)

SPFA算法：推荐

（Shortest Path Faster Algorithm）

主要处理问题：权值为负，无负环，单源点最短路径问题。或者稀疏图，邻接表实现

算法思想：bfs+松弛，队实现，首先s入队，输出队首元素u，然后历遍与u相连的所有边[u,v]，然后进行松弛，如果松弛成功，并且v没有在队中，则将v入队。

时间复杂度：O(E) --- O(N*E)，不稳定

拓展：如果某一个节点入队超过N-1次，则存在负环

Floyd算法：

主要处理问题：所有节点间最短路径问题

算法思想：动态规划，三重循环

时间复杂度：O(N^3)

算法模板：

//Dijkstra
int dijkstra(int s, int e)
{
	for(i = 0; i < N; ++ i) d[i] = INF;
	d[s] = 0;
	memset(vis, 0, sizeof(vis));
	for(i = 0; i < N - 1; ++ i)
	{
		int x = 0;
		for(j = 0; j <= N; ++ j) if(!vis[j] && d[j] < d[x]) 
			x = j;
		vis[x] = 1;
		for(j = 0; j <= N; ++ j) if(map[x][j] && d[j] > d[x] + map[x][j]) 
			d[j] = d[x] + map[x][j];
	}
	return d[e];
}

//SPFA
struct Node
{
	int v, w;
};
vector<Node> G[nMax];
int vis[nMax];
int spfa(int s, int e)
{
	memset(vis, 0, sizeof(vis));
	for(i = 0; i < N; ++ i) dis[i] = INF;
	dis[s] = 0;
	queue<int> que;
	que.push(s);
	while(!que.empty())
	{
		int u = que.front();
		que.pop();
		vis[u] = 0;
		for(i = 0; i < G[u].size(); ++ i)
		{
			Node tmp = G[u][i];
			if(dis[tmp.y] > dis[u] + tmp.w)
			{
				dis[tmp.y] = dis[u] + tmp.w;
				if(!vis[tmp.y])
				{
					vis[tmp.y] = 1;
					que.push(tmp.y);
				}
			}
		}
	}
	return dis[e];
}

//Floyd
for(k = 0; k < N; ++ k)
for(i = 0; i < N; ++ i)
for(j = 0; j < N; ++ j)
if(d[i][j] > d[i][k] + d[k][j])
d[i][j] = d[i][k] + d[k][j];

推荐博客： http://blog.csdn.net/v_JULY_v/article/details/6181485