18747 关键路径

### 思路

1. **建模问题**：将项目的事件和活动建模为有向无环图（DAG），其中事件是节点，活动是有权值的边。
2. **选择算法**：使用拓扑排序算法来确定节点的处理顺序，然后在拓扑排序的基础上计算最长路径。
3. **初始化**：创建一个入度数组来记录每个节点的入度，并创建一个距离数组来记录从起点到每个节点的最长路径。
4. **拓扑排序**：使用队列进行拓扑排序，依次处理入度为0的节点，并更新其邻接节点的入度和距离。
5. **计算最长路径**：在拓扑排序的过程中，更新从起点到每个节点的最长路径，最终得到从起点到终点的最长路径。

### 伪代码

```
function find_longest_path(n, m, edges):
    create an array in_degree of size n+1, initialized to 0
    create a graph as an adjacency list of size n+1
    create an array dist of size n+1, initialized to -INF
    create a queue q

    for each (a, b, x) in edges:
        graph[a].append((b, x))
        in_degree[b] += 1

    dist[1] = 0
    for i from 1 to n:
        if in_degree[i] == 0:
            q.push(i)

    while q is not empty:
        u = q.pop()
        for each (v, w) in graph[u]:
            if dist[u] + w > dist[v]:
                dist[v] = dist[u] + w
            in_degree[v] -= 1
            if in_degree[v] == 0:
                q.push(v)

    return dist[n]
```

### C++代码

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

using namespace std;

struct Edge {
    int from;
    int to;
    int weight;
};

int find_longest_path(int n, int m, vector<Edge>& edges) {
    vector<int> in_degree(n + 1, 0);
    vector<vector<pair<int, int>>> graph(n + 1);
    vector<int> dist(n + 1, -1e9); // Use a very small value instead of INT_MIN
    queue<int> q;

    for (const auto& edge : edges) {
        graph[edge.from].emplace_back(edge.to, edge.weight);
        in_degree[edge.to] += 1;
    }

    dist[1] = 0;
    for (int i = 1; i <= n; ++i) {
        if (in_degree[i] == 0) {
            q.push(i);
        }
    }

    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (const auto& neighbor : graph[u]) {
            int v = neighbor.first;
            int w = neighbor.second;
            if (dist[u] + w > dist[v]) {
                dist[v] = dist[u] + w;
            }
            in_degree[v] -= 1;
            if (in_degree[v] == 0) {
                q.push(v);
            }
        }
    }

    return dist[n];
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<Edge> edges(m);
    for (int i = 0; i < m; ++i) {
        cin >> edges[i].from >> edges[i].to >> edges[i].weight;
    }

    int result = find_longest_path(n, m, edges);
    cout << result << endl;

    return 0;
}

### 总结

1. **问题建模**：将项目的事件和活动建模为有向无环图，使用拓扑排序算法求解最长路径。
2. **算法选择**：使用拓扑排序算法，结合动态规划思想计算从起点到终点的最长路径。
3. **实现细节**：初始化入度数组和距离数组，使用队列进行拓扑排序，逐步更新节点的入度和距离。
4. **终止条件**：当队列为空时，输出从起点到终点的最长路径。