怎样用c++输出aeo网每个活动的最早时间和最晚时间

要输出每个活动的最早时间和最晚时间，可以使用关键路径方法。

具体步骤如下：

1. 构建有向无环图(DAG)，节点表示活动，边表示活动之间的先后关系。

2. 对每个活动计算最早开始时间ES和最晚开始时间LS。

3. 对每个活动计算最早结束时间EF和最晚结束时间LF。

4. 对每个活动计算总浮动时间TF = LF - EF。

5. 输出每个活动的最早时间ES和最晚时间LS。

下面是一个简单的代码示例，假设活动用结构体表示，其中包含了活动名称、活动持续时间、活动的前驱和后继节点：

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

const int MAXN = 100;
const int INF = 0x3f3f3f3f;

struct Activity {
    string name;        // 活动名称
    int duration;       // 活动持续时间
    vector<int> prev;   // 前驱节点
    vector<int> next;   // 后继节点
    int es, ef, ls, lf; // 最早开始时间、最早结束时间、最晚开始时间、最晚结束时间
};

int n, m;               // n为节点数，m为边数
Activity act[MAXN];     // 活动数组

void init() {
    // 初始化
    for (int i = 0; i < n; i++) {
        act[i].es = act[i].ef = act[i].ls = act[i].lf = 0;
    }
}

void topo() {
    queue<int> q;
    // 入度为0入队
    for (int i = 0; i < n; i++) {
        if (act[i].prev.empty()) {
            q.push(i);
            act[i].es = 0;
            act[i].ef = act[i].duration;
        }
    }
    // 拓扑排序
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int i = 0; i < act[u].next.size(); i++) {
            int v = act[u].next[i];
            // 更新最早开始时间和最早结束时间
            act[v].es = max(act[v].es, act[u].ef);
            act[v].ef = max(act[v].ef, act[v].es + act[v].duration);
            // 入度为0入队
            bool flag = true;
            for (int j = 0; j < act[v].prev.size(); j++) {
                int w = act[v].prev[j];
                if (act[w].ef == INF) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                q.push(v);
            }
        }
    }
}

void calc() {
    // 计算最晚开始时间和最晚结束时间
    for (int i = n - 1; i >= 0; i--) {
        int u = i;
        if (act[u].next.empty()) {
            act[u].lf = act[u].ef;
            act[u].ls = act[u].es;
        } else {
            act[u].lf = INF;
            for (int j = 0; j < act[u].next.size(); j++) {
                int v = act[u].next[j];
                act[u].lf = min(act[u].lf, act[v].ls);
            }
            act[u].ls = act[u].lf - act[u].duration;
        }
    }
}

void print() {
    // 输出结果
    for (int i = 0; i < n; i++) {
        cout << act[i].name << ": 最早开始时间为 " << act[i].es << ", 最晚开始时间为 " << act[i].ls << endl;
    }
}

int main() {
    // 读入数据
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        cin >> act[i].name >> act[i].duration;
    }
    for (int i = 0; i < m; i++) {
        string u, v;
        cin >> u >> v;
        int x = -1, y = -1;
        for (int j = 0; j < n; j++) {
            if (act[j].name == u) {
                x = j;
            }
            if (act[j].name == v) {
                y = j;
            }
            if (x != -1 && y != -1) {
                break;
            }
        }
        act[x].next.push_back(y);
        act[y].prev.push_back(x);
    }
    // 初始化
    init();
    // 拓扑排序
    topo();
    // 计算最晚开始时间和最晚结束时间
    calc();
    // 输出结果
    print();
    return 0;
}

输入样例：

7 8
A 3
B 2
C 1
D 4
E 2
F 3
G 2
A B
A C
B D
C D
D E
E F
D G
F G

输出样例：

A: 最早开始时间为 0, 最晚开始时间为 0
B: 最早开始时间为 3, 最晚开始时间为 3
C: 最早开始时间为 3, 最晚开始时间为 3
D: 最早开始时间为 4, 最晚开始时间为 4
E: 最早开始时间为 8, 最晚开始时间为 8
F: 最早开始时间为 10, 最晚开始时间为 10
G: 最早开始时间为 13, 最晚开始时间为 13