【每日一题】1466. 重新规划路线-2023.12.7-CSDN博客

本文链接：https://blog.csdn.net/weixin_45142381/article/details/134857221

题目：

1466. 重新规划路线

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]

解答：

代码：

class Solution {
    //res；用来保存结果的全局变量
    int res;
    //adjList:邻接表，保存每个节点的邻居(出边的终点)
    List<List<Integer>> adjList;
    //reversedAdjList:逆邻接表，保存每个节点的逆邻居(入边的起点)
    List<List<Integer>> reversedAdjList;
    public int minReorder(int n, int[][] connections) {
        //初始化三个全局变量
        res=0;
        adjList=new ArrayList<>();
        reversedAdjList=new ArrayList<>();
        //第一步：为方便遍历节点的所以邻居，我们先把边集合转换成邻接表
        //为邻接表各添加n行ArrayList
        for(int i=0;i<n;i++){
            adjList.add(new ArrayList<>());
            reversedAdjList.add(new ArrayList<>());
        }
        //遍历边集合connections
        for(int i=0;i<connections.length;i++){
            //对于边集合的第i条边，connections[i][0]是起点，connections[i][1]是终点
            //在adjList的第connections[i][0]行处，追加connections[i][1]作为邻居
            adjList.get(connections[i][0]).add(connections[i][1]);
            //reversedAdjList要反过来加
            reversedAdjList.get(connections[i][1]).add(connections[i][0]);
        }
        //第二步：创建一个记录每个节点是否访问过的数组
        boolean[] visited=new boolean[n];
        visited[0]=true;
        dfs(0,adjList,reversedAdjList,visited);
        return res;
    }

    //第三步：递归函数
    //cur:当前节点下标
    public void dfs(int cur,List<List<Integer>> adjList,List<List<Integer>> reversedAdjList,boolean[] visited){
        //递归逻辑主要就是遍历cur的所有邻居/逆邻居，再递归遍历邻居的邻居。以此类推，找到邻居就++，逆邻居不++
        //遍历节点cur的所有邻居
        for(int neighbor:adjList.get(cur)){
            //这个邻居被访问过，那就继续，找下一个邻居
            if(visited[neighbor]){
                continue;
            }
            //这个邻居没访问过，那就要立刻置为已访问，并累加到结果，代表需要调换方向
            visited[neighbor]=true;
            res++;
            //深度优先搜索，从这个邻居开始
            dfs(neighbor,adjList,reversedAdjList,visited);
        }
        //遍历节点cur的所有逆邻居
        for(int reversedNeighbor:reversedAdjList.get(cur)){
            //这个邻居被访问过，那就继续，找下一个邻居
            if(visited[reversedNeighbor]){
                continue;
            }
            //这个逆邻居没访问过，那就要立刻置为已访问，但不需要调换方向
            visited[reversedNeighbor]=true;
            //深度优先搜索，从这个逆邻居开始
            dfs(reversedNeighbor,adjList,reversedAdjList,visited);
        }
    }
}