How Long Does It Take

好长时间没写博客了，真心惭愧啊！

废话少说，原题链接：https://pta.patest.cn/pta/test/1342/exam/4/question/24939

题目如下：

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 NNN (≤100le 100≤100), the number of activity check points (hence it is assumed that the check points are numbered from 0 to N−1N-1N−1), and MMM, the number of activities. Then MMM 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

这道题不难，本质上就是一道拓扑排序的问题，只不过增加了权重，成为了一道关键路径的问题，此类拓扑排序问题的核心思想就是先在图中找到入度为0的点，对其进行操作，然后将于该点相邻的边删除，继续对剩下的图重复这一过程。为了提高算法的效率，陈越老师讲过可以在每次删除边时，检查其它顶点是否入度为0，如果为0就将其放在一个容器里面（我用的是队列），下次用的时候就可以直接从容器里面取出。拓扑排序一般是较为稀疏的图，应该用邻接表存储图合适，但我为了写起来简单，就用了邻接矩阵。以下是我的代码：

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define Max 105
#define INFINITY 65535
typedef struct QNode{
    int front,rear;
    int Data[Max];
    int Maxsize;
}Quenue;

Quenue *CreateQ(int N)
{
    Quenue *Q=(Quenue *)malloc(sizeof(struct QNode));
    Q->front=Q->rear=0;
    Q->Maxsize=N+1;
    return Q;
}

bool IsFull(Quenue *Q)
{
    return ((Q->front+1)%Q->Maxsize == Q->rear);
}

void Push(Quenue *Q,int v)
{
    if (!IsFull(Q))
    {
        Q->front=(Q->front+1)%Q->Maxsize;
        Q->Data[Q->front]=v;
    }
}

bool IsEmpty(Quenue *Q)
{
    return (Q->front==Q->rear);
}

int Pop(Quenue *Q)
{
    if (!IsEmpty(Q))
    {
        Q->rear=(Q->rear+1)%Q->Maxsize;
        return (Q->Data[Q->rear]);
    }
}

int G[Max][Max];
int N,M;
 51 
void TopSort()
{
    int Indegree[Max]={0};
    int v,w,weight,cnt=0;
    int endcnt=0; //有多个终点是，用来记录是否为终点的变量
    int dist[Max]={0};
    Quenue *Q=CreateQ(N);
   /* 初始化各顶点的入度值 */
    for (v=0;v<N;v++)
    {
        for (w=0;w<N;w++)
        {
            if ( G[w][v]<INFINITY)Indegree[v]++;
        }
    }
    /*入度为0的顶点入队 */
    for (v=0;v<N;v++)
    {
        if (Indegree[v]==0){Push(Q,v);}
    }
    /*拓扑排序*/
    weight=0;
    while (!IsEmpty(Q))
    {
        v=Pop(Q);
        cnt++;
        for (w=0;w<N;w++)
        {
            if (G[v][w]<INFINITY)
            {
                if (dist[v]+G[v][w]>dist[w])dist[w]=dist[v]+G[v][w];
                if (--Indegree[w]==0)Push(Q,w);
                endcnt++;
            }
        }
        if (endcnt==0)  //此时v为终点
        {
            if (dist[v]>weight)weight=dist[v];
        }
        endcnt=0;
    }
    if (cnt!=N)printf("Impossible");
    else printf("%d",weight);
    return ;
}

int main()
{
    scanf("%d %d",&N, &M);
    int i,j,v,w,weight;
    for (i=0;i<N;i++){
    for (j=0;j<N;j++){G[i][j]=INFINITY;}}
    for (i=0;i<M;i++)
    {
        scanf("%d %d %d",&v, &w, &weight);
        G[v][w]=weight;
    }
    TopSort();
    return 0;
}