7.1最短路径问题

最短路径问题的抽象

• 在网络中，求两个不同顶点之间的所有路径中，边的权值之和最小的那一条路径
  • 这条路径就是两点之间的最短路径
  • 第一个顶点为源点
  • 最后一个顶点为终点

问题分类

• 单源最短路径问题：从某固定源点出发，求其到所有其他顶点的最短路径
  • （有向）无权图
  • （有向）有权图
• 多源最短路径问题：求任意两顶点间的最短路径

无权图的单源最短路算法

• 按照递增（非递减）的顺序找到到各个顶点的最短路（BFS）

void Unweighted( Vertex S )
{
     
    Enqueue(S,Q);
    while(!IsEmpty(Q)) {
     
        V = Dequeue(Q);
        for( V 的每个邻接点 W )
            if( dist[W] == -1 ) {
     
                dist[W] = dist[V] + 1;
                path[W] = V;
                Enqueue(W,Q);
            }
    }
}

• T = O(|V|+|E|)

有权图的单源最短路算法

• 不考虑负值圈

• 按照递增（非递减）的顺序找到到各个顶点的最短路

• Dijkstra算法

  • 令S = {源点s + 已经确定了最短路径的顶点v}
  • 对任一未收录的顶点v，定义dist[v]为s到v的最短路径长度，但该路径仅经过S中的顶点。及路径{s->(vi∈S)->v}的最小长度
  • 若路径是按照递增的顺序生成的，则
    • 真正的最短路必须只经过S中的顶点
    • 每次从未收录的顶点中选一个dist最小的收录（贪心）
    • 增加一个v进入S，可能影响另一个w的dist值！

void Dijkstra( Vertex s )
{
     
    while(1) {
     
        V = 未收录顶点中dist最小者;
        if( 这样的v不存在 )
            break;
        collected[V] = true;
        for( V的每个邻接点 W )
            if( collected[W] == false )
                if( dist[V]+E<V,W> < dist[W] ){
     
                    dist[W] = dist[V]+E<V,W>;
                    path[W] = V;
                }
    }
}// 不能解决有负边的情况

• 方法1：直接扫描所有未收录顶点-O(|V|)
  • T = O(|V|^2 + |E|) 对于稠密图效果好
• 方法2：将dist存在最小堆中-O(log|V|)
  • T = O(|E|log|V|) 对稀疏图效果好

多源最短路算法

• 方法1：直接将单源最短路算法调用|V|遍
  • $T=O(|V{|}^3+|E|\ast |V|)$ 对于稀疏图效果好
• 方法2：Floyd算法
  • $T=O(|V{|}^3)$ 对于稠密图效果好
• 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;
                }
}

• 如果图中有负值圈，Floyd算法还能用吗？如何知道图中是否存在负值圈？

• 需要进行简单变换就可以使用Floyd算法

  可以将负值视为某种不可无限重复的路径

  1）检是否有负值圈（检查权重是否有负值，并找出最小负值）

  2）如果有负值圈，对所有非对角元的权重增加最小负值+1（例如最小负值为-10，则所有非对角元的权+11），最小负值变为1.

  3）使用Floyd算法

  4）最短路径及长度：直接输出矩阵中保存的最短路径，并记录该最短路径经过的边个数n，长度等于矩阵中保存的长度减去最短路径经过的边的个数倍的最小负值+1

/* 邻接表存储 - 无权图的单源最短路算法 */
 
/* dist[]和path[]全部初始化为-1 */
void Unweighted ( LGraph Graph, int dist[], int path[], Vertex S )
{
     
    Queue Q;
    Vertex V;
    PtrToAdjVNode W;
     
    Q = CreateQueue( Graph->Nv ); /* 创建空队列, MaxSize为外部定义的常数 */
    dist[S] = 0; /* 初始化源点 */
    AddQ (Q, S);
 
    while( !IsEmpty(Q) ){
     
        V = DeleteQ(Q);
        for ( W=Graph->G[V].FirstEdge; W; W=W->Next ) /* 对V的每个邻接点W->AdjV */
            if ( dist[W->AdjV]==-1 ) {
      /* 若W->AdjV未被访问过 */
                dist[W->AdjV] = dist[V]+1; /* W->AdjV到S的距离更新 */
                path[W->AdjV] = V; /* 将V记录在S到W->AdjV的路径上 */
                AddQ(Q, W->AdjV);
            }
    } /* while结束*/
}

/* 邻接矩阵存储 - 有权图的单源最短路算法 */
 
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) {
     
            /* 若V未被收录，且dist[V]更小 */
            MinDist = dist[V]; /* 更新最小距离 */
            MinV = V; /* 更新对应顶点 */
        }
    }
    if (MinDist < INFINITY) /* 若找到最小dist */
        return MinV; /* 返回对应的顶点下标 */
    else return ERROR;  /* 若这样的顶点不存在，返回错误标记 */
}
 
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];
        if ( dist[V]<INFINITY )
            path[V] = S;
        else
            path[V] = -1;
        collected[V] = false;
    }
    /* 先将起点收入集合 */
    dist[S] = 0;
    collected[S] = true;
 
    while (1) {
     
        /* V = 未被收录顶点中dist最小者 */
        V = FindMinDist( Graph, dist, collected );
        if ( V==ERROR ) /* 若这样的V不存在 */
            break;      /* 算法结束 */
        collected[V] = true;  /* 收录V */
        for( W=0; W<Graph->Nv; W++ ) /* 对图中的每个顶点W */
            /* 若W是V的邻接点并且未被收录 */
            if ( collected[W]==false && Graph->G[V][W]<INFINITY ) {
     
                if ( Graph->G[V][W]<0 ) /* 若有负边 */
                    return false; /* 不能正确解决，返回错误标记 */
                /* 若收录V使得dist[W]变小 */
                if ( dist[V]+Graph->G[V][W] < dist[W] ) {
     
                    dist[W] = dist[V]+Graph->G[V][W]; /* 更新dist[W] */
                    path[W] = V; /* 更新S到W的路径 */
                }
            }
    } /* while结束*/
    return true; /* 算法执行完毕，返回正确标记 */
}

/* 邻接矩阵存储 - 多源最短路算法 */
 
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; /* 算法执行完毕，返回正确标记 */
}