中国大学MOOC-数据结构基础习题集、06-5、关键活动

题目链接：http://www.patest.cn/contests/mooc-ds/06-5

题目分析：这是一道考察图的拓扑排序——关键路径问题。在作业06-4的基础上不仅要求每个点的最早开始时间，还要求每个点的最晚结束时间，除此之外，还要知道每个活动的最早开始、最晚结束时间。活动的最早和最晚时间相等的活动，才是关键活动。

特别说明：

　　1. 这道题最关键的地方，就是在于整个活动的结束结点，并不一定是最后一个结点，而是earlist的中最大的那一个。所以如果你还想博主，latest[n-1]=earlist[n-1]，那就大错特错了，最起码最后一个case通不过去。求earlist最大值的代码如下：

　　int maxNumber = *max_element(earlist+1,earlist+n);

　　1.1 其实不一定要知道earlist数组中最大值的下标，只需要把这个最大值赋给latest数组的每一个元素就可以了，快捷方式如下：

    fill(latest+1, latest+n, maxNumber);

　　接下来我们就可以对出度为0的结点进行“拓扑排序”了。

　　2. 这道题最最关键的地方，就是case1（也就是测试用例2）的那个奇怪的输出。我们要做的第一步，就是在输入的时候，把输入次序也存起来。在输入的时候，我们不妨将入度、出度都计算好。

    for(int i=0; i<m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        Outdegree[a] ++;
        Indegree[b] ++;
        vec.push_back(node(i, a, b, c));
    }

　　2.1 我们首先不管那个“反序”，先将“正序”路径放在vector中。

    typedef pair<int, int> PAIR;
    vector<PAIR> route;
    for(int i=0; i<m; i++)
    {
        int j = vec[i].s;
        int k = vec[i].e;
        e[i] = earlist[j];
        l[i] = latest[k] - vec[i].l;
        if(e[i] == l[i])
        {
            route.push_back(PAIR(j, k));
        }
    }

　　2.2 接着，对route排序，按照起点升序排序：

    sort(route.begin(), route.end());

　　2.3 接着，利用一个临时的容器routeTemp，将起点相同的按照输入反序输出。flag标记是否是第一次，lastNum记录上次的起点，分为以下三种情况：

　　2.3.1 如果flag=true，证明是第一次，lastNum=j，并且把这条的路径压入routeTemp中。

　　2.3.2 如果flag=false并且j与lastNum不等，将routeTemp中按照输入次序从大到小排序（这个顺序我们在输入的时候就已经指定好了，可以使用sort和cmp函数很方便的排序），并且输出routeTemp中所有路径，清空routeTemp，且将当前路径压入routeTemp中。

　　2.3.2 如果flag=false并且j与lastNum相同，将当前路径压入routeTemp中。

    vector<node> routeTemp;
    int lastNum;
    int flag = true;
    for(int i=0; i<route.size(); i++)
    {
        int j = route[i].first;
        int k = route[i].second;
        if(flag == true)
        {
            flag = false;
            lastNum = j;

            for(int icount=0; icount<m; icount++)
            {
                if(vec[icount].s == j && vec[icount].e == k)
                {
                    routeTemp.push_back(vec[icount]);
                    break;
                }
            }
        }
        else if(flag == false && j != lastNum)
        {
            sort(routeTemp.begin(), routeTemp.end(), cmpForRoute);
            for(int i=0; i<routeTemp.size(); i++)
            {
                cout << routeTemp[i].s << "->" << routeTemp[i].e << endl;
            }
            routeTemp.clear();
            for(int icount=0; icount<m; icount++)
            {
                if(vec[icount].s == j && vec[icount].e == k)
                {
                    routeTemp.push_back(vec[icount]);
                    break;
                }
            }
            lastNum = j;
        }
        else if(flag == false && j == lastNum)
        {
            for(int icount=0; icount<m; icount++)
            {
                if(vec[icount].s == j && vec[icount].e == k)
                {
                    routeTemp.push_back(vec[icount]);
                    break;
                }
            }
        }
    }

代码分析：

　　前面的特别说明已经很详细的解释了本题的重点，相信看过的童鞋对此题已经有了想法。如果你的思路已经明确的话，就不要继续看了，赶紧做题去。如果对整体把握不是那么好的话，不妨阅读一下整体的代码。相关注释已经打好，就不再赘述了。

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

#define MAXNUM 100000000
using namespace std;

struct node
{
    int i;  //用来标记次序
    int s;
    int e;
    int l;
    node(int ii, int a, int b, int c):i(ii), s(a), e(b), l(c) {}
};

int cmp(const node &a, const node &b)
{
    return a.e < b.e;
}

int cmpForRoute(const node &a, const node &b)
{
    if(a.s != b.s)
        return a.s < b.s;
    else
        return a.i > b.i;
}

int main()
{
    int n, m;
    cin >> n >> m;
    n ++;
    // earlist 最早完成时间
    int *earlist = new int[n];
    // latest 最晚完成时间
    int *latest = new int[n];
    // Indegree 入度
    int *Indegree = new int[n];
    // Outdegree 出度
    int *Outdegree = new int[n];
    // 初始化
    for(int i=0; i<n; i++)
    {
        Indegree[i] = 0;
        Outdegree[i] = 0;
        earlist[i] = 0;
        latest[i] = MAXNUM;
    }

    vector<node> vec;

    for(int i=0; i<m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        Outdegree[a] ++;
        Indegree[b] ++;
        vec.push_back(node(i, a, b, c));
    }

    sort(vec.begin(), vec.end(), cmp);

    queue<int> Q;
    // 将所有入度为0的点放入队列中
    for(int V=1; V<n; V++)
        if(Indegree[V] == 0)
            Q.push(V);
    // 记录有多少个点，用来判断是否有回路
    int cnt = 0;
    // 正向求最早完成时间
    while( Q.size() != 0)
    {
        int V = Q.front();
        Q.pop();
        cnt++;
        for ( int i=0; i<m; i++ )
        {
            if ( vec[i].s == V)
            {
                int W = vec[i].e;
                earlist[W] = max(earlist[W], earlist[V] + vec[i].l);
                if ( --Indegree[W] == 0)
                    Q.push(W);
            }
        }
    }
    // 判断是否有环
    if ( ++cnt != n  )
    {
        cout << "0" << endl;
        return 0;
    }
    // 反向求最晚完成时间，出度为0的结点就是终点了
    for(int V=1; V<n; V++)
        if(Outdegree[V] == 0)
            Q.push(V);
    // 将最后一个结点的earlist赋值给latest
    int maxNumber = *max_element(earlist+1,earlist+n);
    cout << maxNumber << endl;
    fill(latest+1, latest+n, maxNumber);
    while( Q.size() != 0)
    {
        int W = Q.front();
        Q.pop();
        cnt++;
        for ( int i=0; i<m; i++ )
        {
            if ( vec[i].e == W)
            {
                int V = vec[i].s;
                latest[V] = min(latest[V], latest[W] - vec[i].l);
                if ( --Outdegree[V] == 0)
                    Q.push(V);
            }
        }
    }
    // 求每个活动的e[i]和l[i]
    int *e = new int [m];
    int *l = new int [m];
    fill(e, e+m, 0);
    fill(l, l+m, 0);
    // 将路径存储在vector容器里
    typedef pair<int, int> PAIR;
    vector<PAIR> route;
    for(int i=0; i<m; i++)
    {
        int j = vec[i].s;
        int k = vec[i].e;
        e[i] = earlist[j];
        l[i] = latest[k] - vec[i].l;
        if(e[i] == l[i])
        {
            route.push_back(PAIR(j, k));
        }
    }
    // 为了应付那个奇怪的输出，需要对容器排序
    sort(route.begin(), route.end());
    // 临时存储路径，用来反序输出
    vector<node> routeTemp;
    int lastNum;
    int flag = true;
    for(int i=0; i<route.size(); i++)
    {
        int j = route[i].first;
        int k = route[i].second;
        if(flag == true)
        {
            flag = false;
            lastNum = j;

            for(int icount=0; icount<m; icount++)
            {
                if(vec[icount].s == j && vec[icount].e == k)
                {
                    routeTemp.push_back(vec[icount]);
                    break;
                }
            }
        }
        else if(flag == false && j != lastNum)
        {
            sort(routeTemp.begin(), routeTemp.end(), cmpForRoute);
            for(int i=0; i<routeTemp.size(); i++)
            {
                cout << routeTemp[i].s << "->" << routeTemp[i].e << endl;
            }
            routeTemp.clear();
            for(int icount=0; icount<m; icount++)
            {
                if(vec[icount].s == j && vec[icount].e == k)
                {
                    routeTemp.push_back(vec[icount]);
                    break;
                }
            }
            lastNum = j;
        }
        else if(flag == false && j == lastNum)
        {
            for(int icount=0; icount<m; icount++)
            {
                if(vec[icount].s == j && vec[icount].e == k)
                {
                    routeTemp.push_back(vec[icount]);
                    break;
                }
            }
        }
    }
    // 将剩余元素依次输出
    for(int i=0; i<routeTemp.size(); i++)
    {
        cout << routeTemp[i].s << "->" << routeTemp[i].e << endl;
    }
    return 0;
}

AC成果：