08-图8 How Long Does It Take

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 NN (le 100≤100), the number of activity check points (hence it is assumed that the check points are numbered from 0 to N-1N−1), and MM, the number of activities. Then MM 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<iostream>
#include<malloc.h>
#include<queue>
using namespace std;

#define INF (100000)
#define MAX 100
//如果采用邻接链表的形式构造图，在每一个顶点中接下存储的边是其相邻的边
typedef struct _Edge{
    int Adjv;
    int Weight;
    

    _Edge *Next;
}Edge,nedge;

typedef struct _VNode
{
    int  NodeName;
    
    nedge *first_edge;
}VNode;

typedef struct _Graph{
    int Vernum;
    int Edgnum;
    VNode G[MAX];

}MGraph;

MGraph *Graph;

void link_last(nedge *list, nedge *node)
{  nedge *p=list;
while(p->Next!=NULL)
{
    p=p->Next;
}
p->Next=node;
node->Next=NULL;
}

MGraph *BuildMyGraph(int N,int M)
{     MGraph *pG;
    pG=(MGraph*)malloc(sizeof( _Graph));//pG图必须要申请空间

    pG->Vernum=N;pG->Edgnum=M;

    //将点初始化
    for(int i=0;i<N;i++)
    {
        pG->G[i].NodeName=i;
    
        pG->G[i].first_edge=NULL;
    }
            //输入数据
      int c1,c2,w1,i,j;
    Edge *edge;
    for(i=0;i<pG->Edgnum;i++)
    {
        cin>>c1>>c2>>w1;
        edge=(Edge*)malloc(sizeof(_Edge));
        edge->Adjv=c2;edge->Weight=w1;edge->Next=NULL;
        for(j=0;j<pG->Vernum;j++)
        {
            if(c1==pG->G[j].NodeName)
            {
                if(pG->G[j].first_edge==NULL)
                {
                    pG->G[j].first_edge=edge;
                }
                else
                {
                    link_last(pG->G[j].first_edge,edge);
                }
            }
        }
    }
    return pG;
}
int TopSort(int Total)
{int Indegree[MAX],V;int TopOrder[MAX],i;int S[MAX];
  queue<int>Q; Edge *E;

  for( i=0;i<Graph->Vernum;i++)
         Indegree[i]=0;
  //计算其入度，每个顶点的入度
  for(i=0;i<Graph->Vernum;i++)
  {
      E=Graph->G[i].first_edge;
      while(E!=NULL)
      {
          Indegree[E->Adjv]++;
          E=E->Next;
      
      }
  }
  //找到入度为零的点
  for(i=0;i<Graph->Vernum;i++)
  {
        if(Indegree[i]==0)
            {  Q.push(i);
                S[i]=0;
        }
  }
  int cnt=0; int temp=0;
  while(!Q.empty())
  {
      V=Q.front();Q.pop();
      TopOrder[cnt++]=V;
      for(E=Graph->G[V].first_edge;E;E=E->Next)
      {
          temp=E->Weight;
            //这里只有一句话，只能计算工程完成要多久，如果深入，编写出其
            //是否有机动组
          S[E->Adjv]=S[V]+temp> S[E->Adjv]?S[V]+temp:S[E->Adjv];
          if(--Indegree[E->Adjv]==0)
               Q.push(E->Adjv);
      }
  }
     if(cnt!=Graph->Vernum)
           Total=-1;
     else
         Total=S[(cnt-1)];
    return Total;
}
int main()
{
    int N,M;
    cin>>N>>M;
Graph=BuildMyGraph(N,M);
    int Total=0;
    Total =TopSort(Total);
    if(Total!=-1)
    {
        cout<<Total<<endl;
    }
    else
    {
        cout<<"Impossible"<<endl;
    }
    return 0;
}