08-图8 How Long Does It Take（25 分）邻接表和队列

Given the relations of all the activities of a project, you are supposed to find the earliest completion time of the project.

Input Specification:

Each input file contains one test case. Each case starts with a line containing two positive integers N (≤100), the number of activity check points (hence it is assumed that the check points are numbered from 0 to N−1), and M, the number of activities. Then M lines follow, each gives the description of an activity. For the i-th activity, three non-negative numbers are given: S[i], E[i], and L[i], where S[i] is the index of the starting check point, E[i] of the ending check point, and L[i] the lasting time of the activity. The numbers in a line are separated by a space.

Output Specification:

For each test case, if the scheduling is possible, print in a line its earliest completion time; or simply output "Impossible".

Sample Input 1:

9 12
0 1 6
0 2 4
0 3 5
1 4 1
2 4 1
3 5 2
5 4 0
4 6 9
4 7 7
5 7 4
6 8 2
7 8 4

Sample Output 1:

18

Sample Input 2:

4 5
0 1 1
0 2 2
2 1 3
1 3 4
3 2 5

Sample Output 2:

Impossible

我的答案

 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>

 #define ERROR -1
 #define false  0
 #define true   1
 #define MaxVertexNum 100
 #define INFINITY     65535
 #define MaxQueue 100
 typedef int Vertex;
 typedef int WeightType;
 typedef int bool;

 //边
 typedef struct ENode *PtrToENode;
 struct ENode {
     Vertex V1, V2;
     WeightType Weight;
 };
 typedef PtrToENode Edge;

 //邻接点
 typedef struct AdjVNode *PtrToAdjVNode;
 struct AdjVNode {
     Vertex AdjV;            //下标
     WeightType Weight;      //边权重
     PtrToAdjVNode Next;     //指向下一个邻接点
 };

 //顶点
 typedef struct VNode {
     PtrToAdjVNode FirstEdge;    //边表头指针
     // DataType Data;              //存顶点的户数据
 }AdjList[MaxVertexNum];

 //图结点
 typedef struct GNode *PtrToGNode;
 struct GNode {
     int Nv;
     int Ne;
     AdjList G;
 };
 typedef PtrToGNode LGraph;

 struct QNode {
     Vertex Data[MaxQueue];
     int rear;
     int front;
 };
 typedef struct QNode *Queue;

 int IsEmptyQ(Queue PtrQ)
 {
     return (PtrQ->front == PtrQ->rear);
 }

 void AddQ(Queue PtrQ, Vertex item)
 {
     if((PtrQ->rear+)%MaxQueue == PtrQ->front) {
         printf("Queue full");
         return;
     }
     PtrQ->rear = (PtrQ->rear+)%MaxQueue;
     PtrQ->Data[PtrQ->rear] = item;
 }

 Vertex DeleteQ(Queue PtrQ)
 {
     if(PtrQ->front == PtrQ->rear) {
         printf("Queue Empty");
         return -;
     } else {
         PtrQ->front = (PtrQ->front+)%MaxQueue;
         return PtrQ->Data[PtrQ->front];
     }
 }

 LGraph CreateGraph(int VertexNum)
 {
     Vertex V;
     LGraph Graph;

     Graph = (LGraph)malloc(sizeof(struct GNode));
     Graph->Nv = VertexNum;
     Graph->Ne = ;

     for(V=;V<Graph->Nv;V++)
         Graph->G[V].FirstEdge = NULL;

     return Graph;
 }

 void InsertEdge(LGraph Graph, Edge E)
 {
     PtrToAdjVNode NewNode;

     //有向边
     NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
     NewNode->AdjV = E->V2;
     NewNode->Weight = E->Weight;
     //向V1插入V2
     NewNode->Next = Graph->G[E->V1].FirstEdge;
     Graph->G[E->V1].FirstEdge = NewNode;
 }

 LGraph BuildGraph()
 {
     LGraph Graph;
     Edge E;
     int Nv, i;

     scanf("%d", &Nv);
     Graph = CreateGraph(Nv);

     scanf(" %d\n", &(Graph->Ne));
     if(Graph->Ne != ) {
         E = (Edge)malloc(sizeof(struct ENode));
         for(i=;i<Graph->Ne;i++) {
             scanf("%d %d %d\n", &E->V1, &E->V2, &E->Weight);
             InsertEdge(Graph, E);
         }
     }

     return Graph;
 }

 void PrintGraph(LGraph Graph)
 {
     Vertex V;
     PtrToAdjVNode W;
     for(V=;V<Graph->Nv;V++) {
         printf("%d:", V);
         for(W=Graph->G[V].FirstEdge;W;W=W->Next) {
             printf("[%3d %3d] ", W->AdjV, W->Weight);
         }
         printf("\n");
     }
 }

 /* 邻接表存储 - 拓扑排序算法 */
 bool TopSort( LGraph Graph, Vertex TopOrder[], Vertex Earliest[])
 { /* 对Graph进行拓扑排序,  TopOrder[]顺序存储排序后的顶点下标 */
     int Indegree[MaxVertexNum], cnt;
     Vertex V;
     PtrToAdjVNode W;

     Queue Q = (Queue)malloc(sizeof(struct QNode)*( Graph->Nv ));

     /* 初始化Indegree[] */
     for (V=; V<Graph->Nv; V++)
         Indegree[V] = ;

     /* 遍历图，得到Indegree[] */
     for (V=; V<Graph->Nv; V++)
         for (W=Graph->G[V].FirstEdge; W; W=W->Next)
             Indegree[W->AdjV]++; /* 对有向边<V, W->AdjV>累计终点的入度 */

     /* 将所有入度为0的顶点入列 */
     for (V=; V<Graph->Nv; V++)
         if ( Indegree[V]== ) {
             AddQ(Q, V);
             Earliest[V] = ;         //起点为0
         }

     /* 下面进入拓扑排序 */
     cnt = ;
     while( !IsEmptyQ(Q) ){
         V = DeleteQ(Q); /* 弹出一个入度为0的顶点 */
         TopOrder[cnt++] = V; /* 将之存为结果序列的下一个元素 */
         /* 对V的每个邻接点W->AdjV */
         for ( W=Graph->G[V].FirstEdge; W; W=W->Next )
             if ( --Indegree[W->AdjV] ==  ) {/* 若删除V使得W->AdjV入度为0 */
                 AddQ(Q, W->AdjV); /* 则该顶点入列 */
                 Earliest[W->AdjV] = Earliest[V] + W->Weight;
                 // if((Earliest[V]+W->Weight)>Earliest[W->AdjV] && Earliest[W->AdjV])
                     // Earliest[W->AdjV] = Earliest[V] + W->Weight;
             }
     } /* while结束*/

     if ( cnt != Graph->Nv )
         return false; /* 说明图中有回路, 返回不成功标志 */
     else
         return true;
 }

 int main()
 {
     LGraph Graph;
     WeightType Earliest[MaxVertexNum];
     Vertex TopOrder[MaxVertexNum],V;
     int ret;

     Graph = BuildGraph();
     // PrintGraph(Graph);
     ret = TopSort(Graph, TopOrder, Earliest);
     if(ret == false) {
         printf("Impossible");
     } else if(ret == true) {
         int max = Earliest[];
         for(int i=;i<Graph->Nv;i++) {
             // printf("%d: [%d]\n", i, Earliest[i]);
             if(max < Earliest[i])
                 max = Earliest[i];
         }
         printf("%d", max);
     }
     // printf("TopOrder:");
     // for(V=0;V<Graph->Nv;V++)
     //     printf("%d ", TopOrder[V]);
     // printf("\n");
     return ;
 }