Leetcode.1129 颜色交替的最短路径

题目链接

Leetcode.1129 颜色交替的最短路径 Rating : 1780

题目描述

在一个有向图中，节点分别标记为 0, 1, ..., n-1。图中每条边为红色或者蓝色，且存在自环或平行边。

red_edges中的每一个 [i, j]对表示从节点 i到节点 j的红色有向边。类似地，blue_edges中的每一个 [i, j]对表示从节点 i到节点 j的蓝色有向边。

返回长度为 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]

示例 3 :

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

示例 4 :

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

示例 5 :

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

提示 :

1 < = n < = 100 1 <= n <= 100 1<=n<=100
r e d e d g e s . l e n g t h < = 400 red_edges.length <= 400 rededges.length<=400
b l u e e d g e s . l e n g t h < = 400 blue_edges.length <= 400 blueedges.length<=400
r e d e d g e s [ i ] . l e n g t h = = b l u e e d g e s [ i ] . l e n g t h = = 2 red_edges[i].length == blue_edges[i].length == 2 rededges[i].length==blueedges[i].length==2
0 <= red_edges[i][j], blue_edges[i][j] < n

分析：
本题是求最短路径的长度，可以使用 BFS（BFS可以求最短路）。

我们用两个集合 g [ 0 ] 和 g [ 1 ] g[0] 和 g[1] g[0]和g[1] 分别代表 红色边集合 和 蓝色边集合。 0代表红色，1代表蓝色。因为 1 ^ 1 = 0 , 0 ^ 1 = 1，这样可以快速的进行集合的交换。

一个记录答案的数组 ans，开始全部初始化为 -1。

队列里的元素有两个属性，分别是点和颜色。比如当前点是 (3,0)，那么下一个点就应该在 g [ 1 ] g[1] g[1] 集合中，从点 3 出发的点。

还要有一个 st[2][n]的数组，来记录已经搜过的状态，防止重复搜索。

开始之前队列中应该加入两个起点 (0,0)和 (0,1)，分别代表从零点出发，从蓝色边开始遍历和从红色边开始遍历。

时间复杂度： O ( n + m ) O(n + m) O(n+m)

C++代码：

class Solution {public:vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& redEdges, vector<vector<int>>& blueEdges) {//g[0] 存放红色边，g[1] 存放蓝色边vector<vector<vector<int>>> g(2,vector<vector<int>>(n));for(auto &e:redEdges){int a = e[0],b = e[1];g[0][a].push_back(b);}for(auto &e:blueEdges){int a = e[0],b = e[1];g[1][a].push_back(b);}bool st[2][n];memset(st,false,sizeof st); //第一个参数是点 第二个参数是颜色queue<pair<int,int>> q;//起点 先从蓝色边开始遍历q.push({0,0});//起点 先从红色边开始遍历q.push({0,1});int step = 0;vector<int> res(n,-1);while(!q.empty()){int sz = q.size();for(int i = 0;i < sz;++i){auto [t,c] = q.front();q.pop();//如果 res[t] == -1,说明这个点是第一次访问，直接记录答案即可if(res[t] == -1) res[t] = step;//将当前状态记录下来，防止重复搜索st[c][t] = true;//交换颜色 0^1 = 1 , 1^1 = 0c ^= 1;for(auto &v:g[c][t]){if(!st[c][v]){q.push({v,c});}}}//没遍历完一层 路径长度+1step++;}return res;}
};

Java代码：

class Solution {public int[] shortestAlternatingPaths(int n, int[][] redEdges, int[][] blueEdges) {List<Integer>[][] g = new List[2][n];for (var f : g) {Arrays.setAll(f, k -> new ArrayList<>());}for (int[] e : redEdges) {int a = e[0];int b = e[1];g[0][a].add(b);}for (int[] e : blueEdges) {int a = e[0];int b = e[1];g[1][a].add(b);}Deque<int[]> q = new ArrayDeque<>();q.offer(new int[] {0, 0});q.offer(new int[] {0, 1});boolean[][] st = new boolean[2][n];int[] ans = new int[n];Arrays.fill(ans, -1);int step = 0;while (!q.isEmpty()) {int size = q.size();for (int i = 0;i < size;i++) {var p = q.poll();int t = p[0], c = p[1];if (ans[t] == -1) {ans[t] = step;}st[c][t] = true;c ^= 1;for (int v : g[c][t]) {if (!st[c][v]) {q.offer(new int[] {v, c});}}}++step;}return ans;}
}