【問題の説明】
実際の南京のバス路線図に従って、南京の主要なバス路線図の保管構造が確立されています。
【基本的な要件】
(1) 任意の停留所を 2 つ入力し、乗り換え回数が最も少ないバス路線を教えてください。
(2) 任意の駅を 2 つ入力し、通過する駅の数が最も少ないバス路線を答えてください。
この質問の実用性は比較的高く、それを実現するにはファイルから大量のデータを読み取る必要があります。ファイルの内容 (一部) を次の図に示します。
大量のデータから見ても、この質問は依然として比較的難しいことがわかります。この問題に対する私の解決策は次のとおりです。
グラフを使用したいので、まずどのデータをグラフ上のノードとして使用するかを検討する必要があります。操作は任意の 2 つのサイトで実行されるため、ここでのノードは各サイトになります。ここでは、隣接リストのデータ構造を使用してグラフを構築します。サイトごとに、その名前とサイト番号 (作成順にコーディング)を保存する必要があります。もちろん、最初のステップはファイルを開くことであり、テキスト ファイルを開いた後、データを 1 行ずつ順番に読み取り、データを処理します (このステップは難しくありませんが、面倒で注意と忍耐が必要です)。
以上が基本的な操作で、次は考えるところです。まず、この質問には 2 つの質問があり、これら 2 つの質問は本質的には最短経路を見つけることに関連していますが、「最短経路」の意味は異なります。最初の質問は乗り換え回数が最も少ない距離を指し、2 番目の質問は停車駅が最も少ない距離を指します。したがって、 2 つの隣接リストを作成する必要があります。最初の隣接テーブル G1 では、エッジを次のように定義します:同じバス ライン上の 2 点間にエッジがある(ここでは各エッジの重みは 1)、2 番目の隣接テーブル G2 では、エッジを次のように定義します:は 2 つの隣接するステーション間のエッジです。これが 2 つのグラフの主な違いで、使用される構造は同じですが、隣接リストを確立する際のエッジの処理が異なります。
次に、最短経路を見つけるにはどうすればよいでしょうか? 誰もがダイクストラ アルゴリズムを思い浮かべると思います。これは、単一のソースから最短パスを見つけるための古典的で広く使用されているアルゴリズムです (知らない人のために、詳細な説明については私の以前の記事を参照してください)。ここでは、隣接する点の重みを 1 とみなし、ダイクストラのアルゴリズムを使用して、任意の駅から他の駅までの最短距離を見つけます。この「最短距離」は、最初の質問では乗り換え回数が最も少ない距離を指し、2 番目の質問では停車回数が最も少ない距離を指します。
もう 1 つ注意すべきことは、一般的なダイクストラ アルゴリズムは 3 つの補助配列のみを使用することです。Adjvex は始点駅から特定の駅まで通過する駅の数を格納します。Lowcost は始点駅から特定の駅までの最短距離を格納します。フラグサイトが選択されているかどうかをマークするために使用されます (0 に初期化されます)。今回の質問では、乗り換えルートを調べるために、始発駅からある駅までのルートを保存するルートを追加しました。
私のコードは次のとおりです:
1. 2 つの隣接リストを作成します。
# include <iostream>
# include <string>
# include <string.h>
# include <fstream>
# include <vector>
# define SIZE 6000
# define NEWSIZE 1024
# define Infinity 100000000 //表示无限大
using namespace std;
typedef struct SiteArcNode //边的结点（站点）结构类型
{
int adjvex; //该边的站点编号
int path; //站点所在的路线
struct SiteArcNode* nextarc; //指向下一条边的指针
}SiteArcNode;
typedef struct SiteVexNode //站点结构
{
int num; //站点编号（从0开始）
char name[50]; //站点名称
SiteArcNode* firstarc; //指向第一条与该站点有关的边的指针
}SiteVexNode;
typedef struct SiteGraph //站点的邻接表结构类型
{
SiteVexNode* SVNode; //定义邻接表
int vexnum; //站点数
int size; //邻接表的大小
}SiteGraph;
//这里的最短距离可以指经过站点最少的距离，也可以指转车次数最少的距离
int* Route; //从起始站点到达某站点会经过的路线
int* Adjvex; //从起始站点到达某站点会经过的站点编号
int* Lowcost; //从起始站点到某站点的最短距离
int* Flag; //标注站点是否已被选中（初始化为0）
void Create(SiteGraph& G1, SiteGraph& G2); //创建两张图（G1：连接同一路线上的站点；G2：连接相邻站点）
void Dijkstra(SiteGraph G1, int v); //迪杰斯特拉算法求单源最短路线
void Find_Route(SiteGraph G1); //对任意两站点，给出转车次数最少的乘车路线
void Find_Site(SiteGraph G2); //对任意两站点，给出经过站点最少的乘车路线
//主函数
int main()
{
SiteGraph G1, G2;
Create(G1, G2);
//动态创建辅助数组
Adjvex = (int*)malloc((G1.vexnum + 10) * sizeof(int));
Route = (int*)malloc((G1.vexnum + 10) * sizeof(int));
Lowcost = (int*)malloc((G1.vexnum + 10) * sizeof(int));
Flag = (int*)malloc((G1.vexnum + 10) * sizeof(int));
cout << "（1）输入任意两站点，给出转车次数最少的乘车路线" << endl;
Find_Route(G1);
cout << endl;
for (int i = 0; i < 120; i++) {
cout << "*";
}
cout << endl << endl;
cout << "（2）输入任意两站点，给出经过站点最少的乘车路线" << endl;
Find_Site(G2);
return 0;
}
//创建图
void Create(SiteGraph& G1, SiteGraph& G2)
{
fstream file;
string s;
G1.SVNode = (SiteVexNode*)malloc(SIZE * sizeof(SiteVexNode));
G2.SVNode = (SiteVexNode*)malloc(SIZE * sizeof(SiteVexNode));
G1.size = SIZE;
G2.size = SIZE;
G1.vexnum = 0;
G2.vexnum = 0;
file.open("南京公交线路.txt", ios::in);
if (file.fail()) {
cout << "文件打开失败" << endl;
exit(0);
}
int f = 1;
int x = 0;
getline(file, s);
while (f) {
if (file.eof()) {
f = 0;
}
int t = 1, a = 0, k = 0;
vector<int>M; //保存这条线路上的所有站点编号
char site[100];
for (int i = 0; i <= s.size(); i++) {
if (s[i] == ' ') {
t = 0;
}
else if (t && (s[i] >= 48 && s[i] <= 57)) {
a = a * 10 + s[i] - 48;
}
else if (!t) {
//开始处理站点数据
if (s[i] == ',' || i == s.size()) {
//遇到“,”说明一个站点已输入完毕，建立该站点的结点
site[k] = '\0';
k = 0;
int t1 = 1;
int n; //当前站点的编号
for (int j = 0; j < G2.vexnum; j++) {
//先查看该站点是否已建立头结点
if (strcmp(G2.SVNode[j].name, site) == 0) {
t1 = 0; //该站点已建立头结点，t1标注为0
n = j; //n=当前站点的编号
break;
}
}
if (t1) {
//该站点未建立头结点
if (G1.size <= G1.vexnum) {
//根据点的个数动态分配空间
G1.SVNode = (SiteVexNode*)realloc(G1.SVNode, (G1.size + NEWSIZE) * sizeof(SiteVexNode));
G1.size += NEWSIZE;
}
if (G2.size <= G2.vexnum) {
//根据点的个数动态分配空间
G2.SVNode = (SiteVexNode*)realloc(G2.SVNode, (G2.size + NEWSIZE) * sizeof(SiteVexNode));
G2.size += NEWSIZE;
}
strcpy(G1.SVNode[G1.vexnum].name, site); //头结点名称
strcpy(G2.SVNode[G2.vexnum].name, site); //头结点名称
G1.SVNode[G1.vexnum].num = G1.vexnum; //头结点编号
G2.SVNode[G2.vexnum].num = G2.vexnum; //头结点编号
G1.SVNode[G1.vexnum].firstarc = NULL;
G2.SVNode[G2.vexnum].firstarc = NULL;
n = G2.vexnum; //n=当前站点的编号
G1.vexnum++;
G2.vexnum++;
}
if (!M.empty()) {
//如果不是这条线路上的第一个站点
SiteArcNode* p, * q;
//不是第一个站点，G1表要与这条线路上的所有站点建立连接
for (int j = 0; j < M.size(); j++) {
//当前站点加入到前面所有站点的链表中
p = (SiteArcNode*)malloc(sizeof(SiteArcNode)); //创建一个用于存放当前边的结点p
p->nextarc = NULL;
p->adjvex = n;
p->path = a; //保存这条边所在的线路
q = G1.SVNode[M[j]].firstarc;
//将边按顺序插入到链表末尾
if (q == NULL) {
G1.SVNode[M[j]].firstarc = p;
}
else {
while (q->nextarc != NULL) {
q = q->nextarc;
}
q->nextarc = p;
}
//前面所有站点加入到当前站点的链表中
p = (SiteArcNode*)malloc(sizeof(SiteArcNode)); //创建一个用于存放当前边的结点p
p->nextarc = NULL;
p->adjvex = M[j];
p->path = a; //保存这条边所在的线路
q = G1.SVNode[n].firstarc; //前一个站点加入到当前站点的链表中
//将边按顺序插入到链表末尾
if (q == NULL) {
G1.SVNode[n].firstarc = p;
}
else {
while (q->nextarc != NULL) {
q = q->nextarc;
}
q->nextarc = p;
}
}
//不是第一个站点，G2表要与前后站点建立连接
int m = M[M.size() - 1];
p = (SiteArcNode*)malloc(sizeof(SiteArcNode)); //创建一个用于存放当前边的结点p
p->nextarc = NULL;
p->adjvex = n;
p->path = a;
q = G2.SVNode[m].firstarc; //当前站点加入到前一个站点的链表中
//将边按顺序插入到链表末尾
if (q == NULL) {
G2.SVNode[m].firstarc = p;
}
else {
while (q->nextarc != NULL) {
q = q->nextarc;
}
q->nextarc = p;
}
p = (SiteArcNode*)malloc(sizeof(SiteArcNode)); //创建一个用于存放当前边的结点p
p->nextarc = NULL;
p->adjvex = m;
p->path = a;
q = G2.SVNode[n].firstarc; //前一个站点加入到当前站点的链表中
//将边按顺序插入到链表末尾
if (q == NULL) {
G2.SVNode[n].firstarc = p;
}
else {
while (q->nextarc != NULL) {
q = q->nextarc;
}
q->nextarc = p;
}
}
M.push_back(n);
}
else {
site[k] = s[i];
k++;
}
}
}
if (f) {
getline(file, s);
}
}
file.close();
}
2. 質問1と質問2を解く
void Dijkstra(SiteGraph G, int v) //迪杰斯特拉算法求单源最短路线
{
Lowcost[v] = 0; //初始站点到初始站点的距离为0
Flag[v] = 1; //标注初始点
int num = 1; //记录目前被选中的站点数目
SiteArcNode* p;
while (num < G.vexnum) {
p = G.SVNode[v].firstarc; //p为新选中的点的第一个邻接点
while (p != NULL) {
//由于新点加入，更新起始点与其余未被选中的顶点之间的距离
if (!Flag[p->adjvex] && Lowcost[p->adjvex] > Lowcost[v] + 1) {
Lowcost[p->adjvex] = Lowcost[v] + 1;
Adjvex[p->adjvex] = v;
Route[p->adjvex] = p->path; //保存该站点所在的路线
}
p = p->nextarc;
}
int min = Infinity;
for (int i = 1; i <= G.vexnum; i++) {
//从未选择的站点中找下一个与起始站点距离最近的站点
if (!Flag[i] && Lowcost[i] < min) {
min = Lowcost[i];
v = i; //更新v为目前与起始站点距离最近的站点
}
}
Flag[v] = 1; //标记新选中的站点
num++; //目前被选中的站点数目+1
}
}
void Print_Path(SiteGraph G, int v1, int v2, string s1) //打印路线
{
cout << "路径为：" << endl;
int j = v2;
vector<int>Path;
while (j != v1) {
Path.push_back(j);
j = Adjvex[j];
}
int k = Route[Path[Path.size() - 1]];
cout << k << "路：" << s1;
for (int i = Path.size() - 1; i >= 0; i--) {
if (Route[Path[i]] != k) {
k = Route[Path[i]];
cout << "\n换乘到" << k << "路：" << G.SVNode[Path[i + 1]].name;
}
cout << "->" << G.SVNode[Path[i]].name;
}
cout << endl;
}
void Find_Route(SiteGraph G) //对任意两站点，给出转车次数最少的乘车路线
{
string s1, s2;
int v1, v2;
cout << "请输入第一个站点：";
cin >> s1;
cout << "请输入第二个站点：";
cin >> s2;
for (int i = 0; i < G.vexnum; i++) {
if (G.SVNode[i].name == s1) {
v1 = i;
}
if (G.SVNode[i].name == s2) {
v2 = i;
}
}
for (int i = 1; i <= G.vexnum; i++) {
//初始化
Adjvex[i] = v1;
Route[i] = 0;
Lowcost[i] = Infinity;
Flag[i] = 0;
}
Dijkstra(G, v1); //求从站点v1出发到站点v2的换乘次数最少的乘车路线
cout << endl;
cout << s1 << " 到 " << s2 << " 的换乘次数最少为" << Lowcost[v2] - 1 << " "; //换乘次数要减1
//输出起始点到站点v2的最少转车路径
Print_Path(G, v1, v2, s1);
}
void Find_Site(SiteGraph G) //对任意两站点，给出经过站点最少的乘车路线
{
string s1, s2;
int v1, v2;
cout << "请输入第一个站点：";
cin >> s1;
cout << "请输入第二个站点：";
cin >> s2;
for (int i = 0; i < G.vexnum; i++) {
if (G.SVNode[i].name == s1) {
v1 = i;
}
if (G.SVNode[i].name == s2) {
v2 = i;
}
}
for (int i = 1; i <= G.vexnum; i++) {
//初始化
Adjvex[i] = v1;
Route[i] = 0;
Lowcost[i] = Infinity;
Flag[i] = 0;
}
Dijkstra(G, v1); //求从站点v1出发到站点v2的经过站点最少的乘车路线
//输出起始站点到站点v2的最短距离
cout << endl;
cout << s1 << " 到 " << s2 << " 的经过站点次数最少为" << Lowcost[v2] + 1 << " ";
//输出起始点到站点v2的最少转车路径
Print_Path(G, v1, v2, s1);
}
完全なコード:
# include <iostream>
# include <string>
# include <string.h>
# include <fstream>
# include <vector>
# define SIZE 6000
# define NEWSIZE 1024
# define Infinity 100000000 //表示无限大
using namespace std;
typedef struct SiteArcNode //边的结点（站点）结构类型
{
int adjvex; //该边的站点编号
int path; //站点所在的路线
struct SiteArcNode* nextarc; //指向下一条边的指针
}SiteArcNode;
typedef struct SiteVexNode //站点结构
{
int num; //站点编号（从0开始）
char name[50]; //站点名称
SiteArcNode* firstarc; //指向第一条与该站点有关的边的指针
}SiteVexNode;
typedef struct SiteGraph //站点的邻接表结构类型
{
SiteVexNode* SVNode; //定义邻接表
int vexnum; //站点数
int size; //邻接表的大小
}SiteGraph;
//这里的最短距离可以指经过站点最少的距离，也可以指转车次数最少的距离
int* Route; //从起始站点到达某站点会经过的路线
int* Adjvex; //从起始站点到达某站点会经过的站点编号
int* Lowcost; //从起始站点到某站点的最短距离
int* Flag; //标注站点是否已被选中（初始化为0）
void Create(SiteGraph& G1, SiteGraph& G2); //创建两张图（G1：连接同一路线上的站点；G2：连接相邻站点）
void Dijkstra(SiteGraph G1, int v); //迪杰斯特拉算法求单源最短路线
void Find_Route(SiteGraph G1); //对任意两站点，给出转车次数最少的乘车路线
void Find_Site(SiteGraph G2); //对任意两站点，给出经过站点最少的乘车路线
//主函数
int main()
{
SiteGraph G1, G2;
Create(G1, G2);
//动态创建辅助数组
Adjvex = (int*)malloc((G1.vexnum + 10) * sizeof(int));
Route = (int*)malloc((G1.vexnum + 10) * sizeof(int));
Lowcost = (int*)malloc((G1.vexnum + 10) * sizeof(int));
Flag = (int*)malloc((G1.vexnum + 10) * sizeof(int));
cout << "（1）输入任意两站点，给出转车次数最少的乘车路线" << endl;
Find_Route(G1);
cout << endl;
for (int i = 0; i < 120; i++) {
cout << "*";
}
cout << endl << endl;
cout << "（2）输入任意两站点，给出经过站点最少的乘车路线" << endl;
Find_Site(G2);
return 0;
}
//创建图
void Create(SiteGraph& G1, SiteGraph& G2)
{
fstream file;
string s;
G1.SVNode = (SiteVexNode*)malloc(SIZE * sizeof(SiteVexNode));
G2.SVNode = (SiteVexNode*)malloc(SIZE * sizeof(SiteVexNode));
G1.size = SIZE;
G2.size = SIZE;
G1.vexnum = 0;
G2.vexnum = 0;
file.open("南京公交线路.txt", ios::in);
if (file.fail()) {
cout << "文件打开失败" << endl;
exit(0);
}
int f = 1;
int x = 0;
getline(file, s);
while (f) {
if (file.eof()) {
f = 0;
}
int t = 1, a = 0, k = 0;
vector<int>M; //保存这条线路上的所有站点编号
char site[100];
for (int i = 0; i <= s.size(); i++) {
if (s[i] == ' ') {
t = 0;
}
else if (t && (s[i] >= 48 && s[i] <= 57)) {
a = a * 10 + s[i] - 48;
}
else if (!t) {
//开始处理站点数据
if (s[i] == ',' || i == s.size()) {
//遇到“,”说明一个站点已输入完毕，建立该站点的结点
site[k] = '\0';
k = 0;
int t1 = 1;
int n; //当前站点的编号
for (int j = 0; j < G2.vexnum; j++) {
//先查看该站点是否已建立头结点
if (strcmp(G2.SVNode[j].name, site) == 0) {
t1 = 0; //该站点已建立头结点，t1标注为0
n = j; //n=当前站点的编号
break;
}
}
if (t1) {
//该站点未建立头结点
if (G1.size <= G1.vexnum) {
//根据点的个数动态分配空间
G1.SVNode = (SiteVexNode*)realloc(G1.SVNode, (G1.size + NEWSIZE) * sizeof(SiteVexNode));
G1.size += NEWSIZE;
}
if (G2.size <= G2.vexnum) {
//根据点的个数动态分配空间
G2.SVNode = (SiteVexNode*)realloc(G2.SVNode, (G2.size + NEWSIZE) * sizeof(SiteVexNode));
G2.size += NEWSIZE;
}
strcpy(G1.SVNode[G1.vexnum].name, site); //头结点名称
strcpy(G2.SVNode[G2.vexnum].name, site); //头结点名称
G1.SVNode[G1.vexnum].num = G1.vexnum; //头结点编号
G2.SVNode[G2.vexnum].num = G2.vexnum; //头结点编号
G1.SVNode[G1.vexnum].firstarc = NULL;
G2.SVNode[G2.vexnum].firstarc = NULL;
n = G2.vexnum; //n=当前站点的编号
G1.vexnum++;
G2.vexnum++;
}
if (!M.empty()) {
//如果不是这条线路上的第一个站点
SiteArcNode* p, * q;
//不是第一个站点，G1表要与这条线路上的所有站点建立连接
for (int j = 0; j < M.size(); j++) {
//当前站点加入到前面所有站点的链表中
p = (SiteArcNode*)malloc(sizeof(SiteArcNode)); //创建一个用于存放当前边的结点p
p->nextarc = NULL;
p->adjvex = n;
p->path = a; //保存这条边所在的线路
q = G1.SVNode[M[j]].firstarc;
//将边按顺序插入到链表末尾
if (q == NULL) {
G1.SVNode[M[j]].firstarc = p;
}
else {
while (q->nextarc != NULL) {
q = q->nextarc;
}
q->nextarc = p;
}
//前面所有站点加入到当前站点的链表中
p = (SiteArcNode*)malloc(sizeof(SiteArcNode)); //创建一个用于存放当前边的结点p
p->nextarc = NULL;
p->adjvex = M[j];
p->path = a; //保存这条边所在的线路
q = G1.SVNode[n].firstarc; //前一个站点加入到当前站点的链表中
//将边按顺序插入到链表末尾
if (q == NULL) {
G1.SVNode[n].firstarc = p;
}
else {
while (q->nextarc != NULL) {
q = q->nextarc;
}
q->nextarc = p;
}
}
//不是第一个站点，G2表要与前后站点建立连接
int m = M[M.size() - 1];
p = (SiteArcNode*)malloc(sizeof(SiteArcNode)); //创建一个用于存放当前边的结点p
p->nextarc = NULL;
p->adjvex = n;
p->path = a;
q = G2.SVNode[m].firstarc; //当前站点加入到前一个站点的链表中
//将边按顺序插入到链表末尾
if (q == NULL) {
G2.SVNode[m].firstarc = p;
}
else {
while (q->nextarc != NULL) {
q = q->nextarc;
}
q->nextarc = p;
}
p = (SiteArcNode*)malloc(sizeof(SiteArcNode)); //创建一个用于存放当前边的结点p
p->nextarc = NULL;
p->adjvex = m;
p->path = a;
q = G2.SVNode[n].firstarc; //前一个站点加入到当前站点的链表中
//将边按顺序插入到链表末尾
if (q == NULL) {
G2.SVNode[n].firstarc = p;
}
else {
while (q->nextarc != NULL) {
q = q->nextarc;
}
q->nextarc = p;
}
}
M.push_back(n);
}
else {
site[k] = s[i];
k++;
}
}
}
if (f) {
getline(file, s);
}
}
file.close();
}
//迪杰斯特拉算法求单源最短路线
void Dijkstra(SiteGraph G, int v)
{
Lowcost[v] = 0; //初始站点到初始站点的距离为0
Flag[v] = 1; //标注初始点
int num = 1; //记录目前被选中的站点数目
SiteArcNode* p;
while (num < G.vexnum) {
p = G.SVNode[v].firstarc; //p为新选中的点的第一个邻接点
while (p != NULL) {
//由于新点加入，更新起始点与其余未被选中的顶点之间的距离
if (!Flag[p->adjvex] && Lowcost[p->adjvex] > Lowcost[v] + 1) {
Lowcost[p->adjvex] = Lowcost[v] + 1;
Adjvex[p->adjvex] = v;
Route[p->adjvex] = p->path; //保存该站点所在的路线
}
p = p->nextarc;
}
int min = Infinity;
for (int i = 1; i <= G.vexnum; i++) {
//从未选择的站点中找下一个与起始站点距离最近的站点
if (!Flag[i] && Lowcost[i] < min) {
min = Lowcost[i];
v = i; //更新v为目前与起始站点距离最近的站点
}
}
Flag[v] = 1; //标记新选中的站点
num++; //目前被选中的站点数目+1
}
}
//对任意两站点，给出转车次数最少的乘车路线
void Find_Route(SiteGraph G)
{
string s1, s2;
int v1, v2;
cout << "请输入第一个站点：";
cin >> s1;
cout << "请输入第二个站点：";
cin >> s2;
for (int i = 0; i < G.vexnum; i++) {
if (G.SVNode[i].name == s1) {
v1 = i;
}
if (G.SVNode[i].name == s2) {
v2 = i;
}
}
for (int i = 1; i <= G.vexnum; i++) {
//初始化
Adjvex[i] = v1;
Route[i] = 0;
Lowcost[i] = Infinity;
Flag[i] = 0;
}
Dijkstra(G, v1); //求从站点v1出发到站点v2的换乘次数最少的乘车路线
cout << endl;
cout << s1 << " 到 " << s2 << " 的换乘次数最少为" << Lowcost[v2] - 1 << " "; //换乘次数要减1
//输出起始点到站点v2的最少转车路径
cout << "路径为：" << endl;
int j = v2;
vector<int>Path;
while (j != v1) {
Path.push_back(j);
j = Adjvex[j];
}
int k = Route[Path[Path.size() - 1]];
cout << k << "路：" << s1;
for (int i = Path.size() - 1; i >= 0; i--) {
if (Route[Path[i]] != k) {
k = Route[Path[i]];
cout << "\n换乘到" << k << "路：" << G.SVNode[Path[i + 1]].name;
}
cout << "->" << G.SVNode[Path[i]].name;
}
cout << endl;
}
//对任意两站点，给出经过站点最少的乘车路线
void Find_Site(SiteGraph G)
{
string s1, s2;
int v1, v2;
cout << "请输入第一个站点：";
cin >> s1;
cout << "请输入第二个站点：";
cin >> s2;
for (int i = 0; i < G.vexnum; i++) {
if (G.SVNode[i].name == s1) {
v1 = i;
}
if (G.SVNode[i].name == s2) {
v2 = i;
}
}
for (int i = 1; i <= G.vexnum; i++) {
//初始化
Adjvex[i] = v1;
Route[i] = 0;
Lowcost[i] = Infinity;
Flag[i] = 0;
}
Dijkstra(G, v1); //求从站点v1出发到站点v2的经过站点最少的乘车路线
//输出起始站点到站点v2的最短距离
cout << endl;
cout << s1 << " 到 " << s2 << " 的经过站点次数最少为" << Lowcost[v2] + 1 << " ";
//输出起始点到站点v2的最少转车路径
cout << "路径为：" << endl;
int j = v2;
vector<int>Path;
while (j != v1) {
Path.push_back(j);
j = Adjvex[j];
}
int k = Route[Path[Path.size() - 1]];
cout << k << "路：" << s1;
for (int i = Path.size() - 1; i >= 0; i--) {
if (Route[Path[i]] != k) {
k = Route[Path[i]];
cout << "\n换乘到" << k << "路：" << G.SVNode[Path[i + 1]].name;
}
cout << "->" << G.SVNode[Path[i]].name;
}
cout << endl;
}操作結果:
（1）输入任意两站点，给出转车次数最少的乘车路线
请输入第一个站点：白马公园站
请输入第二个站点：樱花路站
白马公园站 到 樱花路站 的换乘次数最少为1 路径为：
20路：白马公园站->北京东路九华山站
换乘到11路：北京东路九华山站->樱花路站
*********************************************************************************
（2）输入任意两站点，给出经过站点最少的乘车路线
请输入第一个站点：白马公园站
请输入第二个站点：樱花路站
白马公园站 到 樱花路站 的经过站点次数最少为8 路径为：
20路：白马公园站->太平门站
换乘到11路：太平门站->板仓街岗子村站
换乘到6路：板仓街岗子村站->板仓村站->板仓街花园路站->樱驼村站->蒋王庙站->樱花路站ここで使用するデータ構造は隣接リストですが、もちろん隣接行列も使用でき、基本的な手法は変わりません。ただし、隣接マトリックスを使用すると大量のスペースが無駄になり、実行時間が隣接リストよりも遅くなるため、隣接リストを使用することをお勧めします。この質問は比較的複雑ですが、現実に近いものであり、誰もがダイクストラのアルゴリズムに精通して応用するのに非常に役立ちます。
以上がこの質問に対する私の考えであり、皆さんと共有できることを大変うれしく思います。