C语言关键路径实现

在工程中，要估算工程完成最短时间，就是要找到一条从源点到汇点的带权路劲长度最长的路径，成为关键路径。

确定关键路径的四个描述量：

1.      事件v_i的最早发生时间ve(i)：

进入世界v_i的每一活动都结束，v_i才有可发生，所以ve(i)是从源点到v_i的最长路径长度。其中v₀一般为0.

2.      事件v_i的最迟发生时间:

事件v_i的发生不得延误v_i的每一后继事件的最迟发生时间。为了不延误工期，v_i的最迟时间不得迟于其后继事件v_k的最迟发生时间减去活动<v_i,v_k>的持续时间。

3.      活动a_i=<v_j,v_k>的最早开始时间e(i):

只有事件v_j发生了，活动ai才能开始。所以活动a_i的最早开始时间等于时间v_j的最早发生时间ve(j)。

4.      活动a _i=<v_j,v_k>的最晚开始时间l(i):

活动a _i的开始时间需要保证不延误时间v_k的最迟发生时间。所以活动a _i的最晚开始时间l(i)等于时间v_k的最迟发生时间vl(k)减去活动a_i的持续时间w_j,k。

对于关键活动而言，e(i)=l(i)。对于非关键活动，l(i)-e(i)的值是该工程的期限余量，此范围内的适度延误不会影响整个工程的工期。

（以上引用课本原文）

下面是实现代码：

预定义和类型定义：

#define OK 1
#define ERROR 0
#define MVNum 100

typedef int Status;
typedef char VerTexType;
typedef int OtherInfo;

typedef struct StackNode{
	int data;
	StackNode *next;
}StackNode, *StackList;

typedef struct ArcNode{
	int adjvex;
	ArcNode *nextarc;
	OtherInfo weight;
}ArcNode;

typedef struct VNode{
	VerTexType data;
	ArcNode *firstarc;
}VNode, AdjList[MVNum];

typedef struct{
	AdjList vertices;
	int vexnum, arcnum;
}ALGraph;

创建图、栈和拓扑排序：

int indegree[MVNum] = { 0 };

StackList InitStack(StackList &S)
{
	S = NULL;
	return S;
}

StackList Push(StackList S, int e)
{
	StackList p;
	p = (StackNode *)malloc(sizeof(StackNode));
	p->data = e;
	p->next = S;
	S = p;
	return S;
}

StackList Pop(StackList S, int *e)
{
	StackList p;
	p = S;
	if (!p)
		return ERROR;
	*e = p->data;
	S = S->next;
	free(p);
	return S;
}

int LocateVex(ALGraph *G, VerTexType v)
{
	int i;
	for (i = 0; i < (G->vexnum); i++)
	{
		if (v == G->vertices[i].data)
			return i;
	}
}

void CreateUDG(ALGraph *G)
{
	int i, j, k;
	OtherInfo w;
	VerTexType v1, v2;
	ArcNode *p1;
	printf("输入总节点数和总边数：");
	scanf("%d %d", &G->vexnum, &G->arcnum);
	fflush(stdin);
	printf("输入各个节点的值：");
	for (i = 0; i < G->vexnum; i++)
	{
		scanf("%c", &G->vertices[i].data);
		G->vertices[i].firstarc = NULL;
	}
	for (k = 0; k < G->arcnum; k++)
	{
		fflush(stdin);
		printf("输入一条边的两个节点以及边的权值：");
		scanf("%c %c %d", &v1, &v2, &w);
		i = LocateVex(G, v1);
		j = LocateVex(G, v2);
		p1 = (ArcNode *)malloc(sizeof(ArcNode));
		p1->adjvex = j;
		p1->weight = w;
		p1->nextarc = G->vertices[i].firstarc;
		G->vertices[i].firstarc = p1;
		indegree[j]++;
	}
}

Status TopologicalSort(ALGraph G, int *topo)
{
	int i, m, k;
	StackList S;
	ArcNode *p;
	S = NULL;
	for (i = 0; i < G.vexnum; i++)
	{
		if (!indegree[i])
			S = Push(S, i);
	}
	m = 0;
	while (S)
	{
		S = Pop(S, &i);
		topo[m] = i;
		++m;
		p = G.vertices[i].firstarc;
		while (p != NULL)
		{
			k = p->adjvex;
			--indegree[k];
			if (indegree[k] == 0)
				S = Push(S, k);
			p = p->nextarc;
		}
	}
	topo[m] = -1;
	if (m < G.vexnum)
		return ERROR;
	else
		return OK;
}

关键路径算法：

Status CriticalPath(ALGraph G)
{
	int i, j, k, e, l;
	int *ve, *vl;
	int topo[MVNum];
	ArcNode *p;
	ve = (int *)malloc(sizeof(int)*G.vexnum);
	vl = (int *)malloc(sizeof(int)*G.vexnum);
	if (!TopologicalSort(G, topo))
		return ERROR;
	for (i = 0; i < G.vexnum; i++)
		ve[i] = 0;
	for (i = 0; i < G.vexnum; i++)
	{
		k = topo[i];
		p = G.vertices[k].firstarc;
		while (p)
		{
			j = p->adjvex;
			if (ve[j] < ve[k] + p->weight)
				ve[j] = ve[k] + p->weight;
			p = p->nextarc;
		}
	}
	for (i = 0; i < G.vexnum; i++)
		vl[i] = ve[G.vexnum - 1];
	for (i = G.vexnum - 1; i >= 0; i--)
	{
		k = topo[i];
		p = G.vertices[k].firstarc;
		while (p)
		{
			j = p->adjvex;
			if (vl[k]>vl[j] - p->weight)
				vl[k] = vl[j] - p->weight;
			p = p->nextarc;
		}
	}
	for (i = 0; i < G.vexnum; i++)
	{
		p = G.vertices[i].firstarc;
		while (p)
		{
			j = p->adjvex;
			e = ve[i];
			l = vl[j] - p->weight;
			if (e == l)
				printf("%c->%c\n", G.vertices[i].data, G.vertices[j].data);
			p = p->nextarc;
		}
	}
	return OK;
}

声明两个数组ve[]和vl[]分别用来记录事件最早发生时间和最晚发生时间。为了避免浪费，本人使用动态分配空间为数组分配空间。然后进行拓扑排序（注意输入原始数据的时候保证最后一个元素是最后一步事件）。之后初始化ve[]为0。

为ve[]赋值：让将topo[]中的第i个元素赋值给k，并让指针p指向k元素的第一条边。当p不为空的时候，判断p边记录的另一个节点事件的最早发生时间是否小于k节点记录事件最早发生时间加上p边的权值，若小于，则将k节点记录事件最早发生时间加上p边的权值赋值给ve[j]。让p指向下一条边。重复本段操作为所有ve[]赋值。

初始化vl[]，将其元素全部赋值为ve[G.vexnum-1]（工程完成时间，即最后一个项目最早发生时间）。

为vl[]赋值：让topo[i]赋值给k，并让p指向k元素的第一条边。当p不为空的时候，判断p边记录的另一个节点时间的最晚发生时间减去p边的权值是否小于k节点记录事件的最晚发生时间，若小于，则将p边记录的另一个节点时间的最晚发生时间减去p边的权值赋值给vl[k]。让p指向下一条边。重复本段操作为所有vl[]赋值。

判断是否为关键路径：将p指向第i个节点的第一条边。当p不为空的时候让e为ve[i]，l为p边记录的另一个节点的事件最晚发生时间减去p边的权值，若e和l相等则输出边的两个顶点。让p指向下一条边。重复本段操作直到检测完所有关键路径。

加入main(): 

int main(void)
{
	ALGraph G;
	CreateUDG(&G);
	if (!CriticalPath(G))
		printf("错误\n");
	else
		printf("结束\n");
	return 0;
}