【算法】最短路径
【题目描述】
下图表示从城市A到城市H的交通图。从图中可以看出，从城市A到城市H要经过若干个城市。现在找出一条经过城市最少的一条路线。
【输入描述】
第一行一个整数n,表示几个城市。
接下来2~n+1行，表示两个城市之间的关系（能否直达）
【输出描述】
倒序输出城市最短线路中间用”-“隔开
【样例输入】
8 1 0 0 0 1 0 1 1 0 1 1 1 1 0 1 1 0 1 1 0 0 1 1 1 0 1 0 1 1 1 0 1 1 1 0 1 1 1 0 0 0 0 1 1 1 1 1 0 1 1 1 0 0 1 1 0 1 1 1 1 0 0 0 1
【样例输出】
H-F-A
【题目分析】
考虑用BFS实现最短路径
看到上图很容易想到用邻接矩阵来表示，0表示能走，1表示不能走。则可以产生如下表的数据：
| A | B | C | D | E | F | G | H | |
| A | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 1 |
| B | 0 | 1 | 1 | 1 | 1 | 0 | 1 | 1 |
| C | 0 | 1 | 1 | 0 | 0 | 1 | 1 | 1 |
| D | 0 | 1 | 0 | 1 | 1 | 1 | 0 | 1 |
| E | 1 | 1 | 0 | 1 | 1 | 1 | 0 | 0 |
| F | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 0 |
| G | 1 | 1 | 1 | 0 | 0 | 1 | 1 | 0 |
| H | 1 | 1 | 1 | 1 | 0 | 0 | 0 | 1 |
首先想到的是用队列的思想。a数组是存储扩展结点的队列，a[i]记录经过的城市，b[i]记录前驱的城市，这样就可以倒推出最短路线。具体过程如下：
（1）将城市A入队，队首为０，队尾为１
（2）将队首所指的城市所有可通的城市入队（如果这个城市在队列中出现过就不入队，可以一布尔数组s[i]来判断），将入队城市的前趋城市保存在b[i]中。然后将队首加1，得到新的队首城市。重复以上步骤，直到搜到城市H时，搜索结束。利用b[i]可推导出最少的城市线路。
【参考程序】
#include<iostream>
#include<cstring>
using namespace std;
int ju[9][9]={
{0,0,0,0,0,0,0,0,0},
{0,1,0,0,0,1,0,1,1},
{0,0,1,1,1,1,0,1,1},
{0,0,1,1,0,0,1,1,1},
{0,0,1,0,1,1,1,0,1},
{0,1,1,0,1,1,1,0,0},
{0,0,0,1,1,1,1,1,0},
{0,1,1,1,0,0,1,1,0},
{0,1,1,1,1,0,0,0,1}, // 临接矩阵，0表示能走，1表示不能走
};
int a[101],b[101];
bool s[9];
int print(int d){ //输出函数
cout<<char(a[d]+64);
while(b[d]){
d=b[d];
cout<<"--"<<char(a[d]+64);
}
cout<<endl;
}
void bfs(){
int head,tail,i;
head=0; tail=1; //队首为0，队尾为1
a[1]=1; // 记录经过的城市
b[1]=0; // 记录前趋城市
s[1]=1; //表示该城市已经到过
do{
head++; //队首加一，出队
for(i=1;i<=8;i++){ //搜索可直通的城市
if((ju[a[head]][i]==0) && (s[i]==0)) { //判断城市是否走过
tail++; //队尾加1，入队
a[tail]=i;
b[tail]=head;
s[i]=1;
if(i==8){
print(tail); //第一次搜到H城市时路线最短
head=tail;
break;
}
}
}
}while(head<tail);
}
int main(){
memset(s,false,sizeof(s));
bfs(); //bfs操作
return 0;
}或者：
#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;
bool ccan[9][9]={{0,0,0,0,0,0,0,0,0},
{0,1,0,0,0,1,0,1,1},
{0,0,1,1,1,1,0,1,1},
{0,0,1,1,0,0,1,1,1},
{0,0,1,0,1,1,1,0,1},
{0,1,1,0,1,1,1,0,0},
{0,0,0,1,1,1,1,1,0},
{0,1,1,1,0,0,1,1,0},
{0,1,1,1,1,0,0,0,1}};//邻接矩阵 ，0表示可以走，1表示不可以走
int qque[100],pre[100];//队列和前驱结点，用来输出路径
bool visited[10];//是否入队列
int oout(int);//输出路径
void bfs();//广搜
int main()
{
bfs();
return 0;
}
void bfs()
{
int head=0,tail=1;//队列的指针
qque[1]=1;pre[1]=0;visited[1]=1;//记录队列的 第一个元素是1（A），它的前驱是0，它已经访问了
do
{
head++;
for(int i=1;i<=8;i++)//寻找A,B,C,D,E,F,G,H中能够走的
{
if(!ccan[qque[head]][i]&&!visited[i])//能都走并且没有访问
{
tail++;
qque[tail]=i;//入队
visited[i]=1;//打标记
pre[i]=qque[head];//记录前驱
if(i==8)//当搜到H，输出
{
oout(tail);
head=tail;
break;
}
}
}
}while(head<tail);
}
int oout(int x)
{
cout<<char(qque[x]+64);//首先输出H
while(pre[x]!=0)
{
x=pre[x];
cout<<"---"<<char(x+64);
}
cout<<endl;
}【题目过程详解】
注意：题目是用队列在做。下面的过程模拟广度优先遍历的过程，并输出一条路径(由终点到起点)
qque[1] //队列，表示记录经过的城市，第一个是起点，一定经过，所以标记1 pre[0] //前趋，第一个元素的前趋是0，表示已经访问过了 visited[1] //标记数组，用来标记访问过的点，第一个点默认访问，所以
（1）首先，do while循环。
（2）head++，头指针加1。表示我们要访问下一个点的地址（下标）
（3）然后，开始for循环，A，B，C，D，E，F，G，H 一个8个可以走的地方，所以循环8次，每次选取一个地方（城市）
（4）判断哪些点是可以走的。一个就是地图（题目中邻接矩阵）哪些点是可以走的，另一个是哪些点走过了。
ccan[qque[head]][i] 是个二维数组，前面的qque[head]表示行，后面的i 表示列。
因为head默认是0，head++后是1，所以第一个判断的就是 ccan[1][1]。
后面判断的时候，按照入队的顺序进行判断 ccan（以邻接点点为基础开始扩散）。
（5）if成立，说明，当前这个城市可以走，而且在这次循环中没有走过。
那么，对照上图，我们可以看出，成立的点都有哪些。
head为1：
（1） ccan[1][1]不成立，i++;
（2） qque[head]=qque[1]= 1， ccan[1][2]成立，且visited[2]=0；
那么这个点需要操作一下： tail++; 队列尾指针加1，qque[tail]=qque[2]=2;此时队列里面是 1 2 然后，标记一下当前的visited[i]=visited[2]=1; 记录前驱，qque[head]=qque[1]; 赋值给 pre[i]=pre[2]。 也就是 pre[2]=1。 实际上就是队列里面两个数，2的前驱是1 判断是否到边界 i==8。不成立。循环继续，i++；i为3
（3） qque[head]=qque[1]= 1，ccan[1][3]成立，且visited[3]=0;
那么这个点也需操作一下： tail++； 队列尾指针加1，准备往队列里面存数 tail=3 qque[tail]=qque[3]=3, 此时队列里面是1 2 3 然后，标记一下当前的visited[i]=visited[3]=1; 记录前驱（pre[i]=qque[head]），qque[head]=qque[1]; 赋值给 pre[i]=pre[3]。 也就是 pre[3]=1。 3的前驱是1 (表示从1也可以直接走到3) 判断是否到边界 i==8。不成立。循环继续，i++； i为4
（4） qque[head]=qque[1]= 1，ccan[1][4]成立，且visited[4]=0;
那么这个点也需操作一下： tail++； 队列尾指针加1，准备往队列里面存数 tail=4 qque[tail]=qque[4]=4, 此时队列里面是1 2 3 4 然后，标记一下当前的visited[i]=visited[4]=1; 记录前驱（pre[i]=qque[head]），qque[head]=qque[1]; 赋值给 pre[i]=pre[4]。 也就是 pre[4]=1。 4的前驱是1 (表示从1也可以直接走到4) 判断是否到边界 i==8。不成立。循环继续，i++； i为5
(5) qque[head]=qque[1]= 1，ccan[1][5]不成立，（1不能走到5）,i++; i为6
(6) qque[head]=qque[1]= 1，ccan[1][6]成立， 且visited[5]=0;
那么这个点也需操作一下： tail++； 队列尾指针加1，准备往队列里面存数 tail=5 qque[tail]=qque[5]=6, 此时队列里面是1 2 3 4 6 然后，标记一下当前的visited[i]=visited[6]=1; 记录前驱（pre[i]=qque[head]），qque[head]=qque[1]; 赋值给 pre[i]=pre[6]。 也就是 pre[6]=1。 6的前驱是1 (表示从1也可以直接走到6) 判断是否到边界 i==8。不成立。循环继续，i++； i为7
(7) qque[head]=qque[1]= 1，ccan[1][7]不成立，（1不能走到7）,i++; i为8
(8) qque[head]=qque[1]= 1，ccan[1][8]不成立，（1不能走到8）,i++; i为9。推出for循环
head为2：
由上面的过程可知， qque[head]=qque[2]=2, 根据地图，只有ccan[2][1] 和ccan[2][6] 可以走，但是在上面，visited[1] 和 visted[6] 都被标记过了，所以head为2的时候，一个都没成立
head为3：
由上面的过程可知， qque[head]=qque[3]=3, 根据地图，只有ccan[3][1] 、ccan[3][4]、ccan[3][5] 可以走，但是在上面，visited[1] 、 visted[4] 都被标记过了，所以只有ccan[3][5]这个点成立，此时i为5
那么这个点也需操作一下： tail++； 队列尾指针加1，准备往队列里面存数 tail=6 qque[tail]=qque[6]=5, 此时队列里面是1 2 3 4 6 5 然后，标记一下当前的visited[i]=visited[5]=1; 记录前驱（pre[i]=qque[head]），qque[head]=qque[3]=3; 赋值给 pre[i]=pre[5]。 也就是 pre[5]=3。 5的前驱是3 (表示从3也可以直接走到5) 其余不成立，不再继续判断。
head为4：
由上面的过程可知， qque[head]=qque[4]=4, 根据地图，只有ccan[4][1] 、ccan[4][3]、ccan[4][7] 可以走，但是在上面，visited[1] 、 visted[3] 都被标记过了，所以只有ccan[4][7]这个点成立，此时i为7
那么这个点也需操作一下： tail++； 队列尾指针加1，准备往队列里面存数 tail=7 qque[tail]=qque[7]=7, 此时队列里面是1 2 3 4 6 5 7 然后，标记一下当前的visited[i]=visited[7]=1; 记录前驱（pre[i]=qque[head]），qque[head]=qque[4]=4; 赋值给 pre[i]=pre[7]。 也就是 pre[7]=4。 7的前驱是4 (表示从4也可以直接走到7) 其余不成立，不再继续判断。
head为5：
由上面的过程可知， qque[head]=qque[5]=6, 根据地图，只有ccan[6][1] 、ccan[6][2]、ccan[6][8] 可以走，但是在上面，visited[1] 、 visted[2] 都被标记过了，所以只有ccan[6][8]这个点成立，此时i为8
那么这个点也需操作一下： tail++； 队列尾指针加1，准备往队列里面存数 tail=8 qque[tail]=qque[8]=8, 此时队列里面是1 2 3 4 6 5 7 8 然后，标记一下当前的visited[8]=visited[8]=1; 记录前驱（pre[i]=qque[head]），qque[head]=qque[5]=6; 赋值给 pre[i]=pre[7]。 也就是 pre[8]=6。 8的前驱是6 (表示从6也可以直接走到8) 其余不成立，不再继续判断。111111
if成立，开始输出 oout(tail),此时tail是8。 先输出 8,也就是H 然后，pre[x]!=0。 意思是8的前驱不是0开始输出，8的前驱是6，输出，6，也就是F 然后，x=pre[x], 替换前驱，6的前驱是1。输出1。 也就是A。
然后head=tail。 把尾结点复制给头结点，程序暂时结束。
不满足 head<tail，程序结束。
问题：
为什么没有比较过程，输出路径是最短的？H的前驱明明还有G和E，为什么没有判断过？
从起点开始，把起点能走到的点全部按照顺序入队，然后以这些顺序为基础（邻接矩阵）开始继续寻找别的点，如果找到目标点，就是最短的那条。
比如E点。
扫描二维码推送至手机访问。
版权声明：本文由青少年编程知识记录发布，如需转载请注明出处。
