数据结构与算法题目集 7-11 关键活动 #关键路径 拓扑排序#

7-11 关键活动 (30分)

假定一个工程项目由一组子任务构成，子任务之间有的可以并行执行，有的必须在完成了其它一些子任务后才能执行。“任务调度”包括一组子任务、以及每个子任务可以执行所依赖的子任务集。

比如完成一个专业的所有课程学习和毕业设计可以看成一个本科生要完成的一项工程，各门课程可以看成是子任务。有些课程可以同时开设，比如英语和C程序设计，它们没有必须先修哪门的约束；有些课程则不可以同时开设，因为它们有先后的依赖关系，比如C程序设计和数据结构两门课，必须先学习前者。

但是需要注意的是，对一组子任务，并不是任意的任务调度都是一个可行的方案。比如方案中存在“子任务A依赖于子任务B，子任务B依赖于子任务C，子任务C又依赖于子任务A”，那么这三个任务哪个都不能先执行，这就是一个不可行的方案。

任务调度问题中，如果还给出了完成每个子任务需要的时间，则我们可以算出完成整个工程需要的最短时间。在这些子任务中，有些任务即使推迟几天完成，也不会影响全局的工期；但是有些任务必须准时完成，否则整个项目的工期就要因此延误，这种任务就叫“关键活动”。

请编写程序判定一个给定的工程项目的任务调度是否可行；如果该调度方案可行，则计算完成整个工程项目需要的最短时间，并输出所有的关键活动。

输入格式:

输入第1行给出两个正整数N(≤100)和M，其中N是任务交接点（即衔接相互依赖的两个子任务的节点，例如：若任务2要在任务1完成后才开始，则两任务之间必有一个交接点）的数量。交接点按1~N编号，M是子任务的数量，依次编号为1~M。随后M行，每行给出了3个正整数，分别是该任务开始和完成涉及的交接点编号以及该任务所需的时间，整数间用空格分隔。

输出格式:

如果任务调度不可行，则输出0；否则第1行输出完成整个工程项目需要的时间，第2行开始输出所有关键活动，每个关键活动占一行，按格式“V->W”输出，其中V和W为该任务开始和完成涉及的交接点编号。关键活动输出的顺序规则是：任务开始的交接点编号小者优先，起点编号相同时，与输入时任务的顺序相反。

输入样例:

7 8
1 2 4
1 3 3
2 4 5
3 4 3
4 5 1
4 6 6
5 7 5
6 7 2

输出样例:

17
1->2
2->4
4->6
6->7

题解:

第一次提交时只得了20分，以为只是简单地输出一条关键路径。

认真读题之后憨憨眉头一紧,发现事情没有那么简单。

步骤1：记录所有的关键路径（有若干条最长路）

步骤2：找出各条关键路径中涉及的所有边

步骤3：对这些边去重并根据读入时的顺序排序

之后重新写了一遍就AC了，分解问题之后其实还是蛮简单的嘛。

附上检验所用的一组输入输出样例：

3-1-4-6-5
3-1-4-7-5
3-2-4-7-5
3-2-4-6-5

9
1->4
2->4
3->2
3->1
4->7
4->6
6->5
7->5

 样例参考自https://blog.csdn.net/rxq20081235/article/details/60766993

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const int maxn = 110;
const int inf = 0x3f3f3f3f; // 无穷大常量
bool vis[maxn]; // 拓扑排序过程避免重复取出的标记
int n, m, g[maxn][maxn], id[maxn][maxn]; // 时空限制水，故没有使用链式前向星
struct node
{
    int deg, sum; // 入度和至此最长路径的长度
    vector<int> pre; // 保存每个点可能存在的若干前驱
} nodes[maxn];
struct edge
{
    int u, v; // 有向边的弧尾与弧头
    bool operator < (const edge& n) const
    {
        if (u == n.u) return id[u][v] > id[n.u][n.v];
        return u < n.u;
    }
};
set<edge> ans; // 保存各关键路径涉及的所有边，集合方便去重

inline const int read()
{
    int x = 0, f = 1; char ch = getchar();
    while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar(); }
    while (ch >= '0' && ch <= '9') { x = (x << 3) + (x << 1) + ch - '0'; ch = getchar(); }
    return x * f;
}

bool topsort()
{
    int cnt = 0;
    while (cnt < n)
    {
        int u = 0;
        for (int i = 1; i <= n; i++) // 找出一个入度为0的点
        {
            if (!vis[i] && !nodes[i].deg)
            {
                vis[i] = true;
                cnt++;
                u = i;
                break;
            }
        }
        if (!u) return false; // 存在环，拓扑排序失败
        for (int v = 1; v <= n; v++)
        {
            if (g[u][v] != inf) // 如果邻接
            {
                nodes[v].deg--; // 有向边弧头的点入度减一
                if (nodes[v].sum < nodes[u].sum + g[u][v]) // 如果存在更长路
                {
                    nodes[v].sum = nodes[u].sum + g[u][v];
                    nodes[v].pre.clear(); // 别忘了清空先前优化得到的前驱
                    nodes[v].pre.push_back(u); // 当前点是更优解的前驱
                }
                else if (nodes[v].sum == nodes[u].sum + g[u][v]) // 如果存在多条等长的最长路
                    nodes[v].pre.push_back(u);
            }
        }
    }
    return true;
}

void bfs(int des)
{
    queue<int> q;
    q.push(des);
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        for (auto v : nodes[u].pre) // 遍历以u为有向边弧头的所有最优前驱
        {
            q.push(v);
            ans.insert(edge{ v, u });
        }
    }
}

int main()
{
    n = read(); m = read();
    memset(g, 0x3f, sizeof g); // 邻接距离初始化为最大值
    for (int i = 1; i <= m; i++)
    {
        int u = read(), v = read(), w = read();
        g[u][v] = w;
        id[u][v] = i; // 时间戳，用于边排序
        nodes[v].deg++; // 出度加一
    }
    if (topsort()) // 拓扑排序成功，存在若干条关键路径
    {
        int last = 0, msum = 0;
        for (int i = 1; i <= n; i++) // 维护最长路径，找出终点
        {
            if (msum <= nodes[i].sum)
            {
                msum = nodes[i].sum;
                last = i;
            }
        }
        printf("%d\n", msum);
        bfs(last); // 搜索出各关键路径中涉及的边
        for (auto it : ans) printf("%d->%d\n", it.u, it.v);
    }
    else printf("0\n");
    return 0;
}