单源无权最短路径（BFS实现）

实现代码：

#include<iostream>
#include<queue>
using namespace std;
//单源最短路径（BFS实现）

#define inf 0x3f3f3f
const int N = 155;

int G[N][N]; //图
int n, m; //顶点数 边数
bool book[N]; //标记数组
int dis[N]; //记录最短路径长度
int path[N]; //记录当前顶点的前驱顶点，记录路径
queue<int>q; //辅助队列

void bfs(int x) {

	book[x] = true;
	q.push(x);

	while (!q.empty()) {
		
		for (int i = 0;i < n;i++) {
			if (book[i] == false && G[q.front()][i] == 1) {
				book[i] = true;
				q.push(i);
				path[i] = q.front(); //记录当前顶点的前驱顶点
				dis[i] = dis[q.front()] + 1; //到达当前顶点的最短路径长度为到达前一个顶点的最短路径长度加1
			}
		}
		q.pop();
	}

}


int main() {

	cin >> n >> m;

	for (int i = 0;i < n;i++) //初始化标记数组
		book[i] = false;

	//初始化无向图
	for (int i = 0;i < n;i++) {
		for (int j = 0;j < n;j++) {
			G[i][j] = 0;
			G[j][i] = 0;
		}
	}

	//构建无向图
	for (int i = 0;i < m;i++) {
		int x, y; //边
		cin >> x >> y;
		G[x][y] = 1;
		G[y][x] = 1;
	}

	//初始化
	for (int i = 0;i < n;i++) {
		dis[i] = inf; //最初最短路径长度都为无穷大
		path[i] = -1; //最初前驱节点都为-1
	}

	dis[1] = 0; //自身到自身的最短路径长度为0

	bfs(1); //从1号顶点开始的最短路径

	for (int i = 0;i < n;i++) {
		cout <<"从1号顶点到达顶点"<<i<<"的最短路径长度为："<<dis[i] << "，"<<"路径为："<<i;
		int t = i;
		while (path[t] != -1) {
			cout << "<-" << path[t];
			t = path[t];
		}
		cout << endl;
	}
		

	return 0;
}

/*
输入样例：
8 10
0 1
0 4
1 5
5 2
5 6
2 7
6 3
2 3
6 7
8 3

输出样例：
从1号顶点到达顶点0的最短路径长度为：1，路径为：0<-1
从1号顶点到达顶点1的最短路径长度为：0，路径为：1
从1号顶点到达顶点2的最短路径长度为：2，路径为：2<-5<-1
从1号顶点到达顶点3的最短路径长度为：3，路径为：3<-2<-5<-1
从1号顶点到达顶点4的最短路径长度为：2，路径为：4<-0<-1
从1号顶点到达顶点5的最短路径长度为：1，路径为：5<-1
从1号顶点到达顶点6的最短路径长度为：2，路径为：6<-5<-1
从1号顶点到达顶点7的最短路径长度为：3，路径为：7<-2<-5<-1

*/

运行结果：