题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1874
这题比较基础，拿来练各种刚学会的算法比较好，可以避免好多陷阱，典型的最短路模板题
第一种解法：Floyd算法
算法实现：
使用一个邻接矩阵存储边权值，两两之间能访问的必为一个有限的数，不能访问则为无穷大（用2^29代替）。注意自身和自身距离为0。
对于一对顶点 u 和 v，看看是否存在一个断点 w 使得从 u 经过 w 到 v 比已知的路径更短（包含原始输入中从 u 直接到 v 的路程）。
对所有顶点进行如上松弛操作，得到的结果是两点之间的最短路程，也可判断两点是否连通。
算法缺点：
普通的Floyd算法时间复杂度为O(n^3)，对于数据较多的情况容易TLE。但解决本题 HDU 1874 完全足够。
Floyd算法耗时62MS
#include<stdio.h>
#define Max 0xfffffff
int n
,
m
,
map
[
201
][
201
];
int
min(
int
a
,
int b)
{
return
a
>b
?b
:
a;
}
void
getmap()
{
int
i
,
j
,
a
,b
,
l;
for(
i
=
0;
i
<n;
i
++)
for(
j
=
0;
j
<n;
j
++)
map
[
i
][
j
]
=(
i
==
j
?
0
:
Max);
for(
i
=
0;
i
<
m;
i
++)
{
scanf(
"%d%d%d"
,
&
a
,
&b
,
&
l);
map
[
a
][b
]
=
map
[b
][
a
]
=
min(
map
[
a
][b
],
l);
}
}
void
floyd(
int s
,
int
e)
{
int
i
,
j
,
k;
for(
k
=
0;
k
<n;
k
++)
for(
i
=
0;
i
<n;
i
++)
for(
j
=
0;
j
<n;
j
++)
map
[
i
][
j
]
=
min(
map
[
i
][
j
],
map
[
i
][
k
]
+
map
[
k
][
j
]);
printf(
"%d
\n
"
,
map
[s
][
e
]
<
Max
?
map
[s
][
e
]
:-
1);
}
int
main()
{
int s
,
e;
while(
~
scanf(
"%d%d"
,
&n
,
&
m))
{
getmap();
scanf(
"%d%d"
,
&s
,
&
e);
floyd(s
,
e);
}
return
0;
}
第二种解法：
Dijkstra算法
这个算法比较经典，一般的最短路径都可以用这个来解决，耗时也比较少，不过不能处理负权路径
按路径长度递增次序产生最短路径算法：
把V分成两组：
（1）S：已求出最短路径的顶点的集合
（2）V-S=T：尚未确定最短路径的顶点集合
将T中顶点按最短路径递增的次序加入到S中，
保证：（1）从源点V0到S中各顶点的最短路径长度都不大于
从V0到T中任何顶点的最短路径长度
（2）每个顶点对应一个距离值
S中顶点：从V0到此顶点的最短路径长度
T中顶点：从V0到此顶点的只包括S中顶点作中间
顶点的最短路径长度
依据：可以证明V0到T中顶点Vk的最短路径，或是从V0到Vk的
直接路径的权值；或是从V0经S中顶点到Vk的路径权值之和
（反证法可证）
求最短路径步骤
算法步骤如下：
1. 初使时令 S={V0},T={其余顶点}，T中顶点对应的距离值
若存在<V0,Vi>，d(V0,Vi)为<V0,Vi>弧上的权值
若不存在<V0,Vi>，d(V0,Vi)为∝
2. 从T中选取一个其距离值为最小的顶点W且不在S中，加入S
3. 对T中顶点的距离值进行修改：若加进W作中间顶点，从V0到Vi的
距离值比不加W的路径要短，则修改此距离值
重复上述步骤2、3，直到S中包含所有顶点，即S=T为止
Dijkstra算法耗时0MS
#include<stdio.h>
#include<string.h>
#define max 999999
int
map
[
201
][
201
];
int n
,
m
,
st
,
en
,
f
[
201
],
mark
[
201
];
void
Dijkstra()
{
int
i
,
j
,
k
,
min;
memset(
mark
,
0
,
sizeof(
mark));
for(
i
=
0;
i
<n;
i
++)
f
[
i
]
=
map
[
st
][
i
];
f
[
st
]
=
0;
for(
i
=
0;
i
<n;
i
++)
{
min
=
max;
for(
j
=
0;
j
<n;
j
++)
{
if(
!
mark
[
j
]
&&
f
[
j
]
<
min)
{
min
=
f
[
j
];
k
=
j;
}
}
if(
min
==
max)
break;
mark
[
k
]
=
1;
for(
j
=
0;
j
<n;
j
++)
if(
!
mark
[
j
]
&&
f
[
j
]
>
f
[
k
]
+
map
[
k
][
j
])
f
[
j
]
=
f
[
k
]
+
map
[
k
][
j
];
}
if(
f
[
en
]
!=
max)
printf(
"%d
\n
"
,
f
[
en
]);
else
printf(
"-1
\n
");
}
int
main()
{
int
x
,
y
,
z
,
i
,
j;
while(
scanf(
"%d%d"
,
&n
,
&
m)
!=
EOF)
{
for(
i
=
0;
i
<=n
-
1;
i
++)
for(
j
=
0;
j
<=n
-
1;
j
++)
map
[
i
][
j
]
=
max;
for(
i
=
1;
i
<=
m;
i
++)
{
scanf(
"%d %d %d"
,
&
x
,
&
y
,
&
z);
if(
map
[
x
][
y
]
>
z)
{
map
[
x
][
y
]
=
map
[
y
][
x
]
=
z
;}
}
scanf(
"%d %d"
,
&
st
,
&
en);
Dijkstra();
}
return
0;
}
第三种解法：
Bellman_Ford算法
这个算法也比较好理解，就是不断松弛操作，处理含有负权的路径
对有向图G(V,E)，用贝尔曼-福特算法求以Vs为源点的最短路径的过程：
- 建立dist[]、Pred[],且dist[s] = 0,其余赋。Pred[]表示某节点路径上的父节点
- 对，比较dist[Vi] + (Vi,Vj)和dist[Vj],并将小的赋给dist[Vj]，如果修改了dist[V_j]则pred[Vj] = Vi（松弛操作）
- 重复以上操作V − 1次
- 再重复操作一次，如dist[Vj] > dist[Vi] + (Vi,Vj),则此图存在负权环。
伪代码：
For
i
:=
1
to |
V
|-
1
do
//v为顶点数
For
每条边(
u
,
v)
∈
E
do
//对每条边进行遍历
Relax(
u
,
v
,
w);
For
每条边(
u
,
v)
∈
E
do
//判断是否存在负权环
If
dis
[
u
]
+
w
<
dis
[
v
]
Then
Exit(
False)
Bellman_Ford算法耗时15MS，
代码：
#include<stdio.h>
#define MAX 1047483647
int
m
,n
,
d
[
208
],
start
,
tar;
struct
project
{
int
x
,
y
,
w;
}
map
[
2008
];
void
Bellman_Ford()
{
int
i
,
j;
for(
i
=
0;
i
<n;
i
++)
//Init
d
[
i
]
=
MAX;
d
[
start
]
=
0;
for(
i
=
0;
i
<n;
i
++)
for(
j
=
0;
j
<
2
*
m;
j
++)
{
if(
d
[
map
[
j
].
x
]
>
d
[
map
[
j
].
y
]
+
map
[
j
].
w)
//relax x --w--> y
d
[
map
[
j
].
x
]
=
d
[
map
[
j
].
y
]
+
map
[
j
].
w;
}
if(
d
[
tar
]
<
MAX)
printf(
"%d
\n
"
,
d
[
tar
]);
else
printf(
"-1
\n
");
}
int
main()
{
int
i;
while(
scanf(
"%d%d"
,
&n
,
&
m)
!=
EOF)
{
for(
i
=
0;
i
<
m;
i
++)
{
scanf(
"%d%d%d"
,
&
map
[
i
].
x
,
&
map
[
i
].
y
,
&
map
[
i
].
w);
//two way road ---> one way road
map
[
i
+
m
].
y
=
map
[
i
].
x;
map
[
i
+
m
].
x
=
map
[
i
].
y;
map
[
i
+
m
].
w
=
map
[
i
].
w;
}
scanf(
"%d%d"
,
&
start
,
&
tar);
Bellman_Ford();
}
return
0;
}
第四种解法：
SPFA算法
这种算法可以说是Bellman_Ford算法的优化，就是在Bellman_Ford算法的基础上加上队列实现，
SPFA(Shortest Path Faster Algorithm)
算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素，并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。 直到队列为空时算法结束。
这个算法，简单的说就是队列优化的bellman-ford,利用了每个点不会更新次数太多的特点发明的此算法
SPFA——Shortest Path Faster Algorithm，它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。SPFA的实现甚至比Dijkstra或者Bellman_Ford还要简单：
设Dist代表S到I点的当前最短距离，Fa代表S到I的当前最短路径中I点之前的一个点的编号。开始时Dist全部为+∞，只有Dist[S]=0，Fa全部为0。
维护一个队列，里面存放所有需要进行迭代的点。初始时队列中只有一个点S。用一个布尔数组记录每个点是否处在队列中。
每次迭代，取出队头的点v，依次枚举从v出发的边v->u，设边的长度为len，判断Dist[v]+len是否小于Dist[u]，若小于则改进Dist[u]，将Fa[u]记为v，并且由于S到u的最短距离变小了，有可能u可以改进其它的点，所以若u不在队列中，就将它放入队尾。这样一直迭代下去直到队列变空，也就是S到所有的最短距离都确定下来，结束算法。若一个点入队次数超过n，则有负权环。
SPFA 在形式上和宽度优先搜索非常类似，不同的是宽度优先搜索中一个点出了队列就不可能重新进入队列，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本身被改进，于是再次用来改进其它的点，这样反复迭代下去。设一个点用来作为迭代点对其它点进行改进的平均次数为k，有办法证明对于通常的情况，k在2左右。
SPFA算法（Shortest Path Faster Algorithm），也是求解单源最短路径问题的一种算法，用来解决：给定一个加权有向图G和源点s，对于图G中的任意一点v，求从s到v的最短路径。 SPFA算法是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算，他的基本算法和Bellman-Ford一样，并且用如下的方法改进： 1、第二步，不是枚举所有节点，而是通过队列来进行优化 设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。 2、同时除了通过判断队列是否为空来结束循环，还可以通过下面的方法： 判断有无负环：如果某个点进入队列的次数超过V次则存在负环（SPFA无法处理带负环的图）。
SPFA算法有两个优化算法 SLF 和 LLL
SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)<dist(i)，则将j插入队首，否则插入队尾。 LLL：Large Label Last 策略，设队首元素为i，队列中所有dist值的平均值为x，若dist(i)>x则将i插入到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出对进行松弛操作。 SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高约 50%。 在实际的应用中SPFA的算法时间效率不是很稳定，为了避免最坏情况的出现，通常使用效率更加稳定的Dijkstra算法。
优化之后耗时0ＭＳ，
代码：
#include<stdio.h>
//SPFA 模拟队列实现最短路径
#include<string.h>
#define INF 100000
int
map
[
210
][
210
],
flag
[
210
],
Q
[
210
],
d
[
210
];
int
m
,n
,
start
,
tar;
void
SPFA()
{
int
i
,
x;
int
front
=
0
,
rear
=
0;
memset(
Q
,
0
,
sizeof(
Q));
memset(
flag
,
0
,
sizeof(
flag));
for(
i
=
0;
i
<n;
i
++)
d
[
i
]
=
INF;
d
[
start
]
=
0;
Q
[
rear
]
=
start;
rear
++;
flag
[
start
]
=
1;
while(
front
<
rear)
{
x
=
Q
[
front
];
//出队列
front
=(
front
+
1)
%
210;
flag
[
x
]
=
0;
for(
i
=
0;
i
<n;
i
++)
{
if(
d
[
i
]
>
d
[
x
]
+
map
[
x
][
i
])
{
d
[
i
]
=
d
[
x
]
+
map
[
x
][
i
];
if(
!
flag
[
i
])
{
Q
[
rear
]
=
i;
//入队列
rear
=(
rear
+
1)
%
210;
flag
[
i
]
=
1;
}
}
}
}
if(
d
[
tar
]
<
INF)
printf(
"%d
\n
"
,
d
[
tar
]);
else
printf(
"-1
\n
");
}
int
main()
{
int
i
,
j
,
a
,b
,
c;
while(
scanf(
"%d%d"
,
&n
,
&
m)
!=
EOF)
{
for(
i
=
0;
i
<n;
i
++)
for(
j
=
0;
j
<n;
j
++)
map
[
i
][
j
]
=
INF;
for(
i
=
0;
i
<
m;
i
++)
{
scanf(
"%d%d%d"
,
&
a
,
&b
,
&
c);
if(
map
[
a
][b
]
>
c)
map
[
a
][b
]
=
map
[b
][
a
]
=
c;
}
scanf(
"%d%d"
,
&
start
,
&
tar);
SPFA();
}
return
0;
}
其实最短路总结就一句话，不断的进行松弛操作，无论是什么解法，都要进行松弛操作，然后找到最短路径
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
