spfa

粗略讲讲SPFA算法的原理，SPFA算法是1994年西南交通大学段凡丁提出

是一种求单源最短路的算法，是对Bellman-Ford的一种优化

算法中需要用到的主要变量

int n;  //表示n个点，从1到n标号

int s,t;  //s为源点，t为终点

int d[N];  //d[i]表示源点s到点i的最短路

int p[N];  //记录路径（或者说记录前驱）

queue <int> q;  //一个队列，用STL实现，当然可有手打队列，无所谓

bool vis[N];   //vis[i]=1表示点i在队列中 vis[i]=0表示不在队列中

 

几乎所有的最短路算法其步骤都可以分为两步

1.初始化

2.松弛操作

 

初始化： d数组全部赋值为INF（无穷大）；p数组全部赋值为s（即源点），或者赋值为-1，表示还没有知道前驱

             然后d[s]=0;  表示源点不用求最短路径，或者说最短路就是0。将源点入队；

　　　　（另外记住在整个算法中有顶点入队了要记得标记vis数组，有顶点出队了记得消除那个标记）

核心算法：

队列+松弛操作

读取队头顶点u，并将队头顶点u出队（记得消除标记）；将与点u相连的所有点v进行松弛操作，如果能更新估计值（即令d[v]变小）（同时这个点也就成了被更新点的前驱，记录下来可以方便打印路径）我们用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且 v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。

 

只要最短路径存在，上述SPFA算法必定能求出最小值。

证明：每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。（证毕）

 

判断有无负环：

　　如果某个点进入队列的次数超过N次则存在负环（每个点最多被优化N次）（SPFA无法处理带负环的图）

（不能用入队判断，入队可以超过N次，因此，优化操作也可以超过N*E） 

个人代码（bfs）

<pre name="code" class="cpp">#include <iostream>
#include <queue>
using namespace std;
const int maxn=10010;
queue<int> Q;
int dis[maxn];
bool visit[maxn];
int matrix[maxn][maxn];
int N;
int pre[maxn];
int cnt[maxn];
const int INF=0xfffffff;
bool spfa(){
	dis[1]=0;
	visit[1]=true;
	Q.push(1);
	while(!Q.empty()){
		int cur=Q.front(); Q.pop();
		visit[cur]=false;
		for(int i=1;i<=N;i++){
			if(matrix[cur][i]+dis[cur]<dis[i]){
				dis[i]=matrix[cur][i]+dis[cur];
				pre[i]=cur;
					if(!visit[i]){//只有在能够更新的时候才加入队列，
						//这是一种动态逼近的想法
					cnt[i]++;
					if(cnt[i]>N){
						printf("negative loop\n");
						return false;
					}
					visit[i]=true;
					Q.push(i);
				}
			}
			
		}
	}
	int next=pre[N];
	printf("%d\n",N );
	while(1){
		printf("%d\n",next );
		if(pre[next]==1) break;
		next=pre[next];
	}
	printf("1\n");
	return true;
}
int main(int argc, char const *argv[])
{
	cin>>N;
	for(int i=1;i<=N;i++){
		dis[i]=INF;
		visit[i]=false;
		cnt[i]=0;
		for(int j=1;j<=N;j++){
			matrix[i][j]=INF;
			if(i==j)
				matrix[i][j]=0;
		}
	}
	int M,a,b,c;
	cin>>M;
	for(int i=1;i<=M;i++){
		scanf("%d%d%d",&a,&b,&c);
		matrix[a][b]=matrix[b][a]=c;
	}
	// for(int i=1;i<=N;i++){
	// 	for(int j=1;j<=N;j++){
	// 		printf("%d ",matrix[i][j] );
	// 	}
	// 	printf("\n");
	// }
	spfa();
	printf("%d\n",dis[N]);
	return 0;
}

} 注意

1.int 形式的INF不能大到8个f 0xffffffff最后是-1（由于补码）
2.队列每次加入之前都要标记访问，不然在队友某个点更新的时候，可能会把两个点加入队列（第24行）

3.注意每个点出队的时候要消除标记，因为对于同一个点，可能会有多次入队列（被多次更新）

 

SPFA的两种写法，bfs和dfs，bfs判别负环不稳定，相当于限深度搜索，但是设置得好的话还是没问题的，dfs的话判断负环很快

 

int spfa_bfs(int s)
{
    queue <int> q;
    memset(d,0x3f,sizeof(d));
    d[s]=0;
    memset(c,0,sizeof(c));
    memset(vis,0,sizeof(vis));

    q.push(s);  vis[s]=1; c[s]=1;
    //顶点入队vis要做标记，另外要统计顶点的入队次数
    int OK=1;
    while(!q.empty())
    {
        int x;
        x=q.front(); q.pop();  vis[x]=0;
        //队头元素出队，并且消除标记
        for(int k=f[x]; k!=0; k=nnext[k]) //遍历顶点x的邻接表
        {
            int y=v[k];
            if( d[x]+w[k] < d[y])
            {
                d[y]=d[x]+w[k];  //松弛
                if(!vis[y])  //顶点y不在队内
                {
                    vis[y]=1;    //标记
                    c[y]++;      //统计次数
                    q.push(y);   //入队
                    if(c[y]>NN)  //超过入队次数上限，说明有负环
                        return OK=0;
                }
            }
        }
    }

    return OK;

}

 

DFS(一般不推荐)

int spfa_dfs(int u)
{
    vis[u]=1;
    for(int k=f[u]; k!=0; k=e[k].next)
    {
        int v=e[k].v,w=e[k].w;
        if( d[u]+w < d[v] )
        {
            d[v]=d[u]+w;
            if(!vis[v])
            {
                if(spfa_dfs(v))
                    return 1;
            }
            else
                return 1;
        }
    }
    vis[u]=0;
    return 0;
}