蓝桥杯最短路

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

如下图所示，�G 是一个无向图，其中蓝色边的长度是 11、橘色边的长度是 22、绿色边的长度是 33。

则从 A 到 S 的最短距离是多少？

 解题思路

根据题目给出的图示信息，从顶点 A 到顶点 S 的最短距离可以通过使用最短路径算法来计算

 代码

#include <iostream>
using namespace std;

const int MAX = 20;
int map[MAX][MAX];

void add(char m, char n, int length)
{
    int a = m - 'A';
    int b = n - 'A';
    map[a][b] = map[b][a] = length;
}

void floyd()
{
    for (int i = 0; i < MAX; i++)
    {
        for (int j = 0; j < MAX; j++)
        {
            for (int k = 0; k < MAX; k++)
            {
                if (map[j][k] > map[j][i] + map[i][k])
                {
                    map[j][k] = map[j][i] + map[i][k];
                }
            }
        }
    }
    cout << map[0][18] << endl;
}

int main()
{
    for (int i = 0; i < MAX; i++)
    {
        for (int j = 0; j < MAX; j++)
        {
            if (i == j)
            {
                map[i][j] = 0;
            }
            else
            {
                map[i][j] = 999;
            }
        }
    }

    // 添加图的边
    add('A', 'B', 2);
    add('A', 'C', 1);
    add('A', 'D', 1);
    add('B', 'J', 2);
    add('B', 'G', 1);
    add('C', 'D', 3);
    add('C', 'F', 3);
    add('C', 'G', 3);
    add('D', 'E', 1);
    add('D', 'G', 2);
    add('D', 'H', 1);
    add('D', 'I', 2);
    add('E', 'H', 1);
    add('E', 'I', 3);
    add('F', 'G', 1);
    add('F', 'J', 1);
    add('G', 'F', 1);
    add('G', 'I', 3);
    add('G', 'K', 2);
    add('H', 'I', 1);
    add('H', 'L', 2);
    add('I', 'M', 3);
    add('J', 'S', 2);
    add('K', 'N', 1);
    add('K', 'L', 3);
    add('K', 'P', 2);
    add('L', 'M', 1);
    add('L', 'R', 1);
    add('M', 'N', 2);
    add('M', 'Q', 1);
    add('M', 'S', 1);
    add('N', 'P', 1);
    add('O', 'P', 1);
    add('O', 'Q', 1);
    add('O', 'R', 3);
    add('R', 'S', 1);

    floyd();

    return 0;
}

分析

Floyd算法来计算图中所有节点之间的最短路径。具体来说，它通过三层嵌套循环遍历图中的所有节点，并使用动态规划的方式更新节点间的最短路径长度。

首先，外层循环控制迭代次数，从1到19，表示每次迭代中可以经过的最大节点数。

然后，内层的两个循环分别遍历图中的所有节点，通过比较当前节点经过中间节点k的路径长度是否更短，来更新最短路径的长度。

在每一次迭代中，算法会尝试使用更多的中间节点来找到更短的路径，直到遍历了所有的节点，就可以得到图中任意两个节点之间的最短路径长度。

map[i][j]>map[i][k]+map[k][j]这个条件语句用于比较当前路径的长度是否可以通过经过中间节点k来更新成更短的路径长度。

具体来说，map[i][j]表示节点i到节点j之间的当前最短路径长度，而map[i][k]+map[k][j]表示经过中间节点k的路径长度。

如果map[i][j]大于map[i][k]+map[k][j]，则说明经过节点k的路径长度比当前的最短路径长度还要短，所以需要更新map[i][j]为较小的路径长度map[i][k]+map[k][j]。

通过这个条件语句的判断和更新操作，Floyd算法可以找到图中任意两个节点之间的最短路径长度，并将结果保存在map数组中。

具体的逻辑如下：

• map[j][k]表示目前已知的从节点j到节点k的最短路径长度。
• map[j][i]表示从节点j到节点i的路径长度。
• map[i][k]表示从节点i到节点k的路径长度。

如果map[j][i] + map[i][k]小于当前已知的最短路径长度map[j][k]，就意味着经过节点i的路径比直接从节点j到节点k的路径更短，所以需要更新最短路径长度为map[j][i] + map[i][k]。

这样，通过不断的迭代比较和更新路径长度，最终得到的map矩阵中保存的就是所有节点之间的最短路径。