AOE

/*
*		AOE		Activity on edge network
*				Data: 2013/3 27
*										NolanJian
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAX_VERTEX 100
#define TRUE 1
#define FALSE 0
struct node;
struct hnode;
struct queue;
typedef struct node Node;
typedef struct hnode Hnode;
typedef struct queue Queue;
typedef struct activity Activity;
typedef Queue *QueuePointer;
typedef Node *NodePointer;

void Add(int x, int y, int dur, int num);
void CriticalPath(void);
void Set(void);
void Input(void);
void InitialiseGraph(void);
void FindEarliest(void);
void FindEarly(void);
void FindLatest(void);
void FindLate(void);
void FindCriticalActivity(void);
void ShowResult(void);

struct node {
int Vertex, duration, num;
NodePointer Next;
};
struct hnode {
int Count;
NodePointer Next;
};
struct queue {
NodePointer p;
QueuePointer Next;
};

Hnode AdjacencyList[MAX_VERTEX];
Hnode InverseAdjacencyList[MAX_VERTEX];/*Out degree*/
short int visit[MAX_VERTEX], CriticalActivity[MAX_VERTEX];
int N, M, S, T, CriticalPathLength[MAX_VERTEX];
int Earliest[MAX_VERTEX];	/*最早发生时间F*/
int Latest[MAX_VERTEX];		/*最迟发生时间*/
int Early[MAX_VERTEX]; 		/*最早开始时间F*/
int Late[MAX_VERTEX];		/*最迟开始时间*/
char *re[2] = {"No", "Yes"};

int main() {
while(1) {
Input();
CriticalPath();
FindEarliest();
FindEarly();
FindLatest();
FindLate();
FindCriticalActivity();
ShowResult();
}
}

void ShowResult(void) {
int i;
printf("Activity    Early    Late    Early-Late     Critical\n");
for(i = 0; i < M; i++)
printf("%-8d    %-5d    %-4d    %-10d     %-8s\n",
i, Early[i], Late[i], abs(Early[i] - Late[i]), re[CriticalActivity[i]]);
}

void FindCriticalActivity(void) {
int i;
memset(CriticalActivity, 0, sizeof(CriticalActivity));
for(i = 0; i < M; i++)
if(Early[i] == Late[i])
CriticalActivity[i] = 1;
}

void FindLate(void) {
int i;
NodePointer p;
memset(Late, 0, sizeof(Late));
for(i = 0; i < N; i++) {
p = AdjacencyList[i].Next;
while(p) {
Late[p->num] = Latest[p->Vertex] - p->duration;
p = p->Next;
}
}
}

void FindLatest(void) {
int i, j, k, top = -1, flag = 1;
NodePointer p;
Latest[N - 1] = Earliest[N - 1];
for(i = N - 1; i >= 0; i--) {
if(InverseAdjacencyList[i].Count == 0) {
InverseAdjacencyList[i].Count = top;
top = i;
}
}
for(i = 0; i < N; i++) {
j = top;
top = InverseAdjacencyList[top].Count;
for(p = InverseAdjacencyList[j].Next; p; p = p->Next) {
k = p->Vertex;
if(Latest[j] - p->duration < Latest[p->Vertex] || Latest[p->Vertex] == 0)
Latest[p->Vertex] = Latest[j] - p->duration;
InverseAdjacencyList[k].Count--;
if(InverseAdjacencyList[k].Count == 0) {
InverseAdjacencyList[k].Count = top;
top = k;
}
}
}
}

void FindEarly(void) {
int i;
NodePointer p;
memset(Early, 0, sizeof(Early));
for(i = 0; i < N; i++) {
p = AdjacencyList[i].Next;
while(p) {
Early[p->num] = Earliest[i];
p = p->Next;
}
}
}

void FindEarliest(void) {
int i;
for(i = 0; i < N; i++)
Earliest[i] = CriticalPathLength[i];
return ;
}

void CriticalPath(void) {/* Dijkstra */
NodePointer p;
int i, u, w, v;
Set();
v = S;
visit[v] = TRUE;
for(i = 0; i < N - 2; i++) {
u = Choose();
visit[u] = TRUE;
p = AdjacencyList[u].Next;
while(p) {
if(visit[p->Vertex] == 0)
if(CriticalPathLength[u] + p->duration > CriticalPathLength[p->Vertex])
CriticalPathLength[p->Vertex] = CriticalPathLength[u] + p->duration;
p = p->Next;
}
}
}

void Set(void) {
NodePointer p;
memset(visit, 0, sizeof(visit));
memset(CriticalPathLength, 0, sizeof(CriticalPathLength));
p = AdjacencyList[S].Next;
while(p) {
CriticalPathLength[p->Vertex] = p->duration;
p = p->Next;
}
}

int Choose(void) {
int i, max, maxpos;
max = 0;
maxpos = -1;
for(i = 0; i < N; i++)
if(CriticalPathLength[i] > max && visit[i] == 0) {
max = CriticalPathLength[i];
maxpos = i;
}
return maxpos;
}

void Input(void) {
int i, x, y, dur;
scanf("%d%d", &N, &M);
scanf("%d%d", &S, &T);
InitialiseGraph();
for(i = 0; i < M; i++) {
scanf("%d%d%d", &x, &y, &dur);
Add(x, y, dur, i);
}
return ;
}

void Add(int x, int y, int dur, int num) {
NodePointer tmp = (NodePointer)malloc(sizeof(Node)), tmp2 = (NodePointer)malloc(sizeof(Node));
tmp->Next = tmp2->Next = NULL;
tmp->duration = tmp2->duration = dur;
tmp->num = tmp2->num = num;
tmp->Vertex = y;
tmp2->Vertex = x;
AdjacencyList[y].Count++;
InverseAdjacencyList[x].Count++;
if(AdjacencyList[x].Next == NULL)
AdjacencyList[x].Next = tmp;
else {
tmp->Next = AdjacencyList[x].Next;
AdjacencyList[x].Next = tmp;
}
if(InverseAdjacencyList[y].Next == NULL)
InverseAdjacencyList[y].Next = tmp2;
else {
tmp2->Next = InverseAdjacencyList[y].Next;
InverseAdjacencyList[y].Next = tmp2;
}
return ;
}

void InitialiseGraph(void) {
int i;
for(i = 0; i < N; i++) {
if(AdjacencyList[i].Next)
free(AdjacencyList[i].Next);
if(InverseAdjacencyList[i].Next)
free(InverseAdjacencyList[i].Next);
AdjacencyList[i].Next = InverseAdjacencyList[i].Next = NULL;
AdjacencyList[i].Count = InverseAdjacencyList[i].Count = 0;
}
return ;
}