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 ;
}