​> 活动地址：CSDN21天学习挑战赛
学习的最大理由是想摆脱平庸，早一天就多一份人生的精彩；迟一天就多一天平庸的困扰。

题目描述

假定一个工程项目由一组子任务构成，子任务之间有的可以并行执行，有的必须在完成了其它一些子任务后才能执行。“任务调度”包括一组子任务、以及每个子任务可以执行所依赖的子任务集。
比如完成一个专业的所有课程学习和毕业设计可以看成一个本科生要完成的一项工程，各门课程可以看成是子任务。有些课程可以同时开设，比如英语和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

说明

代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
来源PTA：https://pintia.cn/problem-sets/15/problems/719

解题代码

#include
#include
typedef struct{
    int v,u,c;
    int next;
}T;
typedef struct{
    int data[105];
    int rear;
    int front;
}QUE;
int in[105];//入度
int out[105];//出度
T edge[10005];
int cnt=0;
int head[105];
void add_edge(int v,int u,int c)
{
    cnt++;
    edge[cnt].next=head[v];
    edge[cnt].v=v;
    edge[cnt].u=u;
    edge[cnt].c=c;
    head[v]=cnt;
}
void push_back(QUE *q,int data){
    q->data[q->rear]=data;
    q->rear=(q->rear+1)%105;
}

void pop(QUE *q){
    q->front=(q->front+1)%105;
}

int front(QUE *q){
    return q->data[q->front];
}

int isEmpty(QUE *q){
    if(q->rear==q->front)return 1;
    return 0;
}
void clear(QUE *q){
    q->rear=q->front=0;
}
void Solution(int n)
{
    int dist[n+1];//正向拓扑
    int dist2[n+1];//逆向拓扑
    int sum=0;
    int t;
    int max=0;
    QUE *q = (QUE *)malloc(sizeof(QUE));
    clear(q);
    for(int i=1;i<=n;i++){
        if(in[i]==0) {
            push_back(q,i);
        }
        dist[i]=0;
    }
    while(!isEmpty(q)){//队列判空，这个循环只找最长所需时间和记录各个点的最迟到达时间
        t=front(q);
        sum++;
        pop(q);
        //printf("%d\n",cnt);
        for(int i=head[t];i!=0;i=edge[i].next){
            in[edge[i].u]--;//入度减一
            if(edge[i].c+dist[t]>dist[edge[i].u]){//记录每个环节到达的最迟时间
                dist[edge[i].u]=edge[i].c+dist[t];
            }
            if(in[edge[i].u]==0){//当入度等于0了就入队
                push_back(q,edge[i].u);
            }
            //printf("%d ->%d:%d\n",t,edge[i].u,dist[edge[i].u]);
            if(max<dist[edge[i].u]){
                max=dist[edge[i].u];//找到花费时间最长的时间，即整个任务完成的最短时间
            }
            
        }
    }
    if(sum==n){//如果计数相等，那么任务调度可行，开始输出
        printf("%d\n",max);
        clear(q);
        //逆拓扑，找到逆序的最短花费时间
       for(int i=1;i<=n;i++){//初始化路径dist2
           if(!out[i])push_back(q,i);//将出度为0的全部放入队列
           dist2[i]=max;
       }
        while(!isEmpty(q)){
            t=front(q);
            pop(q);
            for(int j=1;j<=n;j++){//遍历星图中的每一个节点
                for(int i=head[j];i!=0;i=edge[i].next){
                    if(edge[i].u==t){//如果终点等于当前要找的点
                        out[edge[i].v]--;
                        if(dist2[edge[i].v]>dist2[t]-edge[i].c){//找出最短路径
                            dist2[edge[i].v]=dist2[t]-edge[i].c;
                        }
                        if(out[edge[i].v]==0){
                            push_back(q,edge[i].v);
                        }
                    }
                }
            }
            
        }
        for(int j=1;j<=n;j++){//遍历星图，判断从起点出发和从终点出发是否花费时间相同，相同就是关键路径
            for(int i=head[j];i!=0;i=edge[i].next){
                if(dist[edge[i].u]==dist2[edge[i].u]&&dist2[edge[i].u]==(dist[edge[i].v]+edge[i].c)){
                    printf("%d->%d\n",edge[i].v,edge[i].u);
                }
            }
        }
    }else{
        printf("0\n");
    }
    
    
}

int main()
{
    int n,m;
    int v,w,c;
    while(scanf("%d %d",&n,&m)!=EOF){
        memset(head,0,sizeof(head));
        memset(out,0,sizeof(out));
        memset(in,0,sizeof(in));
        for(int i=0;i<m;i++){
            scanf("%d %d %d",&v,&w,&c);
            add_edge(v,w,c);
            in[w]++;
            out[v]++;
        }
        Solution(n);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

解题思路

关键路径问题，AOE网具有以下两个特点：

1. 只有在某顶点所代表的事件发生后，从该顶点出发的各有向边所代表的活动才能开始
2. 只有在进入某定点的各有向边所代表的活动都已结束时，该定点所代表的事件才能发生。

根据这个特性其实要做三件事情，正向拓扑，逆向拓扑，求弧边以及到达该点的时间是否相同。
其实拓扑的时候有点生成树的意思在那里，但是开始拓扑的点必须是出度或者入度为0的点，正向拓扑时我们要找入度为0的点进行拓扑，此时的拓扑排序找的是到每个点的最短时间，得出的最终结果就是我们要的调度时间。
逆向拓扑的时候，遇到汇点我们求的是最小值，表示的是这个最迟的开始时间，这样，看下图就能看出来，只要开始时间和到达时间相同的点一定是关键点，把路径连起来就是关键路径

我用的是前向星的结构，这样子我的遍历就麻烦一点，没有用矩阵的方便，但是也能写。