图的四种最短路径算法

1.迪杰斯特拉算法

int u;
int minx;
for(int i=1;i<=n;i++) dst[i]=edge[1][i];
for(int i=1;i<=n;i++) book[i]=0;//初始化
book[1]=1;
for(int i=1;i<=n-1;i++){
        minx=inf;
    for(int j=1;j<=n;j++){
        if(book[j]==0&&dst[j]<minx){
            minx=dst[j];
            u=j;
        }
    }
    book[u]=1;
    /***更新最短路径***/
    for(int k=1;k<=n;k++){
        if(book[k]==0&&dst[k]>dst[u]+edge[u][k]&&edge[u][k]<inf){
            dst[k]=dst[u]+edge[u][k];
        }
    }
}

算法分析：包含两重循环，时间复杂度为O（n^2）
不允许负权存在

2.Bellman-Ford 算法
为了能够求解边上带有负值的单源最短路问题，Bellman-Ford算法从源点逐次绕过其他顶点，通过松弛操作以缩短到达终点的最短路径方法。

void BellmanFord(MGraph g,int v){
	int i,k,u;
	int dist[MAXV],path[MAXV];
	for(i=0;i<g.n;i++){
		dist[i]=g.edges[v][i];
		if(i!=v&&dist[i]<INF) 
			path[i]=v;
		else path[i]=-1; 
	}
	for(k=1;k<g.n;k++){
		for(u=0;u<g.n;u++){
			if(u!=v){
				for(i=0;i<g.n;i++){
					if(g.edges[i][u]<INF&&dist[u]>dist[i]+g.edges[i][u]){
						dist[u]=dist[i]+g.edges[i][u];
						path[u]=i;
					}
				}
			}
		}
	}
} 

3.SPFA算法
当给定的图存在负权边时迪杰斯特拉不适合，而Bellman-Ford的时间复杂度又太高，这时可以采用SPFA算法，但是它仍然不适合含负权回路的图。

int s;
ALGraph *G;
int dist[MAXV];
int path[MAXV];

void SPFA(){
	ArcNode *p;
	int v,w;
	int visited[MAXV];
	queue<int>qu;
	for(int i=0;i<G->n;i++){
		dist[i]=INF;
		visited[i]=0;
		path[i]=-1;
	}
	dist[s]=0;
	visited[s]=1;
	qu.push(s);
	while(!qu.empty()){
		v=qu.front();qu.pop();
		visited[v]=0;
		p=G->adjlist[v].firstarc;
		while(p!=NULL){
			w=p->adjvex;
			if(dist[w]>dist[v]+p->weight){
				dist[w]=dist[v]+p->weight;
				path[w]=v;
				if(visited[w]==0){
					qu.push(w);
					visited[w]=1;
				} 
			}
			p=p->nextarc;
		}
	}
}

在SPFA算法中，时间复杂度为O（e）。

4.弗洛伊德算法

for(int k=1;k<=n;k++){
     for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(edge[k][j]<inf&&edge[i][k]<inf&&edge[i][j]>edge[i][k]+edge[k][j]){
               edge[i][j]=edge[i][k]+edge[k][j];
            }
        }
     }
 }

和Bellman-Ford 算法一样，弗洛伊德算法在考察顶点k时可能修正所有两个顶点i,j之间的最短路径，所以适合于带有负权值的图，但不适合于含有负权回路的图求最短路径。