本文涉及知识点

C++BFS算法

LeetCode1466. 重新规划路线

n 座城市，从 0 到 n-1 编号，其间共有 n-1 条路线。因此，要想在两座不同城市之间旅行只有唯一一条路线可供选择（路线网形成一颗树）。去年，交通运输部决定重新规划路线，以改变交通拥堵的状况。
路线用 connections 表示，其中 connections[i] = [a, b] 表示从城市 a 到 b 的一条有向路线。
今年，城市 0 将会举办一场大型比赛，很多游客都想前往城市 0 。
请你帮助重新规划路线方向，使每个城市都可以访问城市 0 。返回需要变更方向的最小路线数。
题目数据 保证 每个城市在重新规划路线方向后都能到达城市 0 。

示例 1：

输入：n = 6, connections = [[0,1],[1,3],[2,3],[4,0],[4,5]]
输出：3
解释：更改以红色显示的路线的方向，使每个城市都可以到达城市 0 。
示例 2：

输入：n = 5, connections = [[1,0],[1,2],[3,2],[3,4]]
输出：2
解释：更改以红色显示的路线的方向，使每个城市都可以到达城市 0 。
示例 3：

输入：n = 3, connections = [[1,0],[2,0]]
输出：0

提示：

2 <= n <= 5 * 10⁴
connections.length == n-1
connections[i].length == 2
0 <= connections[i][0], connections[i][1] <= n-1
connections[i][0] != connections[i][1]

C++BFS

所有边看成无向边，以0为起点求各节点的层次。枚举各边是否是层次大的指向层次小的。由于没有环，所以任意城市到达0，都是只有一条路径，即层次唯一。
BFS的状态表示：leves[0] = {0}，leves[i]记录所有层次为i的城市。
BFS的后续状态：通过next枚举cur的临接点。
BFS的初始状态：leves[0] = {0}
BFS的返回值：无。
BFS的重复处理：leve[i]记录各城市层次，-1表示未处理。

代码

核心代码

class Solution {
		public:
			int minReorder(int n, vector<vector<int>>& connections) {
				vector<vector<int>> neiBo(n);
				for (const auto& v:connections) {
					neiBo[v[0]].emplace_back(v[1]);
					neiBo[v[1]].emplace_back(v[0]);
				}
				vector<int> leve(n, -1);
				queue<int> que;
				que.emplace(0);
				leve[0] = 0;
				while (que.size()) {
					const auto cur = que.front();
					que.pop();
					for (const auto& next : neiBo[cur]) {
						if (-1 != leve[next]) { continue; }
						leve[next] = leve[cur] + 1;
						que.emplace(next);
					}
				}
				int iRet = 0;
				for (const auto& v : connections) {
					iRet += (leve[v[0]] < leve[v[1]]);
				}
				return iRet;
			}
		};

单元测试

int n;
		vector<vector<int>> connections;
		TEST_METHOD(TestMethod1)
		{
			n = 3, connections = { {0,2},{2,1} };
			auto res = Solution().minReorder(n, connections);
			AssertEx(2, res);
		}
		TEST_METHOD(TestMethod11)
		{
			n = 6, connections = { {0,1},{1,3},{2,3},{4,0},{4,5} };
			auto res = Solution().minReorder(n, connections);
			AssertEx(3, res);
		}
		TEST_METHOD(TestMethod12)
		{
			n = 5, connections = { {1,0},{1,2},{3,2},{3,4} };
			auto res = Solution().minReorder(n, connections);
			AssertEx(2, res);
		}
		TEST_METHOD(TestMethod13)
		{
			n = 3, connections = { {1,0},{2,0} };
			auto res = Solution().minReorder(n, connections);
			AssertEx(0, res);
		}