SPFA算法

/*
SPFA(Shortest Path Faster Algorithm) [图的存储方式为邻接表]
是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。
算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素，
并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。 直到队列为空时算法结束。
它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。

SPFA 在形式上和BFS非常类似，不同的是BFS中一个点出了队列就不可能重新进入队列，但是SPFA中
一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本
身被改进，于是再次用来改进其它的点，这样反复迭代下去。

判断有无负环：如果某个点进入队列的次数超过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算法。
*/

//用数组实现邻接表存储，pnt[i,0]表示与i相邻的结点个数，pnt[i,1...k]存储与i相邻的点
int  pnt[MAXN][MAXN];
int  map[MAXN][MAXN]; //map[i,j]为初始输入的i到j的距离，并且map[i,i]=0;未知的map[i,j]=INF;
int  dis[MAXN];
char vst[MAXN];

int SPFA(int n, int s)
{
    int i, pri, end, p, t;
    memset(vst, 0, sizeof(vst));
    for (i=1; i<=n; i++)
        dis[i] = INF;
    dis[s] = 0;
    vst[s] = 1;
    Q[0] = s; pri = 0; end = 1;
    while (pri < end)
    {
        p = Q[pri];
        for (i=1; i<=pnt[p][0]; i++)
        {
            t = pnt[p][i];
            //先释放，释放成功后再判断是否要加入队列
            if (dis[p]+map[p][t] < dis[t])
            {
                dis[t] = dis[p]+map[p][t];
                if (!vst[t])
                {
                    Q[end++] = t;
                    vst[t] = 1;
                }
            }
        }
        vst[p] = 0;
        pri++;
    }
    return 1;
}

1. 正规邻接表存储：  
2. /* ------- 邻接表存储 ----------- */  
3. struct Edge  
4. {  
5.     int e;  //终点  
6.     int v;  //边权  
7.     struct Edge *nxt;  
8. };  
9. struct  
10. {  
11.     struct Edge *head, *last;  
12. } node[MAXN];  
13. /* -------------------------------- */  
14.   
15. /*  添加有向边<起点,终点,边权>  */  
16. void add(int s, int e, int v)  
17. {  
18.     struct Edge *p;  
19.     p = (struct Edge*)malloc(sizeof(struct Edge));  
20.     p->e = e;  
21.     p->v = v;  
22.     p->nxt = NULL;  
23.     if (node[s].head == NULL)  
24.     {  
25.         node[s].head = p;  
26.         node[s].last = p;  
27.     }  
28.     else  
29.     {  
30.         node[s].last->nxt = p;  
31.         node[s].last = p;  
32.     }  
33. }  
34.   
35. /*  松弛，成功返回1，否则0  */  
36. int relax(int s, int e, int v)  
37. {  
38.     if (dis[s]+v < dis[e])  
39.     {  
40.         dis[e] = dis[s]+v;  
41.         return 1;  
42.     }  
43.     return 0;  
44. }  
45.   
46. /*  SPFA有负权回路返回0,否则返回1并且最短路径保存在dis[]  */  
47. int n;  
48. int vst[MAXN], cnt[MAXN];  
49. int Q[MAXN*MAXN];  
50. int SPFA(int s0)  
51. {  
52.     int i, p, q;  
53.     struct Edge *pp;  
54.   
55.     memset(vst, 0, sizeof(vst));  
56.     memset(cnt, 0, sizeof(cnt));  
57.     for (i=0; i<=n; i++)  
58.         dis[i] = INF;  
59.     dis[s0] = 0;  
60.   
61.     Q[0] = s0; p = 0; q = 1;  
62.     vst[s0] = 1;  
63.     cnt[s0]++;  
64.     while (p < q)  
65.     {  
66.         pp = node[Q[p]].head;  
67.         while (pp)  
68.         {  
69.             if (relax(Q[p], pp->e, pp->v) && !vst[pp->e])  
70.             {  
71.                 Q[q++] = pp->e;  
72.                 vst[pp->e] = 1;  
73.                 cnt[pp->e]++;  
74.                 if (cnt[pp->e] > n) //有负权回路  
75.                     return 0;  
76.             }  
77.             pp = pp->nxt;  
78.         }  
79.         vst[Q[p]] = 0;  
80.         p++;  
81.     }  
82.     return 1;  
83. }  

正规邻接表存储：
/* ------- 邻接表存储 ----------- */
struct Edge
{
    int e;  //终点
    int v;  //边权
    struct Edge *nxt;
};
struct
{
    struct Edge *head, *last;
} node[MAXN];
/* -------------------------------- */

/*  添加有向边<起点,终点,边权>  */
void add(int s, int e, int v)
{
    struct Edge *p;
    p = (struct Edge*)malloc(sizeof(struct Edge));
    p->e = e;
    p->v = v;
    p->nxt = NULL;
    if (node[s].head == NULL)
    {
        node[s].head = p;
        node[s].last = p;
    }
    else
    {
        node[s].last->nxt = p;
        node[s].last = p;
    }
}

/*  松弛，成功返回1，否则0  */
int relax(int s, int e, int v)
{
    if (dis[s]+v < dis[e])
    {
        dis[e] = dis[s]+v;
        return 1;
    }
    return 0;
}

/*  SPFA有负权回路返回0,否则返回1并且最短路径保存在dis[]  */
int n;
int vst[MAXN], cnt[MAXN];
int Q[MAXN*MAXN];
int SPFA(int s0)
{
    int i, p, q;
    struct Edge *pp;

    memset(vst, 0, sizeof(vst));
    memset(cnt, 0, sizeof(cnt));
    for (i=0; i<=n; i++)
        dis[i] = INF;
    dis[s0] = 0;

    Q[0] = s0; p = 0; q = 1;
    vst[s0] = 1;
    cnt[s0]++;
    while (p < q)
    {
        pp = node[Q[p]].head;
        while (pp)
        {
            if (relax(Q[p], pp->e, pp->v) && !vst[pp->e])
            {
                Q[q++] = pp->e;
                vst[pp->e] = 1;
                cnt[pp->e]++;
                if (cnt[pp->e] > n) //有负权回路
                    return 0;
            }
            pp = pp->nxt;
        }
        vst[Q[p]] = 0;
        p++;
    }
    return 1;
}

1. /**通过poj 3159 证明：还是用数组来实现邻接表比用链表来实现邻接表效率高，  **/  
2.   
3. #define MAX_node 10000   
4. #define MAX_edge 100000   
5.   
6. struct Edge  
7. {  
8.     int e, v;  
9. } edge[MAX_edge];  
10.   
11. int neg;    //number of edge  
12. int node[MAX_node];  //注意node要用memset初始化全部为-1  
13. int next[MAX_edge];  
14.   
15. void add(int s, int e, int v)  
16. {  
17.     edge[neg].e = e;  
18.     edge[neg].v = v;  
19.     next[neg] = node[s];  
20.     node[s] = neg++;  
21. }  
22. /*  该题还证明用栈来实现SPFA比用队列来实现效率高，还节约空间 */  
23. int SPFA(int s0) //栈实现  
24. {  
25.     int i, t, p, top;  
26.   
27.     memset(vst, 0, sizeof(vst));  
28.     for (i=1; i<=n; i++)  
29.         dis[i] = INF;  
30.     dis[s0] = 0;  
31.   
32.     Q[0] = s0;  
33.     top = 1;  
34.     vst[s0] = 1;  
35.     while (top)  
36.     {  
37.         t = Q[--top];  
38.         vst[t] = 0;  
39.         p = node[t];  
40.         while (p != -1)  
41.         {  
42.             if (relax(t, edge[p].e, edge[p].v) && !vst[edge[p].e])  
43.             {  
44.                 Q[top++] = edge[p].e;  
45.                 vst[edge[p].e] = 1;  
46.             }  
47.             p = next[p];  
48.         }  
49.     }  
50.     return 1;  
51. }