严蔚敏数据结构关键路径

 

#include <stdio.h>
#include <string.h>
#define OK 1
#define INFINITY 32767
#define MAX_VERTEX_NUM 30
#define MAXINFOLEN 30
#define ERROR 0
#define OVERFLOW -1
#define MAXVERTEXLEN 30
#define FALSE 0
#define TRUE 1
typedef int Status;
typedef enum { DG, DN, UDG, UDN }GraphKind;
typedef int VRType;
typedef int InfoType;
typedef char* VertexType;
//邻接表存储图结构
typedef struct ArcNode
{
	struct ArcNode* nextarc;
	InfoType* info;
	int adjvex;
}ArcNode;
typedef struct VNode
{
	VertexType data;
	ArcNode* firstnode;
}VNode, AdjList[MAX_VERTEX_NUM];
typedef struct
{
	AdjList vertices;
	int vexnum, arcnum;
	GraphKind kind;
}ALGraph;
void CreatGraph_AL(ALGraph* G)
{
	printf("请输入邻接表存储图的种类，且只能存储有向图（0）与无向图（2）\n");
	scanf("%d", &(G->kind));
	int info;
	printf("请依次输入图的节点数，弧数，是否需要弧的信息\n");
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	for (int i = 0; i < G->vexnum; i++)
	{
		printf("请输入图的第%d个节点的描述\n", i + 1);
		G->vertices[i].data = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vertices[i].data) exit(OVERFLOW);
		gets(G->vertices[i].data);
		G->vertices[i].firstnode = NULL;
	}
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	if (G->kind == DG)
	{
		int tail, head;
		for (int i = 0; i < G->arcnum; i++)
		{
			printf("请输入第%d个节点关系\n", i + 1);
			printf("请输入弧尾描述信息\n");
			gets(ch);
			for (int j = 0; j < G->vexnum; j++)
			{
				if (strcmp(G->vertices[j].data, ch) == 0)
				{
					tail = j;
					break;
				}
			}
			printf("请输入弧头描述信息\n");
			gets(ch);
			for (int j = 0; j < G->vexnum; j++)
			{
				if (strcmp(G->vertices[j].data, ch) == 0)
				{
					head = j;
					break;
				}
			}
			ArcNode* p = (ArcNode*)malloc(sizeof(ArcNode));
			if (!p) exit(OVERFLOW);
			p->adjvex = head;
			ArcNode* s = G->vertices[tail].firstnode;
			if (!s)
			{
				p->nextarc = G->vertices[tail].firstnode;
				G->vertices[tail].firstnode = p;
			}
			else
			{
				while (s->nextarc)
					s = s->nextarc;
				p->nextarc = s->nextarc;
				s->nextarc = p;
			}
			if (info)
			{
				printf("请输入弧的描述信息\n");
				p->info = (int*)malloc(sizeof(int));
				if (!p->info) exit(OVERFLOW);
				scanf("%d", p->info);
				getchar();
			}
		}
	}
	else
	{
		int vex1, vex2;
		for (int i = 0; i < G->arcnum; i++)
		{
			printf("请输入第%d个节点关系\n", i + 1);
			printf("请输入第一个相关节点描述信息\n");
			gets(ch);
			for (int j = 0; j < G->vexnum; j++)
			{
				if (strcmp(G->vertices[j].data, ch) == 0)
				{
					vex1 = j;
					break;
				}
			}
			printf("请输入第二个相关节点描述信息\n");
			gets(ch);
			for (int j = 0; j < G->vexnum; j++)
			{
				if (strcmp(G->vertices[j].data, ch) == 0)
				{
					vex2 = j;
					break;
				}
			}
			ArcNode* p = (ArcNode*)malloc(sizeof(ArcNode));
			if (!p) exit(OVERFLOW);
			p->adjvex = vex1;
			ArcNode* s = G->vertices[vex2].firstnode;
			if (!s)
			{
				p->nextarc = G->vertices[vex2].firstnode;
				G->vertices[vex2].firstnode = p;
			}
			else
			{
				while (s->nextarc)
					s = s->nextarc;
				p->nextarc = s->nextarc;
				s->nextarc = p;
			}
			if (info)
			{
				printf("请输入弧的描述信息\n");
				p->info = (int*)malloc(sizeof(int));
				if (!p->info) exit(OVERFLOW);
				scanf("%d", p->info);
				getchar();
			}
			ArcNode* q = (ArcNode*)malloc(sizeof(ArcNode));
			if (!q) exit(OVERFLOW);
			q->adjvex = vex2;
			s = G->vertices[vex1].firstnode;
			if (!s)
			{
				q->nextarc = G->vertices[vex1].firstnode;
				G->vertices[vex1].firstnode = q;
			}
			else
			{
				while (s->nextarc)
					s = s->nextarc;
				q->nextarc = s->nextarc;
				s->nextarc = q;
			}
			if (info)
			{
				printf("请输入弧的描述信息\n");
				p->info = (int*)malloc(sizeof(int) * MAXINFOLEN);
				if (!p->info) exit(OVERFLOW);
				scanf("%d", p->info);
				getchar();
			}
		}
	}
}
//栈的数据结构及函数
#define STACK_INIT_SIZE 100
#define STACK_INCREASMENT 10
typedef int SElemType;
typedef struct
{
	SElemType* base, * top;
	int stacksize;
}SqStack;
Status InitStack(SqStack* S)
{
	S->base = (SElemType*)malloc(sizeof(SElemType) * STACK_INIT_SIZE);
	if (!S->base) exit(OVERFLOW);
	S->top = S->base;
	S->stacksize = STACK_INIT_SIZE;
}
Status Push(SqStack* S, SElemType e)
{
	if (S->top - S->base > S->stacksize)
	{
		S->base = (SElemType*)realloc(S->base, sizeof(SElemType) * (S->stacksize + STACK_INCREASMENT));
		if (!S->base) exit(OVERFLOW);
		S->stacksize += STACK_INCREASMENT;
	}
	*(S->top) = e;
	S->top++;
	return OK;
}
Status Pop(SqStack* S, SElemType* e)
{
	if (S->base == S->top)
		return ERROR;
	S->top--;
	*e = *(S->top);
	return OK;
}
Status StackEmpty(SqStack S)
{
	if (S.base == S.top)
		return TRUE;
	else
		return FALSE;
}

//求关键路径
int ve[MAX_VERTEX_NUM];
Status TopoLogicalOrder(ALGraph G, SqStack* T)
{
	int* indegree;
	indegree = (int*)malloc(sizeof(int) * MAXVERTEXLEN);
	if (!indegree) exit(OVERFLOW);
	for (int i = 0; i < G.vexnum; i++)
		indegree[i] = 0;
	for (int i = 0; i < G.vexnum; i++)
	{
		ArcNode* p = G.vertices[i].firstnode;
		while (p)
		{
			indegree[p->adjvex]++;
			p = p->nextarc;
		}
	}
	SqStack S;
	InitStack(&S);
	for (int i = 0; i < G.vexnum; i++)
		if (indegree[i] == 0)
			Push(&S, i);
	int count = 0;
	for (int i = 0; i < G.vexnum; i++)
		ve[i] = 0;
	while (!StackEmpty(S))
	{
		int i;
		Pop(&S, &i);
		count++;
		Push(T, i);
		ArcNode* p = G.vertices[i].firstnode;
		while (p)
		{
			indegree[p->adjvex]--;
			if (indegree[p->adjvex] == 0)
				Push(&S, p->adjvex);
			if (ve[p->adjvex] < ve[i] + *(p->info))
				ve[p->adjvex] = ve[i] + *(p->info);
			p = p->nextarc;
		}
	}
	if (count < G.vexnum)
		return ERROR;
	else
		return OK;
}
Status CriticalPath(ALGraph G, SqStack* T)
{
	if (!TopoLogicalOrder(G, T))
		return ERROR;
	int* vl;
	vl = (int*)malloc(sizeof(int) * G.vexnum);
	if (!vl) return ERROR;
	for (int i = 0; i < G.vexnum; i++)
		vl[i] = ve[i];
	while (!StackEmpty(*T))
	{
		int i;
		Pop(T, &i);
		ArcNode* p = G.vertices[i].firstnode;
		int min = INFINITY;
		while (p)
		{
			int m = p->adjvex;
			int w = *(p->info);
			if (vl[m] - w < min)
				min = vl[m] - w;
			p = p->nextarc;
		}
		if (min != INFINITY)
			vl[i] = min;
	}
	for (int i = 0; i < G.vexnum; i++)
		if (ve[i] == vl[i])
			printf("%s", G.vertices[i].data);
}
int main()
{
	SqStack* T;
	T = (SqStack*)malloc(sizeof(SqStack));
	if (!T) exit(OVERFLOW);
	InitStack(T);
	ALGraph G;
	CreatGraph_AL(&G);
	CriticalPath(G, T);
	return 0;
}

原图：

输入：

0
9 11 1
V1
V2
V3
V4
V5
V6
V7
V8
V9
V1
V2
6
V1
V3
4
V2
V5
1
V3
V5
1
V5
V7
9
V5
V8
7
V7
V9
2
V8
V9
4
V1
V4
5
V4
V6
2
V6
V8
4

 输出：