检查给定的图中两个节点之间的路径是否表示最短路径

要检查图表的两个中心之间的给定路径是否符合最短路径，可以通过使用可靠的最短路径将沿给定路径的整个边缘权重与相同中心组合之间的最短距离进行比较方式计算，例如 Dijkstra 计算或 Floyd−Warshall 计算。如果给定路径上的所有边权重与最有限的删除相匹配，那么它就代表最简单的路径。另外：如果整个边权重比最短距离更突出，则表明图表中两个中心之间存在较短的距离。

使用的方法

• Dijkstra 算法

• 具有边缘反转成本的 Floyd−Warshall 算法

贪心算法

Dijkstra 的计算可能是一种流行的图表遍历计算，用于发现图表中源中心与所有其他中心之间最有限的路径。在检查两个中心之间的给定路径是否与最有限路径相关的情况下，Dijkstra 的计算可用于计算这些中心之间的最有限间隔。通过从起始枢纽运行 Dijkstra 的计算，我们得到所有其他枢纽的最有限的间隔。如果给定的路线与两个枢纽之间的最有限距离相匹配，那么它就表示一条实质性且最短的路线。其他：如果给定的路线比计算的最短距离长，则表明图表中存在更短的路线。

算法

• 创建最短路径（图形、源、目的地）：

• 初始化一组“过去”来存储去往中心的距离，并初始化一个单词参考间隔来存储最有限的距离。

• 在分隔字典中将源集线器的间隔设置为无限，并将所有其他中心的间隔设置为无限。

• 虽然存在未访问的节点，

• a。选择与分隔词参考距离最小的中心并将其标记为已访问。

• b。对于当前节点的每个邻居集线器：

• 通过将边权重添加到当前节点的距离来计算临时间隔。

• 如果条件间距小于存放间距，则检修距离。

• 如果在分离中从源到目标的最短距离与给定路径长度收支平衡，则返回 true（给定路径表示最短路径）。其他情况，返回 false。

• 此计算利用 Dijkstra 方法来计算最短间隔，然后将从源到目标的最短距离与给定的路径长度进行比较，以确定是否是最短的路径.

示例

#include <iostream>
#include <vector>
#include <queue>
#include <limits>
using namespace std;

const int INF = numeric_limits<int>::max();

bool shortestPath(vector<vector<pair<int, int>>>& graph, int source, int destination, int pathLength) {
    int numNodes = graph.size();
    vector<int> distances(numNodes, INF);
    distances[source] = 0;

    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
    pq.emplace(0, source);

    while (!pq.empty()) {
        int u = pq.top().second;
        int dist = pq.top().first;
        pq.pop();

        if (dist > distances[u])
            continue;

        for (auto& neighbor : graph[u]) {
            int v = neighbor.first;
            int weight = neighbor.second;

            if (dist + weight < distances[v]) {
                distances[v] = dist + weight;
                pq.emplace(distances[v], v);
            }
        }
    }

    return (distances[destination] == pathLength);
}

int main() {
    int numNodes = 6;
    vector<vector<pair<int, int>>> graph(numNodes);

    // Build the graph
    graph[0].emplace_back(1, 2);
    graph[0].emplace_back(2, 5);
    graph[1].emplace_back(3, 4);
    graph[1].emplace_back(4, 1);
    graph[2].emplace_back(3, 2);
    graph[3].emplace_back(4, 3);
    graph[3].emplace_back(5, 6);
    graph[4].emplace_back(5, 2);

    int source = 0;
    int destination = 5;
    int pathLength = 8;

    bool isShortestPath = shortestPath(graph, source, destination, pathLength);

    if (isShortestPath)
        cout << "The given path represents a shortest path." << endl;
    else
        cout << "The given path does not represent a shortest path." << endl;

    return 0;
}

输出

The given path does not represent a shortest path.

具有边缘反转成本的 Floyd−Warshall 算法

Floyd-Warshall 计算是一种动态编程计算，用于发现图表中所有中心对之间的最短路径。在检查两个中心之间的给定路径是否与最有限路径相关的情况下，Floyd-Warshall 计算可用于计算图表中所有中心集之间的最短间隔。通过将计算得到的最短距离与给定路径上的全部边权重进行比较，我们就可以确定给定路径是否涉及最有限的路径。如果整个边权重与最短的间隔相匹配，则此时给定的路径可能是图表中两个中心之间最有限的路径。

算法

• 制作一个测量 numNodes x numNodes 的二维格子，并为所有节点集将其初始化为无限 (INF)。

• 将 dist 的角对角加法设置为 0。

• 对于图表中权重为 w 的每个协调边 (u, v)，将 dist[u][v] 彻底修改为 w，将 dist[v][u] 修改为 w w_reversal，其中 w_reversal 是反转通过边（v，u）的方式获取。

• 在固定循环后执行 Floyd−Warshall 计算：

• 对于从 numNodes 到 1 之间的每个中途集线器，请执行以下操作：

• 对于从 numNodes 到 1 的集线器 i 和 j 的每个聚合，将 dist[i][j] 改进到以下值中的最小值：

• 距离[i][j]

• 距离[i][k]距离[k][j]

• 计算完成后，考虑到边缘反转成本，dist 将包含所有集线器组之间最有限的间隔。

• 要检查两个枢纽（源和目标）之间的给定路线是否为最简短的路线，请将给定路线的长度与距离 [源] [目的地] 进行比较。如果是的话，给定的方式是最有限的方式。

示例

#include <iostream>
#include <vector>
using namespace std;

const int INF = 1e9;

void floydWarshall(vector<vector<int>>& graph, int numNodes) {
    vector<vector<int>> dist(graph); // Distance matrix initialized with the graph

    for (int k = 0; k < numNodes; k++) {
        for (int i = 0; i < numNodes; i++) {
            for (int j = 0; j < numNodes; j++) {
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
            }
        }
    }

    // Printing the shortest distances
    cout << "Shortest distances between all pairs of nodes:" << endl;
    for (int i = 0; i < numNodes; i++) {
        for (int j = 0; j < numNodes; j++) {
            if (dist[i][j] == INF)
                cout << "INF ";
            else
                cout << dist[i][j] << " ";
        }
        cout << endl;
    }
}

int main() {
    int numNodes = 4; // Number of nodes

    // Adjacency matrix representation of the graph with edge weights and edge reversal costs
    vector<vector<int>> graph = {
        {0, 5, INF, 10},
        {INF, 0, 3, INF},
        {INF, INF, 0, 1},
        {INF, INF, INF, 0}
    };

    floydWarshall(graph, numNodes);

    return 0;
}

输出

Shortest distances between all pairs of nodes:
0 5 8 9 
INF 0 3 4 
INF INF 0 1 
INF INF INF 0 

结论

本文探讨了如何检查图表的两个中心之间的给定路径是否代表最有限的路径。它阐明了两种方法：Dijkstra 计算和获取边缘反转的 Floyd-Warshall 计算。 C 中的代码用法说明了这些计算。它还简要说明了计算及其用途。本文旨在帮助读者了解如何在图表中找到最有限的方法，并确定给定的方法是否无疑是最简单的。

以上是检查给定的图中两个节点之间的路径是否表示最短路径的详细内容。更多信息请关注PHP中文网其他相关文章！