目录链接：

力扣编程题-解法汇总_分享+记录-CSDN博客

GitHub同步刷题项目：

https://github.com/September26/java-algorithms

原题链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

描述：

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^4
• connections.length == n-1
• connections[i].length == 2
• 0 <= connections[i][0], connections[i][1] <= n-1
• connections[i][0] != connections[i][1]

解题思路：

这里使用广度优先搜索的解法，从0出发，先找到一步可以走到的所有节点，如果有反向的，则次数+1。如果正向的则无需处理。

然后找2步可以走到的所有节点，依次下去。

代码：

class Solution {
    Map<Integer, List<Integer>> toMap = new HashMap<>();
    Map<Integer, List<Integer>> fromMap = new HashMap<>();
    boolean[] dp;

    public int minReorder(int n, int[][] connections) {
        dp = new boolean[n];
        for (int[] connection : connections) {
            int from = connection[0];
            int to = connection[1];
            List<Integer> integers1 = toMap.computeIfAbsent(to, k -> new ArrayList<>());
            integers1.add(from);
            List<Integer> integers2 = fromMap.computeIfAbsent(from, k -> new ArrayList<>());
            integers2.add(to);
        }
        int sum = 0;
        List<Integer> list = new ArrayList<>();
        list.add(0);
        dp[0] = true;
        while (list.size() > 0) {
            List<Integer> newList = new ArrayList<>();
            for (int i : list) {
                List<Integer> integers = toMap.get(i);
                List<Integer> integers1 = fromMap.get(i);
                if (integers != null) {
                    for (int key : integers) {
                        if (dp[key]) {
                            continue;
                        }
                        dp[key] = true;
                        newList.add(key);
                    }
                }
                if (integers1 != null) {
                    for (int key : integers1) {
                        if (dp[key]) {
                            continue;
                        }
                        dp[key] = true;
                        sum++;
                        newList.add(key);
                    }
                }
            }
            list = newList;
        }
        return sum;
    }
}