最短路径 Dijkstra算法 AND Floyd算法

无权单源最短路：直接广搜

void Unweighted ( vertex s)
{
    queue <int> Q;
    Q.push( S );
    while( !Q.empty() )
    {
        V = Q.front();
        Q.pop();
        for( each W adjacent to V )
        {
            if( dist[W] == -1 )
            {
                dist[W] = dist[V] + 1;
                path[W] = V;
                Q.push( W );
            }
        }
    }
}
dist[W] = S ---- W of MinDist;
dist[S] = 0;
path[W] = S ---> W of vertex

Dijkstra算法思路：有权单源最短路

void Dijkstra ( )
{
    while( 1 )
    {
        V = smallest unknow distance vertex;   //未收录顶点中dist最小者
        if( no  V )                            //V不存在
            break;

        collected[V] = true;                   //收录
        for( each W adjacent to V )            //V的每个邻接点W
        {
            if( collected[W] == false )        //如果未收录
            {
                if( dist[V] + E(V, W) < dist[W] )
                {                              //路径变短，更新一下
                    dist[W] = dist[V] + E(V, W);
                    path[W] = V;               //path记录路径
                }
            }
        }
    }
}

Floyd算法思路：多源最短路，不过因为其代码简单，在时间要求宽松时求给定两点的最短路也可以用Floyd算法

void Floyd ( )
{
    for( i=0; i<n; i++ )
    {
        for( j=0; j<n; j++ )
        {
            D[i][j] = G[i][j];
            path[i][j] = -1;
        }
    }
    for( k=0; k<n; k++ )
    {
        for( i=0; i<n; i++ )
        {
            for( j=0; j<n; j++ )
            {
                if( D[i][k] + D[k][j] < D[i][j] )
                {
                    D[i][j] = D[i][k] + D[k][j];
                    path[i][j] = k;
                }
            }
        }
    }
}