最短路径-

 弗洛伊德

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

// 定义图的顶点数
const int N = 100;
// 定义无穷大的初始距离
const int INF = numeric_limits<int>::max();

// 弗洛伊德算法的实现
void floydWarshall(vector<vector<int>>& dist) {
    int n = dist.size();
    // 遍历所有顶点作为中间顶点
    for (int k = 0; k < n; k++) {
        // 遍历所有顶点作为起点
        for (int i = 0; i < n; i++) {
            // 遍历所有顶点作为终点
            for (int j = 0; j < n; j++) {
                // 如果通过顶点k可以找到更短的路径，则更新dist[i][j]
                if (dist[i][k] != INF && dist[k][j] != INF && dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }
    }
}

int main() {
    int n; // 顶点的数量
    cin >> n;

    vector<vector<int>> dist(n, vector<int>(n, INF)); // 初始化距离矩阵

    // 读取邻接矩阵
    for (int i = 0; i < n; i++) {
        dist[i][i] = 0; // 自己到自己的距离是0
        for (int j = i; j < n; j++) {
            int w;
            cin >> w;
            dist[i][j] = w;
            dist[j][i] = w; // 如果是无向图，需要设置对称的权重
        }
    }

    // 执行弗洛伊德算法
    floydWarshall(dist);

    // 打印所有顶点对之间的最短路径
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (dist[i][j] == INF) {
                cout << "INF" << " ";
            } else {
                cout << dist[i][j] << " ";
            }
        }
        cout << endl;
    }

    return 0;
}

   迪杰斯特拉算法

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

const int INF = numeric_limits<int>::max(); // 定义无穷大

// 迪杰斯特拉算法的实现
void dijkstra(const vector<vector<pair<int, int>>>& graph, int start) {
    int n = graph.size(); // 图的顶点数
    vector<int> dist(n, INF); // 保存从起点到每个顶点的最短距离
    vector<bool> visited(n, false); // 标记顶点是否已被访问
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq; // 优先队列，用于选择当前距离最小的顶点

    // 初始化起点
    dist[start] = 0;
    pq.push({0, start});

    while (!pq.empty()) {
        int u = pq.top().second; // 当前距离最小的顶点
        pq.pop();

        if (visited[u]) continue; // 如果该顶点已被访问，则跳过
        visited[u] = true; // 标记该顶点为已访问

        // 遍历顶点u的所有邻接顶点
        for (const auto& edge : graph[u]) {
            int v = edge.first; // 邻接顶点
            int weight = edge.second; // 边的权重

            // 如果通过顶点u到达顶点v的路径更短，则更新dist[v]
            if (dist[u] + weight < dist[v]) {
                dist[v] = dist[u] + weight;
                pq.push({dist[v], v}); // 将更新后的顶点v加入优先队列
            }
        }
    }

    // 输出从起点到每个顶点的最短距离
    for (int i = 0; i < n; i++) {
        if (dist[i] == INF) {
            cout << "Vertex " << i << " is unreachable from " << start << endl;
        } else {
            cout << "Shortest distance from " << start << " to " << i << " is " << dist[i] << endl;
        }
    }
}

int main() {
    int n, m; // 顶点数和边数
    cin >> n >> m;

    vector<vector<pair<int, int>>> graph(n); // 邻接表表示图

    // 读取图的边
    for (int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        graph[u].push_back({v, w}); // 无向图时还需要添加 graph[v].push_back({u, w});
    }

    int start; // 起点
    cin >> start;

    // 执行迪杰斯特拉算法
    dijkstra(graph, start);

    return 0;
}