leetcode1129题（图的BFS）

1129. 在一个有向图中，节点分别标记为 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。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/shortest-path-with-alternating-colors
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1. 由于本题中提到的边有两种，因此可以想象成两个图重叠起来构成的图，所以可以把两个图分开存储，这样也比较好找红蓝边交替的路径。
2. 把两个图分开存储即针对两个颜色为每个节点创建两个邻接矩阵，将题目给的两个二维数组转化成每个节点的邻接矩阵。
3. 其余看代码

class Solution {
    public int[] shortestAlternatingPaths(int n, int[][] redEdges, int[][] blueEdges) {
        List<List<Integer>> redAdj = new ArrayList<>();
        List<List<Integer>> blueAdj = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            redAdj.add(new ArrayList<Integer>());
            blueAdj.add(new ArrayList<Integer>());
        }

        // 把redEdges数组转化成由红色边到达的节点对应的邻接矩阵
        for (int i = 0; i < redEdges.length; i++) {
            int[] edge = redEdges[i];
            redAdj.get(edge[0]).add(edge[1]);
        }

        // 把blueEdges数组转化成由蓝色边到达的节点对应的邻接矩阵
        for (int i = 0; i < blueEdges.length; i++) {
            int[] edge = blueEdges[i];
            blueAdj.get(edge[0]).add(edge[1]);
        }

        // 记录节点是否被访问过，由于有红色边跟蓝色边,所以创建一个二维数组visit[i][0]=true表明节点i被访问且走的是红色边到达下一个节点，visit[i][1]=true表明节点i被访问且走的是蓝色边到达下一个节点
        boolean[][] visited = new boolean[2][n];
        int[] res = new int[n];
        Arrays.fill(res, -1);
        
        // BFS,入队元素包括了当前访问节点的序号，通过什么颜色的边到达当前节点，节点0走红蓝交替边到达当前节点的路径长度,[v,color,len]
        Queue<int[]> queue = new LinkedList<>();
        // 初始时0节点可以走红色和蓝色到0节点
        queue.offer(new int[]{0, 0, 0});
        queue.offer(new int[]{0, 1, 0});
        visited[0][0] = true;
        visited[1][0] = true;

        while (!queue.isEmpty()) {
            int[] x = queue.poll();
            // 获得当前所到节点，以及通过什么颜色的边到达的当前节点，还有到达当前节点的路径长度
            int v = x[0], color = x[1], len = x[2];
            if (res[v] == -1) // 第一次访问为最短路径长度
                res[v] = len;
            // 当上条边颜色是红色时
            if (color == 0) {
                // 遍历当前节点的蓝色边邻接矩阵
                for (int w : blueAdj.get(v)) {
                    if (!visited[1][w]) {
                        visited[1][w] = true;
                        // 遇到未通过蓝色边到达的节点则入队
                        queue.add(new int[]{w, 1, len + 1});
                    }
                }
            } else { //上条边颜色为蓝色，跟上面类似的操作
                // 遍历当前节点的红边邻接矩阵
                for (int w : redAdj.get(v)) {
                    if (!visited[0][w]) {
                        visited[0][w] = true;
                        // 遇到未通过红色边到达的节点则入队
                        queue.add(new int[]{w, 0, len + 1});
                    }
                }
            }
        }
        return res;
    }
}