拓朴排序，关键路径

 1)拓朴排序：有向无环图；

/**
    1)拓朴排序：有向无环图；
    vector<int> Adj[maxn]; //邻接表
    int inDegree[maxn];  //入度数组
    int Nv,Ne; //顶点数，边数；

    bool topSort()
    {
        int num=0;
        queue<int> q;
        for(int i=0;i<Nv;++i)
        {
            if(inDegree[i]==0)
                q.push(i);
        }

        while(!q.empty())
        {
            int u=q.front();
            printf("%d ",u);
            q.pop();
            for(int i=0;i<Adj[u].size();++i)
            {
                int v=Adj[u][i];
                inDegree[v]--;
                if(indegree[v] == 0)
                    q.push(v);
            }
            ++num;
        }

        if(num == Nv)
            return true;
        retuen false;
    }
*/

2) e[r],l[r]:分别表示活动 ar 的最早开始时间和最迟开始时间；
    当e[r] == l[r] 说明活动 ar 是关键活动；

    ve[i],vl[i] : 表示事件 i 的最早发生时间和最迟发生时间；

    事件 Vi 经过活动 ar 到达 事件 Vj；那么 e[r]=ve[i], l[r]=vl[j]-length[r];
*/

/**

    3) 通过前驱节点 ve[il] ~ ve[ik]的值更新 ve[j]的值：ve[j] = max{ve[ip] + length[rp]};

 

/**
    2) e[r],l[r]:分别表示活动 ar 的最早开始时间和最迟开始时间；
    当e[r] == l[r] 说明活动 ar 是关键活动；

    ve[i],vl[i] : 表示事件 i 的最早发生时间和最迟发生时间；

    事件 Vi 经过活动 ar 到达 事件 Vj；那么 e[r]=ve[i], l[r]=vl[j]-length[r];
*/

/**

    3) 通过前驱节点 ve[il] ~ ve[ik]的值更新 ve[j]的值：ve[j] = max{ve[ip] + length[rp]};

    代码：
    //拓朴排序，顺便求ve数组；
    stack<int> topOrder;  //用栈存储拓朴排序的结果，方便后面计算vl 数组；

    bool topSort()
    {
        queue<int> q;
        for(int i=0;i<n;++i)
        {
            if(inDegree[i]==0)
                q.push(i);
        }

        while(!q.empty())
        {
            int u=q.front();
            q.pop();
            topOrder.push(u);
            for(int i=0;i<Adj[u].size();++i)
            {
                int v=Adj[u][i].v;
                inDegree[v]--;
                if(inDegree[v]==0)
                   1)拓朴排序：有向无环图； q.push(v);

                if(ve[u]+Adj[u][i].cost > ve[v])
                    ve[v]=ve[u]+Adj[u][i].cost;
            }
        }

        if(topOrder.size() == n)
            return true;
        else
            return false;
    }
*/

 4) 通过 vi的后继节点 vjl~vjk 来推出vi的值： vi = min{vl[jp]-length[rp]};

/**
    4) 通过 vi的后继节点 vjl~vjk 来推出vi的值： vi = min{vl[jp]-length[rp]};

    代码：
    stack<int> topOrder;  //用栈存储拓朴排序的结果，方便后面计算vl 数组；

    bool topSort()
    {
        queue<int> q;
        for(int i=0;i<n;++i)
        {
            if(inDegree[i]==0)
                q.push(i);
        }

        while(!q.empty())
        {
            int u=q.front();
            q.pop();
            topOrder.push(u);
            for(int i=0;i<Adj[u].size();++i)
            {
                int v=Adj[u][i].v;
                inDegree[v]--;
                if(inDegree[v]==0)
                    q.push(v);

                if(ve[u]+Adj[u][i].cost > ve[v])
                    ve[v]=ve[u]+Adj[u][i].cost;
            }
        }

        int Size=topOrder.size();
        
        fill(vl,vl+n,ve[n-1]);
        while(!topOrder.empty())
        {
            int u=topOrder.top();
            topOrder.pop();
            for(int i=0;i<Adj[u].size();++i)
            {
                int v=Adj[u][i].v;

                if(vl[v] - Adj[u][i].cost < vl[u])
                    vl[u] = vl[v] - Adj[u][i].cost;
            }
        }

        if(Size == n)
            return true;
        else
            return false;
    }

*/

 5）求关键路径长度；
    关键路径，不是有向无环图返回-1，否则返回关键路径长度；

/**
    5）求关键路径长度；
    关键路径，不是有向无环图返回-1，否则返回关键路径长度；

    代码：
    int CriticalPath()
    {
        memset(ve,0,sizeof(ve));
        if(topSort() == false)
            return -1;

        fill(vl,vl+n,ve[n-1]);
        while(!topOrder.empty())
        {
            int u=topOrder.top();
            topOrder.pop();
            for(int i=0;i<Adj[u].size();++i)
            {
                int v=Adj[u][i].v;
                if(vl[v] - Adj[u][i].cost < vl[u])
                    vl[u]=vl[v] - Adj[u][i].cost;
            }
        }

        for(int u=0;u<n;++u)
            for(int i=0;i<Adj[u].size();++i)
            {
                int v=Adj[u][i].v , cost=Adj[u][i].cost;
                int e=ve[u] , l=vl[v]-cost;

                if(e == l)
                    printf("%d->%d\n",u,v);
            }

        return ve[n-1];
    }

*/