适用范围：
给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。 我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。
算法思想：
我们用数组d记录每个结点的最短路径估计值，用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止
期望的时间复杂度O(ke)， 其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。
算法实现过程：
建立一个队列，初始时队列里只有起始点，再建立一个表格记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。然后执行松弛操作，用队列里有的点作为起始点去刷新到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空。 判断有无负环： 如果某个点进入队列的次数超过N次则存在负环（SPFA无法处理带负环的图） 首先建立起始点a到其余各点的 最短路径表格
nodeabcdefg
d[i]0∞∞∞∞∞∞
首先源点a入队，当队列非空时： １、队首元素（a）出队，对以a为起始点的所有边的终点依次进行松弛操作（此处有b,c,d三个点），此时路径表格状态为：
out of queue nodenodes in queuenodes in queuenodes in queue
abcd024815
在松弛时三个点的最短路径估值变小了，而这些点队列中都没有出现，这些点需要入队，此时，队列中新入队了三个结点b,c,d 队首元素b点出队，对以b为起始点的所有边的终点依次进行松弛操作（此处只有e点），此时路径表格状态为：
out of queue nodenodes in queuenodes in queuenodes in queue
bcde2481530
在最短路径表中，e的最短路径估值也变小了，e在队列中不存在，因此e也要入队，此时队列中的元素为c，d，e 队首元素c点出队，对以c为起始点的所有边的终点依次进行松弛操作（此处有e,f两个点），此时路径表格状态为：
out of queue nodenodes in queuenodes in queuenodes in queue
cdef8151511
在最短路径表中，e，f的最短路径估值变小了，e在队列中存在，f不存在。因此e不用入队了，f要入队，此时队列中的元素为d，e，f 队首元素d点出队，对以d为起始点的所有边的终点依次进行松弛操作（此处只有g这个点），此时路径表格状态为：
out of queue nodenodes in queuenodes in queuenodes in queue
defg15151119
在最短路径表中，g的最短路径估值没有变小（松弛不成功），没有新结点入队，队列中元素为f，g 队首元素f点出队，对以f为起始点的所有边的终点依次进行松弛操作（此处有d，e，g三个点），此时路径表格状态为：
out of queue nodenodes in queuenodes in queuenodes in queue
efg151119
在最短路径表中，e，g的最短路径估值又变小，队列中无e点，e入队，队列中存在g这个点，g不用入队，此时队列中元素为g，e 队首元素g点出队，对以g为起始点的所有边的终点依次进行松弛操作（此处只有b点），此时路径表格状态为：
out of queue nodenodes in queuenodes in queuenodes in queue
geb141317
在最短路径表中，b的最短路径估值又变小，队列中无b点，b入队，此时队列中元素为e，b 队首元素e点出队，对以e为起始点的所有边的终点依次进行松弛操作（此处只有g这个点），此时路径表格状态为：
out of queue nodenodes in queuenodes in queuenodes in queue
eb1317
在最短路径表中，g的最短路径估值没变化（松弛不成功），此时队列中元素为b 队首元素b点出队，对以b为起始点的所有边的终点依次进行松弛操作（此处只有e这个点），此时路径表格状态为：
out of queue nodenodes in queuenodes in queuenodes in queue
bnull17null
在最短路径表中，e的最短路径估值没变化（松弛不成功），此时队列为空了 最终a到g的最短路径为１４
实现代码
package code.cdn.src.com.utils;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Scanner;
public class SPFA {
private double[][] map;
private double[] dist;
public static final int INF =
10000;
private int n;
private int s;
private int e;
private HashMap<Pairs, ArrayList<Integer>> shortPathLinkMap;
public SPFA(){
}
public SPFA(
int n,
int s,
int e,
double[][] map) {
this.n = n;
this.s = s;
this.e = e;
this.map = map;
dist =
new double[n];
shortPathLinkMap =
new HashMap<Pairs, ArrayList<Integer>>();
}
/**
* @author Zhang_Li
* 算法的逻辑主要在函数spfa()里实现
*/
public void spfa() {
for (
int i =
0; i < dist.length; i++) {
dist[i] = INF;
}
Queue<Integer> queue =
new LinkedList<Integer>();
queue.offer(s);
dist[s] =
0;
shortPathLinkMap.put(
new Pairs(s,s),
new ArrayList<Integer>());
while (!queue.isEmpty()) {
int poll = queue.poll();
ArrayList<Integer> t_List = shortPathLinkMap.get(
new Pairs(s,poll));
for (
int i =
0; i < map[poll].length; i++) {
if (map[poll][i] < INF || map[i][poll] < INF) {
if (!queue.contains(i)) {
if (dist[i] > dist[poll] + map[poll][i]) {
queue.add(i);
Pairs t_Pairs =
new Pairs(s,i);
ArrayList<Integer> t_List1 =
new ArrayList<Integer>();
t_List1.addAll(t_List);
t_List1.add(i);
shortPathLinkMap.put(t_Pairs, t_List1);
dist[i] = dist[poll] + map[poll][i];
}
}
else {
if (map[poll][i] + dist[poll] < dist[i]) {
ArrayList<Integer> being_List;
if(!shortPathLinkMap.containsKey(
new Pairs(s,poll))){
being_List =
new ArrayList<Integer>();
}
else{
being_List = shortPathLinkMap.get(
new Pairs(s,poll));
}
ArrayList<Integer> copy_List =
new ArrayList<Integer>();
copy_List.addAll(being_List);
copy_List.add(i);
Pairs new_Pairs =
new Pairs(s,i);
shortPathLinkMap.put(new_Pairs,copy_List);
dist[i] = map[poll][i] + dist[poll];
}
}
}
}
}
}
/**
* 打印一下log
* @param t_Pairs
* @param t_List
*/
private static void printLog(Pairs t_Pairs, ArrayList<Integer> t_List) {
System.out.print(t_Pairs +
" ");
for (
int k : t_List) {
System.out.print(k +
" ");
}
System.out.println();
}
public void SPFAByMe(
int s,
int e,
double[][] graphMatrix) {
this.s = s;
this.e = e;
this.map = graphMatrix;
this.n = graphMatrix.length;
this.dist =
new double[n];
shortPathLinkMap =
new HashMap<Pairs, ArrayList<Integer>>();
spfa();
}
public static void main(String[] args) {
Scanner sc =
new Scanner(System.in);
int n, m, s, e, u, v, w;
double[][] map;
while (sc.hasNext()) {
n = sc.nextInt();
m = sc.nextInt();
map =
new double[n][n];
for (
int i =
0; i < n; i++)
for (
int j =
0; j < n; j++)
map[i][j] = INF;
while (m-- >
0) {
u = sc.nextInt();
v = sc.nextInt();
w = sc.nextInt();
if (map[u][v] > w) {
map[u][v] = w;
}
}
s = sc.nextInt();
e = sc.nextInt();
SPFA ma =
new SPFA(n, s, e, map);
ma.spfa();
double[] dist = ma.getDist();
if (dist[e] == INF)
System.out.println(-
1);
else
System.out.println(dist[e]);
HashMap<Pairs, ArrayList<Integer>> shortPathLinkMap = ma.getShortPathLinkMap();
Iterator<Entry<Pairs, ArrayList<Integer>>> it = shortPathLinkMap.entrySet().iterator();
while (it.hasNext()){
Entry<Pairs, ArrayList<Integer>> next = it.next();
Pairs key = next.getKey();
ArrayList<Integer> value = next.getValue();
}
}
}
public double[][]
getMap() {
return map;
}
public void setMap(
double[][] rentCapRatio) {
this.map = rentCapRatio;
}
public int getN() {
return n;
}
public void setN(
int n) {
this.n = n;
}
public int getS() {
return s;
}
public void setS(
int s) {
this.s = s;
}
public int getE() {
return e;
}
public void setE(
int e) {
this.e = e;
}
public HashMap<Pairs, ArrayList<Integer>>
getShortPathLinkMap() {
return shortPathLinkMap;
}
public void setShortPathLinkMap(HashMap<Pairs, ArrayList<Integer>> shortPathLinkMap) {
this.shortPathLinkMap = shortPathLinkMap;
}
public void setDist(
double[] dist) {
this.dist = dist;
}
public double[]
getDist() {
return dist;
}
}
reference：
http://lib.csdn.net/article/datastructure/10344
