图的最短路和最小生成树

最短路径

Dijkstra 算法

令S={源点s + 已经确定了最短路径的顶点Vi}

对任一未收录的顶点V，定义dist[V]为s到V的最短路径长度，但该路径仅经过S中的顶点。

若路径是按照递增（非递减）的顺序生成的，则

1.真正的最短路径必须只经过S中的顶点。

2.每次从未收录的顶点中选一个dist最小的收录。

3.增加一个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] = ist[V] + E<v,w>;
                    prth[w] = v;
                }
    }
}

示例：

初始化

选择v1作为起点并更新其dist

访问与其相连的点v2,v4，并更新其dist以及上一个节点

自此进入正式算法

将v4标注为被访问过，开始访问v4的邻接点

连接v3并更新

连接v5并更新

连接v6,v7并更新，开始进入下一轮循环

访问v2，对v5更新失败，进入下一轮循环。v4已被访问过，进入下一轮循环

访问v3，并更新v6的信息

访问v5

访问v7，并更新v6

访问v6
所有节点已被访问，算法结束

实现代码：

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] = O; 
    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; /*算法执行完毕，返回正确标记*/
}

Floyd 算法

d（i，j）表示节点i到j最短路径的距离，对于每一个节点k，检查d（i，k）+ d（k，j）小于d(i，j),如果成立，

d（i，j） = d（i，k）+ d（k，j）

bool Floyd(MGraph Graph, Weight Type D[] [ MaxVertexNum], Vertex path[] [ MaxVertex­Num]) 
{
    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] < D)/* 若发现负值圈＊*/
                        return false; /*不能正确解决，返回错误标记*/
                    path[i][j] = k; 
                }
    return true; /*算法执行完毕，返回正确标记*/
}

生成树

Prim算法

最小生成树，图中不能出现回路。

适用于稠密图

伪代码如下:

void Prim()
{
    MST = {s};
    while (1)
    {
        V = 未收录顶点中dist最小者;
        if ( 这样的V不存在 )
            break;
将V收录进MST: dist[V] = 0;
        for ( V 的每个邻接点 W )
            if (  Wdist[W]!= 0未被收录 )
                if ( E(V,W) < dist[W] )
                {
                    dist[W] = E(V,W) ;
                    parent[W] = V;
                }
    }
    if ( MST中收的顶点不到|V|个 )
    	Error ( “生成树不存在”);
}

示例：

在图中寻找一个节点当作起点

在与v1相连的点中寻找权重最小的边进行连接，并将该点（v4）纳入树中

在与已有点（v1,v4）相连的点中寻找权重最小的边进行连接，继续扩大树的的规模（这里先选择v2，在选择v3）

选择v3之后，为避免形成回路，则v1无法选择只能选择v7

之后选择权重为1且与v7相连的点v6

最后选择v5，至此所有的点全被访问过，访问了六条边，树已生成。

Kruskal算法

适用于稀疏图

伪代码如下：

void Kruskal ( Graph G )
{/*将最小生成树板寸为邻接表存储的图MST，返回最小权重和*/
    MST = { } ;/*包含所有顶点但没有边的图*/
    while ( MST 中不到 |V| -1 条边 && E 中还有边 )
    {
        从 E 中取一条权重最小的边 E(v,w) ;/* 引入最小堆完成 */
        将 E(v,w)从 E 中删除；
        if ( E(V,W)不在 MST 中构成回路)   /* 此判断由并查集的Find完成 */
            将 E(V,W)加入 MST;	 	/*此判断由并查集的Union完成*/
        else
            彻底无视 E(V,W);
    }/*结束while*/
    if ( MST 中不到 |V| -1 条边 )
        Error ( “生成树不存在”);
     else return 最小权重和；
}

示例：

Kruskal是将森林合并成树，认为每一个节点都是一棵树，访问所有结点之后将其合并为一棵树

在和访问过程中同样要避免形成回路，每次寻找权重最小的边，在避免形成回路的情况下依次递增。

找出权重最小的边进行访问

权重依次递增

避免形成回路，不选择v4,v1之间，v2,v4之间的路。

生成了六条边，树已生成，程序结束。