图-最短路径（数据结构）

图的最短路径算法

//迪杰斯特拉算法：求某一顶点到其余各顶点的最短路径

// 弗洛伊德算法：任意一对顶点间的路径

#include <iostream>
using namespace std;
//最短路径

//迪杰斯特拉算法：求某一顶点到其余各顶点的最短路径
void printfPath(int path[],int a){//输出路径算法 
    int stack[maxsize],top=-1;
    while(path[a]!=-1){
        stack[++top]=path[a];
        a=path[a];
    }
    while(top!=-1){
        cout<<stack[top--]<<" ";
    }
    cout<endl;
} 
void Dijkstra(MGraph g,int v,int dist[],int path[]){
    int set[maxsize];
    int k,min;
    for(int i=0;i<g.n;i++){//初始化 
        dist[i]=g.edges[v][i];
        set[i]=0;
        if(g.edges[v][i]<INF){
            path[i]=v;
        }else{
            path[i]=-1;
        }
    }
    set[v]=1;
    path[v]=-1;
    for(int i=0;i<g.n-1;i++){//两层循环 
        min=INF;
        for(int j=0;j<g.n;j++){//找出下一个顶点放入集合 
            if(set[j]==0&&dist[j]<min){
                k=j;
                min=dist[j];
            }
        }
        set[k]=1;
        for(int j=0;j<g.n;j++){//更新最短路径 
            if(set[j]==0&&dist[j]>dist[k]+edges[k][j]){
                dist[j]=dist[k]+edges[k][j];
                path[j]=k;
            }
        }
    }
} 

// 弗洛伊德算法：任意一对顶点间的路径
void printPath(int u,int v,int path[][maxsize]){//输出路径 
    if(path[u][v]==-1){
        cout<<u<<"->"<<v<<endl;
        return;
    }
    else{
        int mid=path[u][v];
        printPath(u,mid,path);
        printPath(mid,v,path);
    }
} 
void Floyd(MGraph g,int path[][maxsize]){//复杂度为N^3; 
    int A[maxsize][naxsize];
    for(int i=i;i<g.n;i++){//对A[][]和path[][]初始化 
        for(int j=0;j<g.n;j++){
            A[i][j]=g.edges[i][j];
            path[i][j]=-1;
        }
    }
    for(int k=0;k<g.n;k++){//三层循环，完成了以K为中间点对所有i,j进行了检测和修改。 
        for(int i=0;i<g.n;i++){
            for(int j=0;j<g.n;j++){
                if(A[i][j]>A[i][k]+A[k][j]){
                    A[i][j]=A[i][K]+A[k][j];
                    path[i][j]=k;
                }
            }
        }
    }
}