基于 Dijsktra(迪杰斯特拉) 算法的最短路径求值

原创已于 2024-03-03 18:17:13 修改 · 964 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构 #贪心算法

于 2023-12-03 11:35:58 首次发布

数据结构实验专栏收录该内容

2 篇文章

订阅专栏

一、实验目的

1.掌握图的邻接矩阵表示法，掌握采用邻接矩阵表示法创建图的算法。

2.掌握求解最短路径的 Dijsktra 算法。

二、实验内容

问题描述一张地图包括 n 个城市，假设城市间有 m 条路径(有向图)，每条路径的长度已知。给定地图的一个起点城市和终点城市，利用 Dijsktra 算法求出起点到终点之间的最短路径。输入要求多组数据，每组数据有 m+3 行。第一行为两个整数 n 和 m，分别代表城市个数 n 和路径条数 m。第二行有 n 个字符，代表每个城市的名字。第三行到第 m+2 行每行有两个字符 a 和 b 和一个整数 d，代表从城市 a 到城市 b 有一条距离为 d 的路。最后一行为两个字符，代表待求最短路径的城市起点和终点。当 n 和 m 都等于 0 时，输入结束。输出要求每组数据输出 2 行。第 1 行为一个整数，为从起点到终点之间最短路的长度。第 2 行为一串字符串，代表该路径。每两个字符之间用空格隔开。

输入样例

3 3 //三条城市三条边

A B C// 城市的名称

A B 1// 边和权重

B C 1

C A 3

A C// 所求AC最短距离

输出样例

2// 最短路的长度

A B C// 路径

Dijkstra算法的时间复杂度取决于实现方式，但通常是O(V^2)或O((V + E) * log(V))，其中V是顶点数，E是边数。在使用最小堆（优先队列）等数据结构进行优化时，算法的时间复杂度可以降低。

假设读者已了解算法具体过程,下面给出实现代码

1. 图的邻接矩阵存储表示：

#define MVNum 100
#define MaxInt 32767

typedef struct {
    char vex[MVNum];        // 顶点表
    int arcs[MVNum][MVNum]; // 邻接矩阵，权重为整数
    int Vexnum;             // 顶点数
    int arcnum;             // 边数
} AMGraph;

2.对G进行初始化

void initG(AMGraph& G, int n) {
    int Max = numeric_limits<int>::max();// 取较大值代替无穷
    
    // 对邻接矩阵进行初始化
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            G.arcs[i][j] = Max;
        }
    }
}

3.对G进行输入

void inputG(AMGraph& G, int n, int m) {
    // 对城市进行录入
    for (int i = 0; i < n; i++) {
        cin >> G.vex[i];
    }

    initG(G, n);

    // 输入路径信息
    for (int i = 0; i < m; i++) {
        char a, b;
        int d;
        cin >> a >> b >> d;
        int index_a = find(G.vex, G.vex + n, a) - G.vex;// G.vex为起始位置,迭代器获取a的索引
        int index_b = find(G.vex, G.vex + n, b) - G.vex;// G.vex为起始位置,迭代器获取b的索引
        G.arcs[index_a][index_b] = d;
    }


}

3.Dijsktra代码实现过程

void Dijkstra(AMGraph G, int start, int end, int& minDist, vector<int>& path) {
    int Max = numeric_limits<int>::max();// 取较大值代替无穷
    
    vector<int> dist(G.Vexnum, Max); // 用于存储起点到各顶点的最短距离
    vector<bool> visited(G.Vexnum, false); // 记录顶点是否已访问
    vector<int> Path(G.Vexnum, -1); // 记录路径上的前驱节点

    dist[start] = 0;// 起点到起点的距离设为零

    for (int i = 0; i < G.Vexnum; ++i) {
        int minIndex = -1;// 当前阶段找到的最小距离的顶点的索引
        int minDistance = Max;// 最小的距离,初始化为无穷

        // 选取未访问的顶点中距离最小的顶点
        for (int j = 0; j < G.Vexnum; ++j) {
            if (!visited[j] && dist[j] < minDistance) {
                minIndex = j;
                minDistance = dist[j];
            }
        }

        if (minIndex == -1) {
            break; // 所有顶点都被访问过
        }

        visited[minIndex] = true;// 将当前已经访问的节点置为true

        // 更新与选取顶点相邻的顶点的最短距离
        for (int k = 0; k < G.Vexnum; ++k) {
            // 如果顶点 k 未被访问且存在从当前顶点 minIndex 到顶点 k 的边
            if (!visited[k] && G.arcs[minIndex][k] < Max) {
                int newDist = dist[minIndex] + G.arcs[minIndex][k];// 计算从起点经过 minIndex 到达顶点 k 的新路径长度
                if (newDist < dist[k]) {
                    dist[k] = newDist;  // 更新起点到顶点 k 的最短路径长度
                    Path[k] = minIndex;  // 记录顶点 k 在最短路径上的前驱顶点为 minIndex
                }
            }    
        }
    }

    minDist = dist[end];// 记录从起点到终点的最短路径长度
    int vi = end;// vi 为终点 end 在顶点表 vex[] 中的索引
    
    // 从终点开始反向遍历最短路径上的各个顶点
    while (vi != -1) {
        path.push_back(vi);// 将当前顶点 vi 添加到路径中
        vi = Path[vi];  // 获取当前顶点 vi 在最短路径上的前驱顶点的索引
    }
    reverse(path.begin(), path.end()); // 反转路径，使起点到终点的顺序正确
}

完整代码实现

#include <iostream>
#include <climits>
#include <vector>
#include <algorithm>

using namespace std;

#define MVNum 100
#define MaxInt 32767

typedef struct {
    char vex[MVNum];        // 顶点表
    int arcs[MVNum][MVNum]; // 邻接矩阵，权重为整数
    int Vexnum;             // 顶点数
    int arcnum;             // 边数
} AMGraph;

// 对G进行初始化
void initG(AMGraph& G, int n) {
    int Max = numeric_limits<int>::max();// 取较大值代替无穷
    
    // 对邻接矩阵进行初始化
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            G.arcs[i][j] = Max;
        }
    }
}

// 对G进行输入
void inputG(AMGraph& G, int n, int m) {
    // 对城市进行录入
    for (int i = 0; i < n; i++) {
        cin >> G.vex[i];
    }

    initG(G, n);

    // 输入路径信息
    for (int i = 0; i < m; i++) {
        char a, b;
        int d;
        cin >> a >> b >> d;
        int index_a = find(G.vex, G.vex + n, a) - G.vex;// G.vex为起始位置,迭代器获取a的索引
        int index_b = find(G.vex, G.vex + n, b) - G.vex;// G.vex为起始位置,迭代器获取b的索引
        G.arcs[index_a][index_b] = d;
    }


}

void Dijkstra(AMGraph G, int start, int end, int& minDist, vector<int>& path) {
    int Max = numeric_limits<int>::max();// 取较大值代替无穷
    
    vector<int> dist(G.Vexnum, Max); // 用于存储起点到各顶点的最短距离
    vector<bool> visited(G.Vexnum, false); // 记录顶点是否已访问
    vector<int> Path(G.Vexnum, -1); // 记录路径上的前驱节点

    dist[start] = 0;// 起点到起点的距离设为零

    for (int i = 0; i < G.Vexnum; ++i) {
        int minIndex = -1;// 当前阶段找到的最小距离的顶点的索引
        int minDistance = Max;// 最小的距离,初始化为无穷

        // 选取未访问的顶点中距离最小的顶点
        for (int j = 0; j < G.Vexnum; ++j) {
            if (!visited[j] && dist[j] < minDistance) {
                minIndex = j;
                minDistance = dist[j];
            }
        }

        if (minIndex == -1) {
            break; // 所有顶点都被访问过
        }

        visited[minIndex] = true;// 将当前已经访问的节点置为true

        // 更新与选取顶点相邻的顶点的最短距离
        for (int k = 0; k < G.Vexnum; ++k) {
            // 如果顶点 k 未被访问且存在从当前顶点 minIndex 到顶点 k 的边
            if (!visited[k] && G.arcs[minIndex][k] < Max) {
                int newDist = dist[minIndex] + G.arcs[minIndex][k];// 计算从起点经过 minIndex 到达顶点 k 的新路径长度
                if (newDist < dist[k]) {
                    dist[k] = newDist;  // 更新起点到顶点 k 的最短路径长度
                    Path[k] = minIndex;  // 记录顶点 k 在最短路径上的前驱顶点为 minIndex
                }
            }    
        }
    }

    minDist = dist[end];// 记录从起点到终点的最短路径长度
    int vi = end;// vi 为终点 end 在顶点表 vex[] 中的索引
    
    // 从终点开始反向遍历最短路径上的各个顶点
    while (vi != -1) {
        path.push_back(vi);// 将当前顶点 vi 添加到路径中
        vi = Path[vi];  // 获取当前顶点 vi 在最短路径上的前驱顶点的索引
    }
    reverse(path.begin(), path.end()); // 反转路径，使起点到终点的顺序正确
}



int main() {
    int n;// 城市的个数
    int edge;// 有向边
    cin >> n >> edge;

    AMGraph G;// 创建图G
    // 图G参数赋值
    G.Vexnum = n;
    G.arcnum = edge;

    inputG(G, n, edge);

    char start;// 起始目标节点
    char end;// 终止目标节点
    cin >> start >> end;

    int minDist;// 存储目标结点间最短路径
    vector<int> path;// 存储从起点到终点的最短路径上的顶点序列
    int startIndex = find(G.vex, G.vex + n, start) - G.vex;// 迭代器,计算start索引
    int endIndex = find(G.vex, G.vex + n, end) - G.vex;// 迭代器, 计算end索引

    Dijkstra(G, startIndex, endIndex, minDist, path);

    // 输出结果
    cout << minDist << endl;
    for (int i = 0; i < path.size(); ++i) {
        cout << G.vex[path[i]];
        if (i < path.size() - 1) {
            cout << " ";
        }
    }
    cout << endl;

    return 0;
}

运行结果

输入为