图的最短路径问题

1. 无权图的单源最短路径算法（邻接表存储）

(相似于图的遍历的广度优先算法)

typedef int Vertex;
void UnWeighted(LGraph Graph,Vertex S){
    int i;
    ListNode W;
    int Dist[MaxVertexNumber],Path[MaxVertexNumber];//Dist存储到源点S的最短距离，Path存储到源点S路径
    Queue Q;
    Q=CreatQueue(Graph->Nn);
    for(i=0;i<Graph->Nn;i++){
        Dist[i]=Path[i]=-1;   //将Dist和Path初始化为-1
    }
    Dist[S]=0;
    AddQ(Q,S);
    while(!IsEmpty(Q)){
        V=DeleteQ(Q);
        for(W=Graph->G[V].FirstEdge;W;W=W.next){
            if(Dist[W->AdjV]==-1){
                Dist[W->AdjV]=Dist[V]+1;
                Path[W->AdjV]=V;
                AddQ(Q,W->AdjV);
            } 
        }
    }
}

 2.有权图的单源最短路径算法（邻接矩阵存储）

typedef int Vertex;
#define Infinity 10000;
int Dist[VertexMaxNum],Path[VertexMaxNum];
Vertex FindMinDist(MGraph Graph,int Dist[],int Collected[]){
    MinDist=Infinity;
    Vertex V,MinV;
    for(V=0;V<Graph->Nv;V++){
        if(Collected[V]==false && Dist[V]<MinDist){
            MinV=V;
            MinDist=Dist[V];
        }
    }
    if(MinDist<Infinity){
        return MinV;
    }
    else{
        return ERRORS;
    }
}
bool Dijkstra(MGraph Graph,int Dist[],int Path[],Vertex S){
    bool Collected[VertexMaxNum];
    Vertex V,W;
    for(V=0;V<Graph->Nv;V++){
        Dist[V]=Graph->G[S][V];//默认邻接矩阵中不存在的边用INFINITY表示
        Path[V]=-1;
        if(G[S][V]<Infinity){
            Path[V]=S;
        }
        Collected[V]=false;
    }
    Dist[S]=0;
    Collected[S]=true;
    Collected[V]=true;
    while(1){
        V=FindMinDist(Graph,Dist,Collected);
        Collected[V]=true;
        if(V==ERRORS){
            break;
        }
        for(W=0;W<Graph->Nv;W++){
            if(G[V][W]<0) return false;
            if(Graph->G[V][W]<Infinity && Collected[W]==false){
                if(Dist[V]+Graph[V][W]<Dist[W]){
                   Dist[W]=Dist[V]+Graph[V][W];
                   Path[W]=V;
                }   
            }
        }
    }
    return true;
}

上述单源最短路径算法，findMinDist ()，保证了算法的收敛性 

3.有权图多源最短路径算法

1，若有Nv个顶点，将Dijkstra算法调用N遍

2，folyd算法(不能有负值圈)

bool Floyd(MGraph Graph,int Dist[][],Vertex Path[][] ){
    Vertex i,j,k;
    for(i=0;i<Graph->Nv;i++){
        for(j=0;j<Graph->Nv;j++){
            Dist[i][j]=Graph->G[i][j];
            Path[i][j]=-1;
        }
    }
    for(k=0;k<Graph->Nv;k++){
        for(i=0;i<Graph->Nv;i++){
            for(j=0;j<Graph->Nv;j++){
                if(Dist[i][k]+Dist[k][j]<Dist[i][j]){
                    Dist[i][j]=Dist[i][k]+Dist[k][j];
                    if(i==j && Dist[i][j]<0) return false; //有负值，返回错误
                    Path[i][j]=k;
                }
            }
        }
    }
    return true;
}