最短路
标签（空格分隔）： ACM 最短路 图论
最短路
Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 28761 Accepted Submission(s): 12444
Problem Description
在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？
Input
输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，每行包括3个整数A，B，C（1<=A,B<=N,1<=C<=1000）,表示在路口A与路口B之间有一条路，我们的工作人员需要C分钟的时间走过这条路。
输入保证至少存在1条商店到赛场的路线。
Output
对于每组输入，输出一行，表示工作人员从商店走到赛场的最短时间
Sample Input
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0
Sample Output
3
2题目：http://acm.hdu.edu.cn/showproblem.php?pid=2544
求最短路，我是看《挑战程序设计竞赛》里的书学的。
里面介绍了三种方法： Bellman-Ford、Dijkstra and Floyd
三者区别也都很明显：
Bellman-Ford：
求单源最短路，可以判断有无负权回路（若有，则不存在最短路）， 时效性较好，时间复杂度O（VE）。
Bellman-Ford算法是求解单源最短路径问题的一种算法。
单源点的最短路径问题是指： 给定一个加权有向图G和源点s，对于图G中的任意一点v，求从s到v的最短路径。
与Dijkstra算法不同的是，在Bellman-Ford算法中，边的权值可以为负数。 设想从我们可以从图中找到一个环路（即从v出发，经过若干个点之后又回到v）且这个环路中所有边的权值之和为负。那么通过这个环路，环路中任意两点的最短路径就可以无穷小下去。如果不处理这个负环路，程序就会永远运行下去。 而Bellman-Ford算法具有分辨这种负环路的能力。
Dijkstra：
求单源、无负权的最短路。时效性较好，时间复杂度为O（V*V+E）。 源点可达的话，O（V*lgV+E*lgV）=>O（E*lgV）。 当是稀疏图的情况时，此时E=V*V/lgV，所以算法的时间复杂度可为O（V^2） 。若是斐波那契堆作优先队列的话，算法时间复杂度，则为O（V*lgV + E）。
Floyd：
求多源、无负权边的最短路。用矩阵记录图。时效性较差，时间复杂度O(V^3)。 Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题。
Floyd-Warshall算法的时间复杂度为O(N^3)，空间复杂度为O(N^2)。
Floyd-Warshall的原理是动态规划： 设Di,j,k为从i到j的只以(1..k)集合中的节点为中间节点的最短路径的长度。 若最短路径经过点k，则Di,j,k = Di,k,k-1 + Dk,j,k-1； 若最短路径不经过点k，则Di,j,k = Di,j,k-1。 因此，Di,j,k = min(Di,k,k-1 + Dk,j,k-1 , Di,j,k-1)。
在实际算法中，为了节约空间，可以直接在原来空间上进行迭代，这样空间可降至二维。 Floyd-Warshall算法的描述如下： for k ← 1 to n do for i ← 1 to n do for j ← 1 to n do if (Di,k + Dk,j < Di,j) then Di,j ← Di,k + Dk,j; 其中Di,j表示由点i到点j的代价，当Di,j为 ∞ 表示两点之间没有任何连接。
后来，我看Bellman-Ford的队列优化，SPFA（Shortest Path Faster Algorithm ）。
SPFA：
是Bellman-Ford的队列优化，时效性相对好，时间复杂度O（kE）。（k<
/****************************************
*****************************************
* Author:Tree *
*From :http://blog.csdn.net/lttree *
* Title : 最短路 *
*Source: hdu 2544 *
* Hint : SPFA *
*****************************************
****************************************/
#include <stdio.h>
#include <queue>
using namespace std;
#define RANGE 101
#define MAX 0x3f3f3f3f
int cost[RANGE][RANGE];
int d[RANGE];
bool used[RANGE];
int n,m;
void spfa( int s )
{
int i,now;
// 初始化
for( i=1;i<=n;++i )
{
d[i]=MAX;
used[i]=false;
}
d[s]=0;
queue <int> q;
q.push(s);
used[s] = true;
while(!q.empty())
{
now = q.front();
q.pop();
used[now] = false;
for(i = 1; i <= n; i++)
{
if(d[i] > d[now] + cost[now][i])
{
d[i] = d[now] + cost[now][i];
if(used[i] == 0)
{
q.push(i);
used[i] = true;
}
}
}
}
}
int main()
{
int i,j,A,B,C;
while( scanf("%d%d",&n,&m) )
{
if( !n && !m ) break;
// 初始化
for( i=1;i<=n;++i )
for( j=1;j<=i;++j )
if( i==j ) cost[i][j]=0;
else cost[i][j]=cost[j][i]=MAX;
for( i=0;i<m;++i )
{
scanf("%d%d%d",&A,&B,&C);
cost[A][B]=cost[B][A]=C;
}
spfa(1);
printf("%d
",d[n]);
}
return 0;
} Dijkstra：
/****************************************
*****************************************
* Author:Tree *
*From :http://blog.csdn.net/lttree *
* Title : 最短路 *
*Source: hdu 2544 *
* Hint : Dijkstra *
*****************************************
****************************************/
#include <stdio.h>
#define MAX 0x3f3f3f3f
#define RANGE 101
int cost[RANGE][RANGE];
int d[RANGE];
bool used[RANGE];
int n,m;
int Min( int a,int b )
{
return a<b?a:b;
}
void Dijkstra( int s )
{
int i,v,u;
for( i=1;i<=n;++i )
{
used[i]=false;
d[i]=cost[1][i];
}
d[s]=0;
while( true )
{
v=-1;
for( u=1;u<=n;++u )
if( !used[u] && ( v==-1 || d[u]<d[v]) )
v=u;
if( v==-1 ) break;
used[v]=true;
for( u=1;u<=n;++u )
d[u]=Min( d[u],d[v]+cost[v][u] );
}
}
int main()
{
int A,B,C,i,j;
while( scanf("%d%d",&n,&m) )
{
if( !n && !m ) break;
// 初始化
for( i=1;i<=n;++i )
for( j=1;j<=i;++j )
if( i==j ) cost[i][j]=0;
else cost[i][j]=cost[j][i]=MAX;
for( i=0;i<m;++i )
{
scanf("%d%d%d",&A,&B,&C);
cost[A][B]=cost[B][A]=C;
}
Dijkstra(1);
printf("%d
",d[n]);
}
return 0;
} Floyd：
/****************************************
*****************************************
* Author:Tree *
*From :http://blog.csdn.net/lttree *
* Title : 最短路 *
*Source: hdu 2544 *
* Hint : Floyd *
*****************************************
****************************************/
#include <stdio.h>
#define MAX 0x3f3f3f3f
#define RANGE 105
int d[RANGE][RANGE];
int n;
int Min( int a,int b )
{
return a<b?a:b;
}
void warshall_floyd( void )
{
int i,j,k;
for( k=1;k<=n;++k )
for( i=1;i<=n;++i )
for( j=1;j<=n;++j )
d[i][j]=Min( d[i][j],d[i][k]+d[k][j] );
}
int main()
{
int m,A,B,C,i,j;
while( scanf("%d%d",&n,&m) )
{
if( !n && !m ) break;
// 初始化
for( i=1;i<=n;++i )
for( j=1;j<=i;++j )
{
if( i==j ) d[i][j]=0;
else d[i][j]=d[j][i]=MAX;
}
// 输入
for( i=0;i<m;++i )
{
scanf("%d%d%d",&A,&B,&C);
d[A][B]=d[B][A]=C;
}
// floyd算法求最短路
warshall_floyd();
printf("%d
",d[1][n]);
}
return 0;
} 整体测试代码
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<iomanip>
#include<cstdio>
#include<queue>
#include<stack>
#include<vector>
#include<functional>
#define INF 99999
using namespace std;
typedef pair<int, int> P;
struct edge {
int from, to, cost;
};
int n, m; //n为顶点数，m为边数
int a[100][100];
void warshall()
{
int b[100][100] = { 0 };
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
b[i][j] = a[i][j];
cout << "Floyd-warshall:
";
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= n; j++)
{
for (int k = 1; k <= n; k++)
{
if (b[j][k] > b[j][i] + b[i][k])
{
b[j][k] = b[j][i] + b[i][k];
}
}
}
}
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= n; j++)
{
cout << b[i][j] << " ";
}
cout << endl;
}
}
void Dijkstra()
{
int dis[100] = { 0 };
bool book[100] = { 0 };
int b[100][100] = { 0 };
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
b[i][j] = a[i][j];
for (int i = 1; i <= n; i++)
{
dis[i] = a[1][i];
}
book[1] = 1;
for (int i = 1; i <= n - 1; i++)
{
int minv = INF, min = 0;
for (int i = 1; i <= n; i++)
{
if (!book[i] && minv > dis[i])
{
minv = dis[i]; //在取最小值的过程中可以用堆优化
min = i;
}
}
book[min] = 1;
for (int j = 1; j <= n; j++)
{
if (dis[j] > dis[min] + a[min][j])
{
dis[j] = dis[min] + a[min][j]; //用最短的边对其他所有点进行优化
}
}
}
for (int i = 1; i <= n; i++)
{
cout << dis[i] << " ";
}
cout << endl;
}
void Bellman()
{
int dis[100] = { 0 };
int b[100][100] = { 0 };
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
b[i][j] = a[i][j];
for (int i = 1; i <= n; i++)
dis[i] = INF;
dis[1] = 0;
/*for (int i = 1; i <= n; i++)
{
dis[i] = a[1][i];
}*/
for (int i = 1; i <= n - 1; i++)
{
for (int j = 1; j <= n; j++)
{
for (int k = 1; k <= n; k++)
{
if (dis[k] > dis[j] + a[j][k])
{
dis[k] = dis[j] + a[j][k];
}
}
}
}
for (int i = 1; i <= n; i++)
{
cout << dis[i] << " ";
}
cout << endl;
}
void BellmanQueue()
{
int dis[100] = { 0 };
int b[100][100] = { 0 };
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
b[i][j] = a[i][j];
for (int i = 1; i <= n; i++)
dis[i] = INF;
dis[1] = 0;
queue<int> que;
bool book[100] = { 0 };
que.push(1);
book[1] = 1;
while (que.size())
{
int k = que.front();
que.pop();
for (int i = 1; i <= n; i++)
{
if (dis[i] > dis[k] + b[k][i])
{
dis[i] = dis[k] + b[k][i];
if (!book[i])
{
que.push(i);
book[i] = 1;
}
}
}
book[k] = 0;
}
for (int i = 1; i <= n; i++)
{
cout << dis[i] << " ";
}
cout << endl;
}
void warshall2()
{
vector<edge> G[100];
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++)
{
int p;
edge q;
cin >> p >> q.to >> q.cost;
G[p].push_back(q);
}
for (int i = 1; i <= n; i++)
{
for (int k = 1; k <= n; k++)
{
for (int j = 0; j < G[k].size(); j++)
{
edge e = G[k][j];
}
}
}
cout << "不会
";
}
void Dijkstra2()
{
vector<edge> G[100];
int n, m;
cin >> n >> m;
int dis[100] = { 0 };
fill(dis, dis + 100, INF);
dis[1] = 0;
for (int i = 0; i < m; i++)
{
int p;
edge q;
cin >> p >> q.to >> q.cost;
G[p].push_back(q);
}
priority_queue<P, vector<P>, greater<P> >que;
que.push(P(0, 1));
while (que.size())
{
P p= que.top(); que.pop();
for (int i = 0; i < G[p.second].size(); i++)
{
edge e = G[p.second][i];
if (dis[e.to] > dis[p.second] + e.cost)
{
dis[e.to] = dis[p.second] + e.cost;
que.push(P(dis[e.to], e.to));
}
}
}
for (int i = 1; i <= n; i++)
{
cout << dis[i] << " ";
}
cout << endl;
}
void Bellman2()
{
edge G[100];
int n, m;
cin >> n >> m;
int dis[100] = { 0 };
fill(dis, dis + 100, INF);
dis[1] = 0;
for (int i = 0; i < m; i++)
{
cin >> G[i].from >> G[i].to >> G[i].cost;
}
for (int i = 1; i <= n - 1; i++)
{
for (int j = 0; j < m; j++)
{
dis[G[j].to] = min(dis[G[j].to], dis[G[j].from] + G[j].cost);
}
}
for (int i = 1; i <= n; i++)
{
cout << dis[i] << " ";
}
cout << endl;
}
int main()
{
cin >> n >> m;
for(int i=0;i<=n;i++)
for (int j = 0; j <= n; j++)
{
if (i == j) a[i][j] = 0;
else a[i][j] = INF;
}
for (int i = 1; i <= m; i++)
{
int p, q, t;
cin >> p >> q >> t;
a[p][q] = t;
}
cout << "邻接矩阵:
";
cout << "1:Floyd-warshall 2:Dijkstra 3:Bellman-Ford 4:Bellman队列优化(SPFA)
";
cout << "邻接表
";
cout << "5:Floyd-warshall 6:Dijkstra(堆优化) 7：Bellman-Ford
";
int t;
while (cin >> t)
{
if (t == 1)
{
warshall();
}
else if (t == 2)
{
cout << "Dijkstra:
";
Dijkstra();
}
else if (t == 3)
{
cout << "Bellman-Ford:
";
Bellman();
}
else if (t == 4)
{
cout << "Bellman队列优化:
";
BellmanQueue();
}
else if (t == 5)
{
cout << "Floyd-warshall（邻接表）:
";
warshall2();
}
else if (t == 6)
{
cout << "Dijkstra(堆优化)
";
Dijkstra2();
}
else if (t == 7)
{
cout << "Bellman-Ford:
";
Bellman2();
}
}
}