【C++图论 BFS】1129. 颜色交替的最短路径|1779

本文涉及知识点

C++图论
 C++BFS算法

LeetCode1129. 颜色交替的最短路径

给定一个整数 n，即有向图中的节点数，其中节点标记为 0 到 n - 1。图中的每条边为红色或者蓝色，并且可能存在自环或平行边。

给定两个数组 redEdges 和 blueEdges，其中：

redEdges[i] = [ai, bi] 表示图中存在一条从节点 ai 到节点 bi 的红色有向边，

blueEdges[j] = [uj, vj] 表示图中存在一条从节点 uj 到节点 vj 的蓝色有向边。

返回长度为 n 的数组 answer，其中 answer[X] 是从节点 0 到节点 X 的红色边和蓝色边交替出现的最短路径的长度。如果不存在这样的路径，那么 answer[x] = -1。

示例 1：

输入：n = 3, red_edges = [[0,1],[1,2]], blue_edges = []

输出：[0,1,-1]

示例 2：

输入：n = 3, red_edges = [[0,1]], blue_edges = [[2,1]]

输出：[0,1,-1]

提示：

1 <= n <= 100

0 <= redEdges.length, blueEdges.length <= 400

redEdges[i].length == blueEdges[j].length == 2

0 <= ai, bi, uj, vj < n

BFS

vis[cur][b] { 0 到 c u r ，并以红色结尾的最小距离 0 = = b 0 到 c u r , 并以蓝色结尾的最小距离 1 = = b \begin{cases} 0到cur，并以红色结尾的最小距离 && 0==b \\ 0到cur,并以蓝色结尾的最小距离 && 1 == b \end{cases} {0到cur，并以红色结尾的最小距离0到cur,并以蓝色结尾的最小距离0==b1==b

vis[cur][b] =n10,表示未处理。 ∀ \forall ∀cur,r vis[cur][b]都只处理一次 → \rightarrow → 每条边只访问两次。
ans[cur] = min(vis[cur][0],vis[cur[[1])
如果ans[cur] >=n10，则为-1。

代码

核心代码

cpp 复制代码

class CNeiBo
{
public:	
	static vector<vector<int>> Two(int n, vector<vector<int>>& edges, bool bDirect, int iBase = 0) 
	{
		vector<vector<int>>  vNeiBo(n);
		for (const auto& v : edges)
		{
			vNeiBo[v[0] - iBase].emplace_back(v[1] - iBase);
			if (!bDirect)
			{
				vNeiBo[v[1] - iBase].emplace_back(v[0] - iBase);
			}
		}
		return vNeiBo;
	}	
	static vector<vector<std::pair<int, int>>> Three(int n, vector<vector<int>>& edges, bool bDirect, int iBase = 0)
	{
		vector<vector<std::pair<int, int>>> vNeiBo(n);
		for (const auto& v : edges)
		{
			vNeiBo[v[0] - iBase].emplace_back(v[1] - iBase, v[2]);
			if (!bDirect)
			{
				vNeiBo[v[1] - iBase].emplace_back(v[0] - iBase, v[2]);
			}
		}
		return vNeiBo;
	}	
	static vector<vector<int>> Mat(vector<vector<int>>& neiBoMat)
	{
		vector<vector<int>> neiBo(neiBoMat.size());
		for (int i = 0; i < neiBoMat.size(); i++)
		{
			for (int j = i + 1; j < neiBoMat.size(); j++)
			{
				if (neiBoMat[i][j])
				{
					neiBo[i].emplace_back(j);
					neiBo[j].emplace_back(i);
				}
			}
		}
		return neiBo;
	}
};

class Solution {
		public:
			vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& redEdges, vector<vector<int>>& blueEdges) {
				vector<vector<int>> neiBos[2];
				neiBos[0] = CNeiBo::Two(n, redEdges, true);
				neiBos[1] = CNeiBo::Two(n, blueEdges, true);
				vector<vector<int>> vis(n, vector<int>(2,10*n));
				queue<pair<int, bool>> que;
				auto Add = [&](int cur, bool b,int dis) {
					if (10 * n != vis[cur][b]) { return; }
					que.emplace(cur, b);
					vis[cur][b] = dis;
				};
				Add(0, true, 0);
				Add(0, false, 0);
				while (que.size()) {
					const auto [cur, b] = que.front();
					que.pop();
					for (const auto& next : neiBos[(b+1)%2][cur]) {
						Add(next, (b + 1) % 2, vis[cur][ b]+1);
					}
				}
				vector<int> ans;
				for (const auto& v : vis) {
					int iMin = min(v[0], v[1]);
					if (iMin >= 10 * n) { iMin = -1; }
					ans.emplace_back(iMin);
				}
				return ans;
			}
		};

单元测试

cpp 复制代码

int n;
		vector<vector<int>> red_edges, blue_edges;
		TEST_METHOD(TestMethod1)
		{
			n = 3, red_edges = { {0,1},{1,2} }, blue_edges = {};
			auto res = Solution().shortestAlternatingPaths(n,red_edges, blue_edges);
			AssertEx({ 0,1,-1 }, res);
		}
		TEST_METHOD(TestMethod2)
		{
			n = 3, red_edges = { {0,1} }, blue_edges = { {2,1} };
			auto res = Solution().shortestAlternatingPaths(n, red_edges, blue_edges);
			AssertEx({ 0,1,-1 }, res);
		}

扩展阅读

我想对大家说的话
工作中遇到的问题，可以按类别查阅鄙人的算法文章，请点击《算法与数据汇总》。
学习算法：按章节学习《喜缺全书算法册》，大量的题目和测试用例，打包下载。重视操作
有效学习：明确的目标及时的反馈拉伸区（难度合适）专注
闻缺陷则喜(喜缺)是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛
失败+反思=成功成功+反思=成功

视频课程

先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

测试环境

操作系统：win7 开发环境： VS2019 C++17

或者操作系统：win10 开发环境： VS2022 C++17

如无特殊说明，本算法用**C++**实现。