LeetCode 每日一题 Day 6（DFS+BFS)

1466. 重新规划路线

DFS解法

参考力扣官方解法：
思路与算法

题目给定一张由 nnn 个点（使用 000 到 n−1n-1n−1 编号），n−1n-1n−1 条边构成的有向图，如果忽略边的方向，就变成了一棵树。我们需要改变某些边的方向使得每个点都可以访问到 000 号点。

如果忽略边的方向，将每条有向边以及其反向边加入到图中，那么从任意一点出发都能到达 000 号点。路径上可能会经过反向边，我们需要变更与之对应的原边的方向。需要变更的次数即为答案。

以每个点为起点进行搜索的代价会很大，因此我们考虑从 000 出发去遍历其他点（可以使用深度优先搜索或者广度优先搜索，本题解使用深度优先搜索），原来我们需要统计反向边的数量，现在需要统计原方向边的数量。

具体而言，我们使用 111 标记原方向的边，使用 000 标记反向边。然后从 000 号点开始遍历，访问到某个新的点时，所经过的边被 111 标记，就令答案加 111。最终统计得到的答案就是我们需要变更方向的最小路线数。

class Solution {
public:
    int dfs(int x, int parent, vector<vector<pair<int, int>>>& e) {
        int res = 0;
        for (auto &edge : e[x]) {
            if (edge.first == parent) {
                continue;
            }
            res += edge.second + dfs(edge.first, x, e);
        }
        return res;
    }

    int minReorder(int n, vector<vector<int>>& connections) {
        vector<vector<pair<int, int>>> e(n);
        for (auto edge : connections) {
            e[edge[0]].push_back(make_pair(edge[1], 1));
            e[edge[1]].push_back(make_pair(edge[0], 0));
        }
        return dfs(0, -1, e);
    }
};

以下是我的解法 BFS

当我们面对这个问题时，我们的目标是重新规划路线方向，使得每个城市都能到达城市 0。给定的城市和路线信息可以表示成一个有向图，其中每个节点是城市，每条边是一条有向的路线。为了达到目标，我们需要确保从每个城市到城市 0 都有一条有向路径。
所以方法很明显了 ，首先建立有向图，然后bfs遍历再计算反向边数即可：

class Solution {
public:
    int minReorder(int n, std::vector<std::vector<int>>& connections) {
        std::vector<std::vector<std::pair<int, int>>> graph(n); // 使用邻接表表示有向图

        // 构建有向图
        for (const auto& edge : connections) {
            graph[edge[0]].emplace_back(edge[1], 1);   // 原方向
            graph[edge[1]].emplace_back(edge[0], 0);   // 反方向
        }

        std::vector<bool> visited(n, false);
        int minReorderCount = 0;

        // 从城市0开始执行BFS遍历
        std::queue<int> q;
        q.push(0);
        visited[0] = true;

        while (!q.empty()) {
            int currentCity = q.front();
            q.pop();

            for (const auto& neighbor : graph[currentCity]) {
                int nextCity = neighbor.first;
                int direction = neighbor.second;

                if (!visited[nextCity]) {
                    // 如果需要反转边的方向，增加计数
                    minReorderCount += direction;

                    // 移动到BFS遍历中的下一个城市
                    q.push(nextCity);
                    visited[nextCity] = true;
                }
            }
        }

        return minReorderCount;
    }
};