单源最短路径Dijkstra算法，多源最短路径Floyd算法

1.单源最短路径

（1）无权图的单源最短路径

/*无权单源最短路径*/
void UnWeighted(LGraph Graph, Vertex S)
{
    std::queue<Vertex> Q;
    Vertex V;
    PtrToAdjVNode W;
    Q.push(S);
    while (!Q.empty())
    {
        V = Q.front();
        Q.pop();
        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;
            Q.push(W->AdjV);
        }

    }

}

函数：返回还未被收录顶点中dist最小者

Vertex FindMinDist(MGraph Graph, int dist[], int collected[])
{
    /*返回未被收录顶点中dist最小者*/
    Vertex MinV, V;
    int MinDist = INFINITY;


    for (V = 0; V < Graph->Nv; ++V)
    {
        if (collected[V] == false && dist[V] < MinDist)
        {
            MinDist = dist[V];
            MinV = V;                //更新对应顶点
        }
    }
    if (MinDist < INFINITY)            //若找到最小值
        return MinV;
    else
        return -1;
}

（2）有权图的单源最短路径
单源最短路径Dijkstra算法

/*单源最短路径Dijkstra算法*/
/*dist数组存储起点到这个顶点的最小路径长度*/
bool Dijkstra(MGraph Graph, int dist[], int path[], Vertex S)
{
    int collected[MaxVertexNum];
    Vertex V, W;

    /*初始化，此处默认邻接矩阵中不存在的边用INFINITY表示*/
    for (V = 0; V < Graph->Nv; V++)
    {
        dist[V] = Graph->G[S][V];            //用S顶点对应的行向量分别初始化dist数组
        if (dist[V] < INFINITY)                //如果(S, V)这条边存在
            path[V] = S;                //将V顶点的父节点初始化为S
        else
            path[V] = -1;                //否则初始化为-1
        collected[V] = false;            //false表示这个顶点还未被收入集合
    }


    /*现将起点S收录集合*/
    dist[S] = 0;                //S到S的路径长度为0
    collected[S] = true;

    while (1)
    {
        V = FindMinDist(Graph, dist, collected);    //V=未被收录顶点中dist最小者
        if (V == -1)        //如果这样的V不存在
            break;
        collected[V] = true;        //将V收录进集合
        for (W = 0; W < Graph->Nv; W++)        //对V的每个邻接点
        {
            /*如果W是V的邻接点且未被收录*/
            if (collected[W] == false && Graph->G[V][W] < INFINITY)
            {
                if (Graph->G[V][W] < 0)        //若有负边，不能正常解决，返回错误标记
                    return false ;
                if (dist[W] > dist[V] + Graph->G[V][W])
                {
                    dist[W] = dist[V] + Graph->G[V][W];        //更新dist[W]
                    path[W] = V;            //更新S到W的路径
                }
            }
        }
    }
    return true;
}

 2.多源最短路径Floyd算法

/*多源最短路径*/
bool Floyd(MGraph Graph, WeightType D[][MaxVertexNum], Vertex path[][MaxVertexNum])
{
    Vertex i, j, k;

    /*初始化*/
    for (i = 0; i < Graph->Nv; i++)
    for (j = 0; j < Graph->Nv; j++)
    {
        D[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 (D[i][k] + D[k][j] < D[i][j])
            D[i][j] = D[i][k] + D[k][j];
        if (i == j && D[i][j] < 0)        //若发现负值圈，不能正常解决，返回错误标记
            return false;
        path[i][j] = k;
    }
    return true;        //算法执行完毕，返回正确标记
}