LeetCode - 拓扑排序

最新推荐文章于 2024-04-30 23:56:40 发布

原创最新推荐文章于 2024-04-30 23:56:40 发布 · 314 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法

LeetCode 专栏收录该内容

4 篇文章

订阅专栏

这篇博客介绍了如何使用深度优先搜索（DFS）和广度优先搜索（BFS）来解决课程依赖的排序问题。在深度优先解法中，通过递归遍历避免环路来组织课程顺序；而在广度优先搜索解法中，利用队列进行拓扑排序，确保无环路的情况下得到正确的课程顺序。这两种方法都是图论在实际问题中的应用，对于理解和解决类似问题具有指导意义。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

207. 课程表

class Solution {
public:
    bool canFinish(int nums, vector<vector<int>>& pres) {
        if (pres.size() == 0 || pres[0].size() == 0) {
            return true;
        }

        vector<vector<int>> paths(nums);
        vector<bool> visited(nums);
        vector<bool> onPath(nums);
        for (int i=0; i<pres.size(); i++) {
            int ai = pres[i][0];
            int bi = pres[i][1];
            paths[bi].push_back(ai);
        }
        for (int i=0; i<nums; i++) {
            dfs(paths, visited, onPath, i);
        }

        return !hasCircle;
    }

    void dfs(vector<vector<int>> &paths, vector<bool> &visited, vector<bool> &onPath, int x) {
        if (onPath[x]) {
            hasCircle = true;
        }
        if (visited[x]) {
            return;
        }
        visited[x] = true;
        onPath[x] = true;
        for (int node : paths[x]) {
            dfs(paths, visited, onPath, node);
        }
        onPath[x] = false;
    }
private:
    bool hasCircle;
};

210. Course Schedule II

深度优先解法

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        vector<vector<int>> graph(numCourses);
        vector<bool> visited(numCourses);
        vector<bool> onPath(numCourses);
        for (vector<int> vec : prerequisites) {
            graph[vec[1]].push_back(vec[0]);
        }

        for (int i=0; i<numCourses; i++) {
            dfs(graph, visited, onPath, i);
        }
        if (hasCircle) {
            return {};
        }

        visited = vector(numCourses, false);
        for (int i=0; i<numCourses; i++) {
            postorder(graph, visited, i);
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }

    void dfs(vector<vector<int>> &graph, vector<bool> &visited, vector<bool> &onPath, int cur) {
        if (onPath[cur]) {
            hasCircle = true;
            return;
        }
        if (visited[cur]) {
            return;
        }
        visited[cur] = true;
        onPath[cur] = true;
        for (int next : graph[cur]) {
            dfs(graph, visited, onPath, next);
        }
        onPath[cur] = false;
    }

    void postorder(vector<vector<int>> &graph, vector<bool> &visited, int cur) {
        if (visited[cur]) {
            return;
        }
        visited[cur] = true;
        for (int next : graph[cur]) {
            postorder(graph, visited, next);
        }
        ans.push_back(cur);
    }

private:
    vector<int> ans;
    int hasCircle;
};

广度有限搜索，也是更加“标准”的拓扑排序解法

class Solution {
public:
    vector<int> findOrder(int n, vector<vector<int>>& prerequisites) {
        vector<int> ans;
        vector<vector<int>> graph(n);
        vector<int> in(n, 0);
        for (vector<int> vec : prerequisites) {
            int a=vec[0];
            int b=vec[1];
            graph[b].push_back(a);
            in[a]++;
        }

        queue<int> que;
        for (int i=0; i<n; i++) {
            if (in[i]==0) {
                que.push(i);
            }
        }

        while(!que.empty()) {
            int i=que.front();
            que.pop();
            ans.push_back(i);
            for(int node : graph[i]) {
                in[node]--;
                if (in[node]==0) {
                    que.push(node);
                }
            }
        }

        if (ans.size() != n) {
            return {};
        } else {
            return ans;
        }
    }
};