SPFA algorithm Detailed

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; This initialization has implications for the while loop below
}

for (int i=1;i<=m;i++)
{
scanf ("%d%d%d\n", &u,&v,&w);
E[i].x=v; The record successor node is equivalent to creating a node in the linked list and causes the data field to be recorded first
E[i].value=w;
E[i].next=st[u]; Record the subscript of one of the edge table nodes of a vertex node, which is equivalent to the next pointer of the side table node in the linked list first points to his subsequent edge table node
St[u]=i; The pointer to the vertex points to the edge table node, which is equivalent to the insertion in the linked list, and the pointer of the head node changes
}
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;
}

2. SPFA (shortest Path Faster algorithm) [graph is stored as adjacency table]
4. is a queue implementation of the Bellman-ford algorithm, which reduces unnecessary redundancy calculations.
6. The approximate process of the algorithm is to use a queue for maintenance. Initially, the source is added to the queue. Each time an element is taken out of the queue,
8. and relaxes all points adjacent to him, and if an adjacent point relaxes successfully, it is enqueued. The algorithm ends until the queue is empty.
10. It can find the shortest path from the source point to all other points in the time complexity of O (KE), and can handle negative edges.
12. 
    
14. SPFA in the form and BFS very similar, the difference is the BFS in a point out of the queue will not be able to re-enter the queue, but SPFA
16. A point may be placed in the queue again after the queue, that is, a point improved over the other points, after a period of time may be this
18. The body is improved, so it is used again to improve the other points, so that repeated iteration down.
20. 
    
22. Determine if there is a negative ring: a negative ring exists if a point enters the queue more than V (SPFA cannot process a graph with negative loops).
24. 
    
26. The SPFA algorithm has two optimization algorithms SLF and LLL:
28. Slf:small Label first policy, set the node to be added is J, team head element is I, if Dist (j) <dist (i), then J is inserted into the first team,
30. Otherwise insert the tail of the team.
32. Lll:large Label last policy, set the first element of the team is I, the average of all dist values in the queue is X, if dist (i) >x i insert
34. At the end of the queue, find the next element until a certain I is found to make the dist (i) <=x, then the I-out pair for relaxation operation.
36. Quoting online data, SLF can increase the speed of the 20%;SLF + LLL up to about 50%.
38. In the practical application, the SPFA algorithm time efficiency is not very stable, in order to avoid the worst case occurrence, usually uses the more stable Dijkstra algorithm.
40. */
44. adjacency table storage with arrays, pnt[i,0] represents the number of nodes adjacent to I, PNT[I,1...K] stores the points adjacent to I
46. int PNT[MAXN][MAXN];
48. int MAP[MAXN][MAXN]; MAP[I,J] for the initial input of the distance from I to J, and map[i,i]=0; unknown map[i,j]=inf;
50. int DIS[MAXN];
52. Char VST[MAXN];
56. int SPFA (int n,int s)
58. {
60. int i, PRI, end, p, t;
62. memset (VST, 0, sizeof (VST));
64. for (I=1; i<=n; i++)
66. Dis[i] = INF;
68. Dis[s] = 0;
70. Vst[s] = 1;
72. Q[0] = s; pri = 0; end = 1;
74. while (PRI < end)
76. {
78. p = Q[pri];
80. for (I=1; i<=pnt[p][0]; i++)
82. {
84. t = Pnt[p][i];
86. Release first, and then decide if you want to join the queue
88. if (Dis[p]+map[p][t] < dis[t])
90. {
92. DIS[T] = dis[p]+map[p][t];
94. if (!vst[t])
96. {
98. q[end++] = t;
100. Vst[t] = 1;
102. }
104. }
106. }
108. Vst[p] = 0;
110. pri++;
112. }
114. return 1;
116. }

SPFA algorithm Detailed