一、实验目的
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;
}
运行结果
输入为
3 3
A B C
A B 1
B C 1
C A 3
A C输出
2
A B C
227
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
