算法:图的关键路径-数据结构(24)

一、个人理解-简单说说

关键路径其实就是一个点到另外一个点的最唱路径，其中这个图是有向无环图。求出工程里面最关键的事件，不能拖延的事件路径，参考P183-P186。解决的思路，便是找出每个事件点的最早开始时间Ve和最晚完成时间ee，当Ve==ee的情况下就是不能拖延的事件，便是关键路径。

二、数据结构与算法

1、有向图的十字链表 

//==========有向图的十字链表===============
typedef int InfoType;
typedef struct ArcBox{
	int tailvex, headvex;//数组索引的弧头和弧尾
	struct ArcBox *hlink, *tlink;//头链和尾链 头链是弧头相同的下一条弧 尾弧是弧尾相同的一条弧
	InfoType info;
}ArcBox;//弧

typedef struct VexNode{
	VertexType data;
	ArcBox *firstin, *firstout;
}VexNode;//头结点

typedef struct{
	VexNode xlist[MAX_VERTEX_NUM];
	int vexnum, arcnum;//顶点总数 和弧总数
}OLGraph;

Status CreateDG(OLGraph &G, int vexnum, char * vexs, int arcnum, int maps[][6]){
	//创建有向图
	G.vexnum = vexnum;
	G.arcnum = arcnum;
	for (int i = 0; i < G.vexnum; i++)
	{
		//初始化指针
		G.xlist[i].data = vexs[i];
		G.xlist[i].firstin = NULL;
		G.xlist[i].firstout = NULL;
	}
	for (int i = 0; i < vexnum; i++)
	{
		for (int j = 0; j < vexnum; j++)
		{
			if (maps[i][j] != 0)
			{
				//i到j这个有有弧
				ArcBox * p = (ArcBox*)malloc(sizeof(ArcBox));
				
				*p = { i, j, G.xlist[j].firstin, G.xlist[i].firstout, maps[i][j] };
				G.xlist[i].firstout = p;
				G.xlist[j].firstin = p;
			}
		}
	}
	return OK;
}
//对弧的所有遍历.
void PrintfGraphDg(OLGraph G){
	printf("弧尾\t弧头\n");
	for (int i = 0; i < G.vexnum; i++)
	{
		ArcBox* arc = G.xlist[i].firstout;
		while (arc!=NULL)
		{
			printf("%d\t%d \t%c->%c 权重：%d\n", arc->tailvex, arc->headvex, G.xlist[arc->tailvex].data, G.xlist[arc->headvex].data,arc->info);
			arc = arc->tlink;
		}
	}
}

2、关键路径算法

//利用拓扑排序算法计算ve数组
int ve[MAX_VERTEX_NUM];//点的最早完成时间数组
int vl[MAX_VERTEX_NUM];//点的最迟完成时间数组
Status TopologicalOrder(OLGraph G,SqStack &T){
	//初始化ve数组
	for (int i = 0; i < G.vexnum; i++)
	{
		ve[i] = 0; 
	}
	int indegree[MAX_VERTEX_NUM];//存放各顶点入度的数组
	//生成入度数组
	for (int i = 0; i < G.vexnum; i++)
	{
		int count = 0;
		ArcBox* arc = G.xlist[i].firstin;//入度的弧
		while (arc != NULL)
		{
			count++;
			arc = arc->hlink;
		}
		indegree[i] = count;
		printf("%c的入度为%d \n", G.xlist[i].data, indegree[i]);
	}

	SqStack stack;//保存的是入度为0的结点
	InitStack(stack);
	InitStack(T);//初始化栈
	for (int i = 0; i < G.vexnum; i++)
	{
		if (indegree[i] == 0)
		{
			//入度为0 进栈
			//printf("push %d\n", i);
			Push(stack, i);
		}
	}

	int count = 0;//计数计算拓扑排序入度为0 的个数
	while (!StackEmpty(stack)){
		//在栈不为空的情况下
		int elem;
		Pop(stack, elem);
		//获取逆的拓扑排序
		Push(T, elem);

		count++;
		printf("pop %d\n", elem);
		//printf("%c", G.xlist[elem].data);

		//遍历所有指向elem顶点的弧
		ArcBox* arc = G.xlist[elem].firstout;//出去的弧
		while (arc != NULL)
		{
			int k = arc->headvex;//当前弧的头的索引
			if ((--indegree[k]) == 0)
			{
				//printf("push %d\n", arc->tailvex);
				Push(stack, k);
			}
			//找出j-k的弧上最大的边
			if (ve[elem] + arc->info > ve[k])
			{
				ve[k] = ve[elem] + arc->info;
			}
			arc = arc->tlink;
		}
	}
	if (count < G.vexnum)
	{
		printf("个图有回路");
		return ERROR;//这个图有回路
	}


	return OK;
}
//求出关键路径
Status CriticalPath(OLGraph G){
	SqStack T;
	TopologicalOrder(G, T);
	for (int i = 0; i < G.vexnum; i++)
	{
		//printf("%d:",ve[i]);
	}
	//计算出vl数组
	//初始化vl数组 最后一个点的ve与vl相等
	for (int i = 0; i < G.vexnum; i++)
	{
		vl[i] = ve[G.vexnum - 1];
	}
	//使用逆拓扑排序计算出所有的vl
	while (!StackEmpty(T))
	{
		int j;//当前计算的点j
		Pop(T, j);
		//遍历点j的所有
		ArcBox* arc = G.xlist[j].firstout;//出去的弧
		while (arc != NULL)
		{
			int k = arc->headvex;//当前弧的头的索引
			//找出j-k的弧上最大的边
			if (vl[k] - arc->info < vl[j])
			{
				vl[j] = vl[k] - arc->info;
			}
			arc = arc->tlink;
		}
	}

	//for (int i = 0; i < G.vexnum; i++)
	//{
	//	printf("%d:", vl[i]);
	//}

	//求出ee和el 就是关于弧的最早开始时间和最晚开始时间 遍历所有的弧
	for (int i = 0; i < G.vexnum; i++)
	{
		ArcBox* arc = G.xlist[i].firstout;
		while (arc != NULL)
		{
			//printf("%d\t%d \t%c->%c 权重：%d\n", arc->tailvex, arc->headvex, G.xlist[arc->tailvex].data, G.xlist[arc->headvex].data, arc->info);
			int ee = ve[arc->tailvex];
			int el = vl[arc->headvex] - arc->info;
			if (ee == el)
			{
				printf("%d\t%d \t%c->%c 权重：%d\n", arc->tailvex, arc->headvex, G.xlist[arc->tailvex].data, G.xlist[arc->headvex].data, arc->info);
			}
			arc = arc->tlink;
		}
	}
	return OK;
}

三、执行

	//链表创建进行拓扑排序和关键路径
	int vexnum = 6;
	char *vexs = "abcdef";
	int arcnum = 8;
	int maps[6][6] = {
		{ 0, 3, 2, 0, 0, 0 },
		{ 0, 0, 0, 2, 3, 0 },
		{ 0, 0, 0, 4, 0, 3 },
		{ 0, 0, 0, 0, 0, 2 },
		{ 0, 0, 0, 0, 0, 1 },
		{ 0, 0, 0, 0, 0, 0 }
	};
	OLGraph G;
	CreateDG(G,vexnum,vexs,arcnum,maps);
	//PrintfGraphDg(G);
	//DFSTraverse_L(G);
	//BFSTraverse_L(G);
	//TopologicalSort(G);//拓扑排序
	CriticalPath(G);//关键路径

输出：

a的入度为0
b的入度为1
c的入度为1
d的入度为2
e的入度为1
f的入度为3
pop 0
pop 1
pop 4
pop 2
pop 3
pop 5
0       2       a->c 权重：2
2       3       c->d 权重：4
3       5       d->f 权重：2
请按任意键继续. . .