拓扑排序+代码

拓扑排序是图论中一个重要的概念，它主要用于解决有向无环图（DAG）中的问题。在拓扑排序中，我们需要对图中的节点进行排序，使得对于任意一对有向边 (u, v)，u 在排序中出现在 v 之前。拓扑排序可以用来判断一个有向图是否是有向无环图，以及对任务调度、依赖关系等问题进行求解。

拓扑排序的实现可以使用深度优先搜索（DFS）或者广度优先搜索（BFS）两种方式。下面我将分别介绍这两种实现方法。

1. 深度优先搜索实现拓扑排序 深度优先搜索的基本思想是从起始节点开始，依次访问其相邻节点，并进行递归访问。在拓扑排序中，我们可以通过递归地访问某个节点的所有邻接节点，直到没有邻接节点可以访问，然后将该节点加入到排序结果中。

具体步骤如下：

1. 初始化一个栈，用于存储已经访问过的节点。
2. 从图中的任意节点开始进行深度优先搜索。
3. 对于当前节点，首先访问其所有未被访问的邻接节点，并递归地进行深度优先搜索。
4. 当没有未被访问的邻接节点时，将当前节点加入到栈中。
5. 重复以上步骤，直到所有节点都被访问过。
6. 从栈中按照逆序依次取出节点，即可得到拓扑排序的结果。

下面是使用深度优先搜索实现拓扑排序的C++代码：

#include<iostream>
#include<vector>
#include<stack>
using namespace std;

vector<vector<int>> adjacencyList;  // 邻接表
vector<bool> visited;  // 记录节点是否被访问过
stack<int> result;  // 存储拓扑排序的结果

void dfs(int node) {
    visited[node] = true;
    for (int i = 0; i < adjacencyList[node].size(); i++) {
        int nextNode = adjacencyList[node][i];
        if (!visited[nextNode]) {
            dfs(nextNode);
        }
    }
    result.push(node);  // 将节点加入到排序结果中
}

void topologicalSort(int numNodes) {
    visited.resize(numNodes, false);  // 初始化visited数组
    for (int i = 0; i < numNodes; i++) {
        if (!visited[i]) {
            dfs(i);  // 从未被访问过的节点开始进行深度优先搜索
        }
    }
    while (!result.empty()) {
        cout << result.top() << " ";  // 输出拓扑排序的结果
        result.pop();
    }
}

int main() {
    int numNodes, numEdges;
    cin >> numNodes >> numEdges;
    adjacencyList.resize(numNodes);
    for (int i = 0; i < numEdges; i++) {
        int u, v;
        cin >> u >> v;
        adjacencyList[u].push_back(v);  // 构建邻接表
    }
    topologicalSort(numNodes);
    return 0;
}

1. 关键路径 关键路径是指在一个有向无环图中，从开始节点到结束节点的一条路径上，所有活动所需的时间或者资源之和达到最大。关键路径问题是项目管理中的重要问题之一，它可以用来确定项目中的关键活动和总工期。

关键路径算法基于拓扑排序，通过对任务进行排序，计算每个任务的最早开始时间（EST）和最晚开始时间（LST），以及每个任务的总工期（TF）。具体步骤如下：

1. 对有向无环图进行拓扑排序，得到任务的执行顺序。
2. 初始化所有任务的 EST 值为 0，并依次计算每个任务的 EST 值：EST(i) = max{EST(j) + duration(j)}, j 是 i 的前继任务。
3. 初始化所有任务的 LST 值为各个任务的 TF 值，并依次计算每个任务的 LST 值：LST(i) = min{LST(j) - duration(i)}, j 是 i 的后继任务。
4. 计算每个任务的 TF 值：TF(i) = LST(i) - EST(i)。
5. 对于关键活动，它的 EST 值和 LST 值相等，TF 值为 0；对于非关键活动，它的 EST 值和 LST 值不相等，TF 值大于 0。

下面是使用关键路径算法实现计算关键路径的C++代码：

#include<iostream>
#include<vector>
#include<stack>
using namespace std;

vector<vector<int>> adjacencyList;  // 邻接表
vector<int> duration;  // 存储每个任务的持续时间
vector<bool> visited;  // 记录节点是否被访问过
vector<int> EST;  // 存储每个任务的最早开始时间
vector<int> LST;  // 存储每个任务的最晚开始时间
vector<int> TF;  // 存储每个任务的总工期

void dfs(int node) {
    visited[node] = true;
    for (int i = 0; i < adjacencyList[node].size(); i++) {
        int nextNode = adjacencyList[node][i];
        if (!visited[nextNode]) {
            dfs(nextNode);
        }
        EST[node] = max(EST[node], EST[nextNode] + duration[nextNode]);  // 计算最早开始时间
    }
}

void topologicalSort(int numNodes) {
    visited.resize(numNodes, false);  // 初始化visited数组
    for (int i = 0; i < numNodes; i++) {
        if (!visited[i]) {
            dfs(i);  // 从未被访问过的节点开始进行深度优先搜索
        }
    }
}

void calculateLST(int node) {
    visited[node] = true;
    for (int i = 0; i < adjacencyList[node].size(); i++) {
        int nextNode = adjacencyList[node][i];
        if (!visited[nextNode]) {
            calculateLST(nextNode);
        }
        LST[node] = min(LST[node], LST[nextNode] - duration[node]);  // 计算最晚开始时间
    }
}

void calculateTF(int numNodes) {
    visited.resize(numNodes, false);  // 初始化visited数组
    for (int i = 0; i < numNodes; i++) {
        LST[i] = EST[i];  // 初始化LST值为EST值
    }
    for (int i = 0; i < numNodes; i++) {
        if (!visited[i]) {
            calculateLST(i);  // 从未被访问过的节点开始进行深度优先搜索
        }
    }
    for (int i = 0; i < numNodes; i++) {
        TF[i] = LST[i] - EST[i];  // 计算总工期
    }
}

int main() {
    int numNodes, numEdges;
    cin >> numNodes >> numEdges;
    adjacencyList.resize(numNodes);
    duration.resize(numNodes);
    EST.resize(numNodes);
    LST.resize(numNodes);
    TF.resize(numNodes);
    for (int i = 0; i < numEdges; i++) {
        int u, v;
        cin >> u >> v;
        adjacencyList[u].push_back(v);  // 构建邻接表
    }
    for (int i = 0; i < numNodes; i++) {
        cin >> duration[i];
    }
    topologicalSort(numNodes);
    calculateTF(numNodes);
    for (int i = 0; i < numNodes; i++) {
        cout << "Task " << i << ": EST=" << EST[i] << ", LST=" << LST[i] << ", TF=" << TF[i] << endl;
        if (EST[i] == LST[i]) {
            cout << "Task " << i << " is a critical task." << endl;
        }
    }
    return 0;
}

以上就是使用C++实现拓扑排序和关键路径的代码详解