LeetCode_BinaryTree_1129. Shortest Path with Alternating Colors 颜色交替的最短路径【BFS求最短路径】【java】【中等】

最新推荐文章于 2023-02-01 17:51:48 发布

&再见萤火虫&

最新推荐文章于 2023-02-01 17:51:48 发布

阅读量262

点赞数

分类专栏： LeetCode 文章标签： java leetcode 颜色交替 BFS 中等

本文链接：https://blog.csdn.net/qq_41528502/article/details/126949222

版权

LeetCode 专栏收录该内容

115 篇文章 2 订阅

订阅专栏

一，题目描述

英文描述

You are given an integer n, the number of nodes in a directed graph where the nodes are labeled from 0 to n - 1. Each edge is red or blue in this graph, and there could be self-edges and parallel edges.

You are given two arrays redEdges and blueEdges where:

redEdges[i] = [ai, bi] indicates that there is a directed red edge from node ai to node bi in the graph, and
blueEdges[j] = [uj, vj] indicates that there is a directed blue edge from node uj to node vj in the graph.
Return an array answer of length n, where each answer[x] is the length of the shortest path from node 0 to node x such that the edge colors alternate along the path, or -1 if such a path does not exist.

中文描述

在一个有向图中，节点分别标记为 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指向0：

如果-1=》0为红色路径，那么0=》下一个节点就要选择蓝色路径

否则正好相反。

由于是求从0开始的最短路径，所以BFS最合适不过了，每次可以得到一层的结果，需要注意两点：

对遍历过的节点，要添加对应的标记，如lastColor为red，需要标记red路径已经使用过，再次遍历到该节点时，需要跳过；
每遍历完一层，需要变换颜色（BFS层次遍历，需要记录当前队列元素数目，这样就可以每次遍历一层的节点）；

三，AC代码

Java

import java.util.*;
class Solution {
    public int[] shortestAlternatingPaths(int n, int[][] redEdges, int[][] blueEdges) {
        int[] ans = new int[n];
        for (int i = 0; i < n; i++) ans[i] = Integer.MAX_VALUE;;

        Map<Integer, List<Integer>> redNext = new HashMap<>();
        Map<Integer, List<Integer>> blueNext = new HashMap<>();
        for (int i = 0; i < redEdges.length; i++) {
            if (!redNext.containsKey(redEdges[i][0])) {
                redNext.put(redEdges[i][0], new ArrayList<>());
            }
            List<Integer> list = redNext.get(redEdges[i][0]);
            list.add(redEdges[i][1]);
        }

        for (int i = 0; i < blueEdges.length; i++) {
            if (!blueNext.containsKey(blueEdges[i][0])) {
                blueNext.put(blueEdges[i][0], new ArrayList<>());
            }
            List<Integer> list = blueNext.get(blueEdges[i][0]);
            list.add(blueEdges[i][1]);
        }

        // false: blue指向当前节点, true: red指向当前节点
        bfs(redNext, blueNext, true, ans);
        bfs(redNext, blueNext, false, ans);

        for (int i = 0; i < n; i++) {
            if (ans[i] == Integer.MAX_VALUE) {
                ans[i] = -1;
            }
        }

        return ans;
    }
    // false: blue指向当前节点, true: red指向当前节点
    public void bfs (Map<Integer, List<Integer>> redNext, Map<Integer, List<Integer>> blueNext, boolean lastColor, int[] ans) {
        int n = ans.length;
        boolean[] redVisited = new boolean[n];
        boolean[] blueVisited = new boolean[n];
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(0);
        int step = 0;
        if (lastColor) redVisited[0] = true;
        else blueVisited[0] = true;
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size-- != 0) {
                int node = queue.peek();
                ans[node] = Math.min(ans[node], step);
                queue.poll();
                // 红色指向当前节点
                if (lastColor && blueNext.containsKey(node)) {
                    for (int num : blueNext.get(node)) {
                        if (!blueVisited[num]) {
                            queue.add(num);
                            blueVisited[num] = true;

                        }
                    }
                }
                // 蓝色指向当前节点
                else if (!lastColor && redNext.containsKey(node)) {
                    for (int num : redNext.get(node)) {
                        if (!redVisited[num]) {
                            queue.add(num);
                            redVisited[num] = true;

                        }
                    }
                }
            }
            lastColor = !lastColor;//  !!!
            step++;
        }
    }
}