问题:给定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;
}