program：

#include<cstdio>
using namespace std;
struct node
{int x;
int value;
int next;
};
node e[60000];
int visited[1505],dis[1505],st[1505],queue[1000];
int main()
{
int n,m,u,v,w,start,h,r,cur;
freopen("c.in","r",stdin);
freopen("c.out","w",stdout);
while(scanf("%d%d",&n,&m)!=EOF)
{
for(int i=1;i<=1500;i++)
{visited[i]=0;
dis[i]=-1;
st[i]=-1; //這個初始化給下邊那個while循環帶來影響
}

for(int i=1;i<=m;i++)
{
scanf("%d%d%d\n",&u,&v,&w);
e[i].x=v; //記錄後繼節點 相當於鏈表中的創建一個節點，並使得數據域先記錄
e[i].value=w;
e[i].next=st[u]; //記錄頂點節點的某一個邊表節點的下標，相當於在鏈表中吧該邊表節點的next指針先指向他的後繼邊表節點
st[u]=i; //把該頂點的指針指向邊表節點，相當於鏈表中的插入中，頭結點的指針改變
}
start=1;
visited[start]=1;
dis[start]=0;
h=0;
r=1;
queue[r]=start;
while(h!=r)
{

h=(h+1)%1000;
cur=queue[h];
int tmp=st[cur];
visited[cur]=0;

while(tmp!=-1)
{
if (dis[e[tmp].x]>dis[cur]+e[tmp].value)
{
dis[e[tmp].x]=dis[cur]+e[tmp].value;
if(visited[e[tmp].x]==0)
{

visited[e[tmp].x]=1;
r=(r+1)%1000;
queue[r]=e[tmp].x;
}
}
tmp=e[tmp].next;
}
}
printf("%d\n",dis[n]);
}
return 0;
}

1. SPFA(Shortest Path Faster Algorithm) [圖的存儲方式為鄰接表]
2. 是Bellman-Ford算法的一種隊列實現，減少了不必要的冗余計算。
3. 算法大致流程是用一個隊列來進行維護。 初始時將源加入隊列。 每次從隊列中取出一個元素，
4. 並對所有與他相鄰的點進行松弛，若某個相鄰的點松弛成功，則將其入隊。 直到隊列為空時算法結束。
5. 它可以在O(kE)的時間復雜度內求出源點到其他所有點的最短路徑，可以處理負邊。
6. 
   
7. SPFA 在形式上和BFS非常類似，不同的是BFS中一個點出了隊列就不可能重新進入隊列，但是SPFA中
8. 一個點可能在出隊列之後再次被放入隊列，也就是一個點改進過其它的點之後，過了一段時間可能本
9. 身被改進，於是再次用來改進其它的點，這樣反復叠代下去。
10. 
    
11. 判斷有無負環：如果某個點進入隊列的次數超過V次則存在負環（SPFA無法處理帶負環的圖）。
12. 
    
13. SPFA算法有兩個優化算法 SLF 和 LLL：
14. SLF：Small Label First 策略，設要加入的節點是j，隊首元素為i，若dist(j)<dist(i)，則將j插入隊首，
15. 否則插入隊尾。
16. LLL：Large Label Last 策略，設隊首元素為i，隊列中所有dist值的平均值為x，若dist(i)>x則將i插入
17. 到隊尾，查找下一元素，直到找到某一i使得dist(i)<=x，則將i出對進行松弛操作。
18. 引用網上資料，SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高約 50%。
19. 在實際的應用中SPFA的算法時間效率不是很穩定，為了避免最壞情況的出現，通常使用效率更加穩定的Dijkstra算法。
20. */
22. //用數組實現鄰接表存儲，pnt[i,0]表示與i相鄰的結點個數，pnt[i,1...k]存儲與i相鄰的點
23. int pnt[MAXN][MAXN];
24. int map[MAXN][MAXN]; //map[i,j]為初始輸入的i到j的距離，並且map[i,i]=0;未知的map[i,j]=INF;
25. int dis[MAXN];
26. char vst[MAXN];
28. int SPFA(int n,int s)
29. {
30. int i, pri, end, p, t;
31. memset(vst, 0, sizeof(vst));
32. for (i=1; i<=n; i++)
33. dis[i] = INF;
34. dis[s] = 0;
35. vst[s] = 1;
36. Q[0] = s; pri = 0; end = 1;
37. while (pri < end)
38. {
39. p = Q[pri];
40. for (i=1; i<=pnt[p][0]; i++)
41. {
42. t = pnt[p][i];
43. //先釋放，釋放成功後再判斷是否要加入隊列
44. if (dis[p]+map[p][t] < dis[t])
45. {
46. dis[t] = dis[p]+map[p][t];
47. if (!vst[t])
48. {
49. Q[end++] = t;
50. vst[t] = 1;
51. }
52. }
53. }
54. vst[p] = 0;
55. pri++;
56. }
57. return 1;
58. }

spfa算法詳解