最短路径算法 dijkstra + floyd + spfa 【记录 总结】

 

问题：给定n个城市，这n个城市间有m条路，每条路长短不一，现让你求出从1到n的最短距离。

 

 

（1）dijkstra 算法：时间复杂度（N^2）

   

    优点：效率高

   缺点：不能求负权图

 

 

准备：用dist[]数组 记录起点到该节点的最短距离，用map[][]二维数组 记录每条边的权值即距离，用vis[]数组标记该点是否已查询过。

 

思路：每次寻求距离起点权值最小的点（除去起点 要遍历n-1次），找到后标记该点(已查找过)，然后更新起点到每个点的最短距离。

 

说下更新过程：假设 当前查询到的 距离起点最近的点为k，那么我们就可以把k当作是起点1和其它点v 的中间点(即1 -> k -> v)，进行更新。

更新实现 ： dist[ v ] = min(dist[ v ], dist[ k ] + map[ k ][ v ])。

 

注意点1--->注意对map[][]的初始化：map[ i ][ j ] = i == j ? 0 : INF。 INF 为无穷大的意思。

注意点2--->注意重边的出现。

 

 

代码实现：

#include <cstdio>
#include <cstring>
#include <algorithm>
#define MAXN 100+10 
#define INF 10000000+10
using namespace std;
int n, m;//点数 边数 
int dist[MAXN], vis[MAXN], map[MAXN][MAXN];
void init()
{
	for(int i = 1; i <= n; i++)
	{
		for(int j = 1; j <= n; j++)
		{
			map[i][j] = i==j?0:INF;
		}
	}
}
void getmap()
{
	int a, b, d;
	while(m--)
	{
		scanf("%d%d%d", &a, &b, &d);
		if(map[a][b] > d)
		map[a][b] = map[b][a] = d;
	}
}
void dijkstra(int s, int e)
{
	int next;//下一并入点 
	int lowdist;
	int i, j;
	for(i = 1; i <= n; i++)
	{
		dist[i] = map[s][i];
		vis[i] = 0;
	}
	vis[s] = 1;
	for(i = 2; i <= n; i++)
	{
		lowdist = INF; next = 1;
		for(j = 1; j <= n; j++)//寻找距离起点最近的点
		{
			if(!vis[j] && lowdist > dist[j])
			{
				next = j;
				lowdist = dist[j];
			}
		} 
		vis[next] = 1;
		for(j = 1; j <= n; j++)//更新 
		{
			if(!vis[j])
			{
				dist[j] = min(dist[j], dist[next]+map[next][j]);
			}
		}
	}
	printf("%d\n", dist[n]); 
}
int main()
{
	while(scanf("%d%d", &n, &m), n||m)
	{
		init();
		getmap();
		dijkstra(1, n);
	} 
	return 0;
}

 

 

（2）floyd算法：时间复杂度（N^3）

 

   优点：代码简洁，简单易懂，适用负权图。

   缺点：太过耗时，除非题目数据很小或者限时很大，要不少用。。。

 

准备：map[][]二维数组存储每条边的权值（初始化同dijkstra）。

 

思路：遍历所有点k，假设它是点i和j的中间点(i -> k -> j)，那么同dijkstra更新，最后map[ i ][ j ]存储的就是i到j的最短路径。

因为我们不知道遍历的k是哪些点的中间点，因此对于每个k值，都要遍历i和j(1 <= i <= n && 1 <= j <= n)。

 

代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#define MAXN 100+10 
#define INF 10000000+10
using namespace std;
int n, m;//点数 边数 
int map[MAXN][MAXN];
void init()
{
	for(int i = 1; i <= n; i++)
	{
		for(int j = 1; j <= n; j++)
		{
			map[i][j] = i==j?0:INF;
		}
	}
}
void getmap()
{
	int a, b, d;
	while(m--)
	{
		scanf("%d%d%d", &a, &b, &d);
		if(map[a][b] > d)
		map[a][b] = map[b][a] = d;
	}
}
void floyd(int s, int e)
{
	int k, i, j;
	for(k = 1; k <= n; k++)
	{
		for(i = 1; i <= n; i++)
		{
			for(j = 1; j <= n; j++)
			{
				map[i][j] = min(map[i][j], map[i][k]+map[k][j]);
			}
		}
	}
	printf("%d\n", map[s][e]);
} 
int main()
{
	while(scanf("%d%d", &n, &m), n||m)
	{
		init();
		getmap();
		floyd(1, n);
	} 
	return 0;
}

 

（3）spfa算法：时间复杂度（VE）

 

  优点：可以判断是否成环，负权图也适用

  缺点：时间效率不稳定

 

准备：

结构体记录每条边的信息 （邻接表实现）

struct Edge
{
	int to, val, next;//记录终点 该边的权值 下一节点指针 
}edge[10000+10];

vis[]数组 标记节点是否在队列里面，dist[]数组 记录最短距离。

used[]数组 记录某一点的入队次数( 若某点入队次数超过n说明存在负环 最短路不存在)

head[]数组 存储指针

top 记录边的数目

 

 

思路：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对它所所指向的结点v进行宋驰操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中(用vis数组判断)，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。在不存在负环的情况下，最后dist[ k ]存储的一定是起点到k点的最短距离。

 

这里有两个重要操作：

 

初始化：

void init()
{
	top = 0;
	for(i = 1; i <= n; i++)
	{
		head[i] = -1;//初始化指针
		used[i] = 0;//初始化入队次数
		vis[i] = 0;//都未标记 
	}
}

 

邻接表的增边函数：（也有直接按边数m递减 来增边的，有兴趣的可以自己上网查下） 注意无向图反向建边

void addedge(int u, int v, int w)
{
	Edge E = {v, w, head[u]};
	edge[top] = E;
	head[u] = top++;
}

 

代码：

 

#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#define MAX 100+10
#define INF 10000000+10
using namespace std;
struct Edge
{
	int to, val, next;//记录终点 该边的权值 下一节点指针 
}edge[10000+10];
int dist[MAX], vis[MAX], used[MAX];
int top;//记录边的数目 
int head[MAX]; 
int n, m; 
void init()//初始化 
{
	top = 0;
	for(int i = 1; i <= n; i++)
	{
		head[i] = -1;//初始化指针
		used[i] = 0;//初始化入队次数
		vis[i] = 0;//都未标记 
	}
}
void addedge(int u, int v, int w)//增边 
{
	Edge E = {v, w, head[u]};
	edge[top] = E;
	head[u] = top++;
}
void getmap()
{
	int u, v, w;
	while(m--)
	{
		scanf("%d%d%d", &u, &v, &w);
		addedge(u, v, w);
		addedge(v, u, w); 
	}
}
void spfa(int s, int e)
{
	int i;
	queue<int> Q;//建立队列
	for(i = 1; i <= n; i++)
	dist[i] = INF;
	while(!Q.empty()) Q.pop();//清空队列 
	vis[s] = 1;//标记 
	dist[s] = 0;
	Q.push(s);
	used[s]++; 
	while(!Q.empty())
	{
		int u = Q.front();
		Q.pop();
		vis[u] = 0;//去掉标记 
		for(i = head[u]; i != -1; i = edge[i].next)
		{
			Edge E = edge[i];
			if(dist[E.to] > dist[u] + E.val)//松弛操作 
			{
				dist[E.to] = dist[u] + E.val;
				if(!vis[E.to])//不在队列里面 
				{
					vis[E.to] = 1;
					used[E.to]++;//入队次数加一
					if(used[E.to] > n) 
					{
						printf("存在负环\n");
						return ;
					} 
					Q.push(E.to);//进队 
				}
			}
		}
	} 
	printf("%d\n", dist[e]); 
}
int main()
{
	while(scanf("%d%d", &n, &m), n||m)
	{
		init();
		getmap();
		spfa(1, n); 
	}
	return 0;
}