Bell-Ford 算法的改进--SPFA算法

Bellman—Ford算法的时间复杂度比较高，原因在于Bellman—Ford算法要递推n次，每次递推，扫描所有的边，在递推n次的过程中很多判断是多余的，SPFA算法是Bellman—Ford算法的一种队列实现，减少了不必要的冗余判断。

大致流程：用一个队列来进行维护。初始时将源点加入队列。每次从队列中取出一个顶点，并与所有与它相邻的顶点进行松弛，若某个相邻的顶点松弛成功，则将其入队。重复这样的过程直到队列为空时算法结束。

实现过程：（1）取出队列头顶点v，扫描从顶点v发出的每条边，设每条边的终点为u，边的权值为w，如果dist[v]+w

（2）重复执行上述过程直至队列为空。

例题：求顶点0到其他各顶点的最短路径长度，并输出相应的最短路径

                    

测试数据：

输入：

7
0 1 6
0 2 5
0 3 5
1 4 -1
2 1 -2
2 4 1
3 2 -2
3 5 -1
4 6 3
5 6 3
-1 -1 -1

输出：

1          0-3-2-1

3          0-3-2

5          0-3

0          0-3-2-1-4

4          0-3-5

3          0-3-2-1-4-6

#include
#include
#include
#include
#define INF 0x3f3f3f3f
#define MAXN 20
using namespace std;
struct ArcNode///构造邻接表必不可少的就是边结点和表头指针
{
    int to;
    int weight;
    ArcNode *next;
};
ArcNode *list[MAXN];///每个顶点的边链表表头指针
queueQ;
int dist[MAXN];
int inq[MAXN];///判断是否在队列中的标志，避免重复入队
int path[MAXN];
int n;
void SPFA(int src)///source的缩写，表示源点
{
    int i,u;
    ArcNode *temp;
    for(i=0;ito;
            if(dist[u]+temp->weightweight;
                path[v]=u;
                if(!inq[v])
                {
                    Q.push(v);
                    inq[v]++;
                }
            }
            temp=temp->next;
        }
    }
}
int main()
{
    int i,j;
    int u,v,w;
    scanf("%d",&n);
    memset(list,0,sizeof(list));
    ArcNode *temp;
    while(1)
    {
        scanf("%d%d%d",&u,&v,&w);
        if(u==-1&&v==-1&&w==-1)
            break;
        temp=new ArcNode;
        temp->to=v;
        temp->weight=w;
        temp->next=NULL;
        if(list[u]==NULL)
            list[u]=temp;
        else
        {
            temp->next=list[u];
            list[u]=temp;
        }
    }
    SPFA(0);
    for(j=0;jnext;
            delete temp;
            temp=list[j];
        }
    }
    int shortest[MAXN];
    for(i=1;i0;j--)
            printf("%d-",shortest[j]);
        printf("%d\n",shortest[0]);
    }
    return 0;
}