用Floyd算法求解最短距离，用Dijkstra算法求点到点的最短路径

用Floyd算法求解最短距离，用Dijkstra算法求点到点的最短路径

1.问题

（1）用Floyd算法求解下图各个顶点的最短距离。写出Floyd算法的伪代码和给出距离矩阵（顶点之间的最短距离矩阵）。

（2）对于下图使用Dijkstra算法求由顶点a到顶点h的最短路径。

2.解析

Floyd算法:

1. 从任意一条单边路径开始。所有两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大。
2. 对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比已知的路径更短。如果是更新它。
3. 把图用邻接矩阵G表示出来，如果从Vi到Vj有路可达，则G[i][j]=d，d表示该路的长度；否则G[i][j]=无穷大。定义一个矩阵D用来记录所插入点的信息，D[i][j]表示从Vi到Vj需要经过的点，初始化D[i][j]=j。把各个顶点插入图中，比较插点后的距离与原来的距离，G[i][j] = min( G[i][j], G[i][k]+G[k][j] )，如果G[i][j]的值变小，则D[i][j]=k。在G中包含有两点之间最短道路的信息，而在D中则包含了最短通路径的信息。
4. 比如，要寻找从V5到V1的路径。根据D，假如D(5,1)=3则说明从V5到V1经过V3，路径为{V5,V3,V1}，如果D(5,3)=3，说明V5与V3直接相连，如果D(3,1)=1，说明V3与V1直接相连。

Dijkstra算法:

1. 通过Dijkstra计算图G中的最短路径时，需要指定起点s(即从顶点s开始计算)。
2. 此外，引进两个集合S和U。S的作用是记录已求出最短路径的顶点(以及相应的最短路径长度)，而U则是记录还未求出最短路径的顶点(以及该顶点到起点s的距离)。
3. 初始时，S中只有起点s；U中是除s之外的顶点，并且U中顶点的路径是”起点s到该顶点的路径”。然后，从U中找出路径最短的顶点，并将其加入到S中；接着，更新U中的顶点和顶点对应的路径。 然后，再从U中找出路径最短的顶点，并将其加入到S中；接着，更新U中的顶点和顶点对应的路径。 … 重复该操作，直到遍历完所有顶点。

3.设计

（1）Floyd算法：

int main()
{
    int i,j,k,m,n;
    int x,y,z;
    scanf("%d%d",&n,&m);
     
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++){
            d[i][j]=max;
            path[i][j]=j;
    }
     
    for(i=1;i<=m;i++) {
            scanf("%d%d%d",&x,&y,&z);
            d[x][y]=z;
            d[y][x]=z;
    }
     
    for(k=1;k<=n;k++)
        for(i=1;i<=n;i++)
            for(j=1;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]=path[i][k];
                }
            }
    for(i=1;i<=n;i++)
        for(j=1;j<=i;j++)
          if (i!=j) printf("%d->%d:%d\n",i,j,d[i][j]);
    int f, en;
    scanf("%d%d",&f,&en);
    while (f!=en) {
        printf("%d->",f);
        f=path[f][en];
    }
    printf("%d\n",en);
    return 0;
}

（2）Dijkstra算法：

void dijkstra(int v0, int map[][100], int parent[], int distance[], int visited[]){
    for (int i = 1; i <= v; i++){
        visited[i] = 0;
        if (map[v0][i] < INFI)
            parent[i] = v0;
        else
            parent[i] = -1;
        distance[i] = map[v0][i];
    }
    visited[v0] = 1; 
    parent[v0] = -1; 

    //dijkstra算法核心
    for (int k = 1; k < v; k++){
        int minDis = INFI; 
        int minIndex = -1;
        for (int i = 1; i <= v; i++) {
            if (!visited[i] && distance[i] < minDis){
                minIndex = i;
                minDis = distance[i];
            }
        }
        if (minIndex == -1)
            break;
        visited[minIndex] = 1; 

        for (int i = 1; i <= v; i++) {
            if (!visited[i] && distance[i] > minDis + map[minIndex][i]) {
                distance[i] = minDis + map[minIndex][i];
                parent[i] = minIndex;
            }
        }
    }
}

结果：