关键路径-课程设计

代码如下

#include  
#include  
#include  
#include  
#include  
#include  
#include    
using namespace std;   
typedef long long ll;  
const int maxm = 20;   
const int maxn = 100;  
const int inf = 0x3f3f3f3f;  
struct node {  
    int x, y, w;  
    int next;  
};  
node edge[maxm];  
int n, m;  
int head[maxn];  
//e代表活动开始的最早时间, l活动最迟开始的时间, ve[i]事件最早发生的时间, vl[i]事件最迟发生的时间 ,
//indegree[i]顶点的入度   
//这个地方没必要分别为e，l开数组了，因为最后只是进行赋值，然后比较两个数是否相等而已
int e, l, ve[maxn], vl[maxn], indegree[maxn]; 
template<class DataType>
struct Node {
    DataType data;
    Node *next;
};
template<class DataType>
class LinkStack
{
    public:
        LinkStack();
        ~LinkStack(){};
        void Push(DataType x);
        DataType Pop();
        DataType Top();
        int Empty();
        int top;
};
template<class DataType>
void LinkStack::Push(DataType x)
{
    Node *s=new Node;
    s->data=x;
    s->next=top; 
    top=s; 
}
template<class DataType>
DataType LinkStack::Pop()
{
    DataType p;
    node n;
    if(top==-1) throw"下溢";
    n.x=top;
    p=top;
    top=n.next;
    delete p;
    return n.x;
}
template<class DataType>
DataType LinkStack::Top()
{
    return top;
}
template<class DataType>
int LinkStack::Empty()
{
    if(top==-1)
    return 0;
    else 
    return 1;
}
stack<int> s, t;    
//s代表逆序的拓扑排序 ，t代表入度为零的栈，里面存放入度为零的点   
int TopologicalSort() {  
    int i, cnt = 0;  
    for(i=1; i<=n; ++i) //入度为零的点入栈   
        if(!indegree[i]) {  
            t.push(i);  
            ++cnt;  
            //printf("%d ", i);  
        }  
    while(!t.empty()) {  
        int a = t.top();  
        s.push(a);  
        //printf("%d ", a);  
        t.pop();  
        //去掉与入度为零的点的相连的边，对应的终点的入度减一   
        int k = head[a];  
        while(k != -1) {  
            if(!--indegree[edge[k].y]) {//终点的度减一后，如果度为零，入栈   
                t.push(edge[k].y);  
                ++cnt;  
                //printf("%d ", edge[k].y);  
            }  
            if(ve[edge[k].y] < ve[a] + edge[k].w) //正拓扑排序求事件发生的最早时间ve[i]，
                                                    //到edge[k].y的最长路径   
                ve[edge[k].y] = ve[a] + edge[k].w;  
            k = edge[k].next;     
        }  
    }  
    if(cnt < n)   
        return 0;  
    return 1;  
}  


int main()  
{  
    int i,sum=0,left=0,aa=0;  
    memset(head, -1, sizeof(head));  
    scanf("%d%d", &n, &m);   
    //建立邻接表   
    for(i=1; i<=m; ++i) {  
        scanf("%d%d%d", &edge[i].x, &edge[i].y, &edge[i].w);  
        ++indegree[edge[i].y];  //终点的入度加一   
        edge[i].next = head[edge[i].x];
        head[edge[i].x] = i;  
    }        
    if(TopologicalSort() == 0) { //在 TopologicalSort()函数里面已经解决了ve的问题   
        printf("不存在关键路径,存在环\n");  
        return 0;  
    }       
    memset(vl, inf, sizeof(vl));  
    vl[n] = ve[n]; //最后一个事件的最迟发生事件就等于最早发生时间，因为是最后一件事，也就是说这个工程干完了，以后就没有事情做了   
    while(!s.empty()) { //逆拓扑排序求vl[i]   
        int a = s.top();  
        s.pop();  
        int k = head[a];  
        while(k != -1) {  
            if(vl[a] > vl[edge[k].y] - edge[k].w) {  
                vl[a] = vl[edge[k].y] - edge[k].w;  
            }  
            k = edge[k].next;  
        }  
    }  
    printf("\n关键活动(该活动不能推迟开工)有:\n");  
    for(i=1; i<=n; ++i)  {   
        int k = head[i];  
        while(k != -1) {  
            e = ve[i]; //该条边的起点代表事情，该条边表示的活动的最早发生时间就等于起点代表的事情的最早发生时间   
            //活动的最迟发生时间  
            l = vl[edge[k].y] - edge[k].w;  
            if(l == e) 
            {
                printf("%d %d %d\n", i, edge[k].y, edge[k].w); 
                if(i == 1)
                {
                    sum=edge[k].w;
                    left=edge[k].y; 
                    aa=i;
                   }
                else if(i == left && aa != i)   
                {
                    sum= sum + edge[k].w;
                    left=edge[k].y; 
                    aa=i;
                }
             } 

            k = edge[k].next;  
        }  
    }  
    printf("请输出最大路径长度：%d",sum);
    return 0;  
}  
/* 
9 11 
1 2 6 
1 3 4 
1 4 5 
2 5 1 
3 5 1 
4 6 2 
5 7 9 
5 8 7 
6 8 4 
7 9 2 
8 9 4 
*/

运行结果