《算法笔记》读书记录DAY_48

CHAPTER_10  提高篇(4)——图算法专题

10.4.3Bellman-Ford算法和SPFA算法 

前面已经提到，Dijkstra算法无法解决边权为负值的情况。而Bellman-Ford算法同样可以解决单源最短路径问题，也能处理有负边权的情况。

现在考虑有向图中的环，也就是从某个顶点出发、经过若干个不同的顶点之后可以回到该顶点的情况。而根据环中边的边权之和的正负，可将环分为零环、正环、负环（如下图所示）。图中零环和正环不会影响最短路径的求解，因为零环和正环不能使最短路径更短。而如果有负环，且从源点可以到达，那么就会影响最短路径的求解。

与Dijkstra相同，Bellman-Ford算法设置一个数组d，用来存放从源点到达各个顶点的最短距离。同时Bellman-Ford算法返回一个bool值：如果其中存在从源点可以到达的负环，那么函数返回false；否则，函数返回true，此时数组d中存放的值就是从源点到各顶点的最短路径。

对一个有V个顶点的图，Bellman-Ford算法的思想如下：

对图中的边进行V-1轮操作。每轮都遍历图中所有边，对每条边u->v，如果以u为中介点可以使d[v]更小，即d[u]+length[u->v]<d[v]，那么就令d[v]=d[u]+length[u->v]。此时，如果图中没有从源点可达的负环，那么数组d中的所有值都已经达到最优。因此，只需要在对所有边进行一轮遍历操作，判断是否有某条边u->v仍然满足d[u]+length[u->v]<d[v]，如果有，说明图中有从源点可达的负环，返回false；否则返回true。

使用邻接表实现Bellman-Ford算法的代码如下：

struct node {
	int v,dis;           //v为顶点,dis为边权 
};
vector<node> Adj[maxn];  //邻接表 
int n;                   //顶点数 
int d[maxn];             //起点到各点的最短路径值

bool Bellman(int s) {                              //s为起点 
	fill(d,d+maxn,INF);
	d[s]=0;                                        //初始化d[] 
	//以下为求解数组d的部分
	for(int i=0;i<n-1;i++) {                       //执行n-1轮操作 
		for(int u=0;u<n;u++) {                     //每轮操作都遍历所有的边 
			for(int j=0;j<Adj[u].size();j++) {
				int v=Adj[u][j].v;                 //该条边的顶点
				int dis=Adj[u][j].dis;             //该条边的边权
				if(d[u]+dis<d[v]) {                //以u为顶点可以使d[v]更小 
					d[v]=d[u]+dis;                 //松弛操作 
				}
			}
		}
	}
	//以下为判断负环的代码
	for(int u=0;u<n;u++) {                         //对每条边进行判断 
		for(int j=0;j<Adj[u].size();j++) {
			int v=Adj[u][j].v;                     //该条边的顶点
			int dis=Adj[u][j].dis;                 //该条边的边权
			if(d[u]+dis<d[v]) {                    //如果仍可以被松弛 
				return false;                      //存在负环 
			}
		}
	} 
	return true;                                   //d[]已经达到最优 
}

需要注意的是：

（1）Bellman-Ford算法可以适用于存在负边权的情况，但它仍不能解决图中存在负环的情况，它所能做的是检测到图中负环的存在与否。

（2）上述算法只对d[]进行了操作，至于最短路径pre[]的求解和多标尺最短路径问题，与Dijkstra算法相同，只需对if(d[u]+dis<d[v])部分做修改并且添加else if(d[u]+dis==d[v])部分即可。

虽然Bellman-Ford算法思路很简洁，但是O(VE)的时间复杂度较高。经过思考可以发现，Bellman-Ford算法每轮操作都需要操作所有边，显然其中有很多无意义操作。注意到只有当某个顶点u的d[u]值改变时，从它出发的边的邻接点v的d[v]值才有可能被改变。由此可以进行优化：建立一个队列，每次将队首顶点u取出，然后对从u出发的所有边u->v进行松弛，也就是判断d[u]+dis<d[v]是否成立，若成立则令d[v]=d[u]+dis，于是d[v]获得最优的值，此时如果v不在队列中，就把v加入队列。这样操作直到队列为空(说明图中无源点可达的负环)，或是某个顶点的入队次数超过V-1(说明图中存在从源点可达的负环)。这种优化后的算法称作SPFA。

下面给出邻接表实现的SPFA代码：

vector<node> Adj[maxn];
int n,d[maxn],num[maxn];       //num数组记录顶点入队次数]
bool inq[maxn];                //顶点是否在队列中

bool SPFA(int s) {
	//初始化部分
	fill(inq,inq+maxn,false);
	fill(num,num+maxn,0);
	fill(d,d+maxn,INF);
	//源点入队部分
	queue<int> q;
	q.push(s);                  //起点入队 
	inq[s]=1; 
	num[s]++;                   //起点入队次数加一 
	d[s]=0;
	//主体部分
	while(!q.empty()) {
		int u=q.front();        //队首顶点编号
		q.pop();                //出队 
		inq[u]=0;               //设置u不在队列中
		//遍历u的所有邻接边 
		for(int j=0;j<Adj[u].size();j++) {
			int v=Adj[u][j].v;
			int dis=Adj[u][j].dis;
			//松弛操作 
			if(d[u]+dis<d[v]) {
				d[v]=d[u]+dis;
				if(!inq[v]) {
					q.push(v);           //v入队
					inq[v]=true;         //设置v在队列中 
					num[v]++;            //v的入队次数加一 
					if(num[v]>=n)
						return false;    //有可达负环 
				}
			}
		}             
	}
	return true;                 //无可达负环 
}