Status InitStack(SqStack &S){
S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
if (!S.base)
exit(_OVERFLOW);
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
return OK;
}
Status StackEmpty(SqStack S){
if (S.top == S.base)
return TRUE;
else
return FALSE;
}
Status GetTop(SqStack s,SElemType &e){
if(s.base==s.top)
return 0;
e = *(s.top - 1);
return 1;
}
Status Push(SqStack &S, SElemType e){
if (S.top - S.base >= S.stacksize) {
S.base = (SElemType *)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));
if (!S.base)
exit(_OVERFLOW);
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*(S.top)++ = e;
return OK;
}
Status Pop(SqStack &S, SElemType &e){ /* 若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR */
if (S.top == S.base)
return ERROR;
e = *–S.top;
return OK;
}
int ve[MAX_VERTEX_NUM], vl[MAX_VERTEX_NUM];//e[]:最早发生时间 vl[]:最迟发生时间
bool flag = 0;
vector path;
int top,down;
void dfs(ALGraph G, int u){
if (G.vertices[u].data == G.vertices[top].data) {//搜索到终点
if (flag) cout << “\n或者:\n”;
cout << G.vertices[down].data; //输出起点
for(auto &it:path) //遍历输出关键路径
cout << it;
flag = 1;
return;
}
ArcNode* p = G.vertices[u].firstarc; //初边
for (; p; p = p->nextarc) { //遍历
int k = p->adjvex; //该弧所指向的顶点的下标
int dut = *(p->info); //弧的权值
if (ve[u] == vl[k] - dut) { //是关键活动
path.push_back(“->”);
path.push_back(G.vertices[k].data); //记录关键活动
dfs(G, k); //继续DFS搜索下一个结点的关键活动
path.pop_back(); //回溯
path.pop_back(); //回溯
}
}
}
//算法7.13
Status TopologicalOrder(ALGraph G, SqStack &T){
int j, k, count, indegree[MAX_VERTEX_NUM],e;
SqStack S;
ArcNode *p;
FindInDegree(G, indegree);
InitStack(S);
for (j = 0; j < G.vexnum; ++j)
if (!indegree[j])
Push(S, j);
GetTop(S, down); //记录起点位置
InitStack(T);
count = 0;
for (j = 0; j < G.vexnum; ++j)
ve[j] = 0; //初始化
while (!StackEmpty(S)){
Pop(S, j);
Push(T, j);
++count; //入栈的顶点数
for (p = G.vertices[j].firstarc; p; p = p->nextarc){ //遍历邻接表
k = p->adjvex; //该弧所指向的顶点的下标
if (–indegree[k] == 0) //入度减为零入栈
Push(S, k);
if (ve[j] + *(p->info) > ve[k])//拓扑正序更新max
ve[k] = ve[j] + *(p->info);
}
}
if (count < G.vexnum){
printf(“此有向网有回路\n”);
return ERROR;
}
else{
GetTop(T, top);//拓扑排序的最后一个结点为终点
return OK;
}
}
//算法7.14
Status CriticalPath(ALGraph G){
SqStack T;
int i, j, k, ee, el;
ArcNode *p;
char dut, tag;
if (!TopologicalOrder(G, T)) // 产生有向环
return ERROR;
j = ve[0];
for (i = 1; i < G.vexnum; i++) //j=Max(ve[]) 完成点的值
if (ve[i] > j)
j = ve[i];
int maxn = j;
for (i = 0; i < G.vexnum; i++) // 初始化顶点事件的最迟发生时间(最大值)
vl[i] = j; // 完成点的最早发生时间
while (!StackEmpty(T)) // 按拓扑逆序求各顶点的vl值
for (Pop(T, j), p = G.vertices[j].firstarc; p; p = p->nextarc){
k = p->adjvex;
dut = *(p->info); // dut<j,k>
if (vl[k] - dut < vl[j])
vl[j] = vl[k] - dut;
}
printf(" j k dut ee el tag\n");
for (j = 0; j < G.vexnum; ++j)//求ee,el和关键活动
for (p = G.vertices[j].firstarc; p; p = p->nextarc){
k = p->adjvex;
dut = *(p->info);//边权
ee = ve[j];
el = vl[k] - dut;
tag = (ee == el) ? ‘*’ : ’ ';
printf(“%2d %2d %3d %3d %3d %c\n”, j, k, dut, ee, el, tag);
}
printf(“关键活动为:\n”);
for (j = 0; j < G.vexnum; ++j)
for (p = G.vertices[j].firstarc; p; p = p->nextarc){
k = p->adjvex;
dut = *(p->info);
if (ve[j] == vl[k] - dut)
printf(“%s→%s\n”, G.vertices[j].data, G.vertices[k].data); // 输出关键活动
}
printf(“关键路径为:\n”);
dfs(G,0);
printf(“\n花费时间最少为:%d\n”, maxn);
return OK;
}
int main(){
ALGraph h;
CreateGraph(h);
Display(h);
CriticalPath(h);
}
测试样例:
再加两条:
v1 -> v10
(权值为8)
v10 -> v9
(权值为10)
测试数据:
请输入图的顶点数和边数(空格隔开): 10 13
请输入10个顶点的值(<5个字符):
v1 v2 v3 v4 v5 v6 v7 v8 v9 v10
请顺序输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):
6 v1 v2
4 v1 v3
5 v1 v4
1 v2 v5
1 v3 v5
2 v4 v6
9 v5 v7
7 v5 v8
4 v6 v8
2 v7 v9
4 v8 v9
8 v1 v10
10 v10 v9
运行结果
有向图
10个顶点:
v1 v2 v3 v4 v5 v6 v7 v8 v9 v10
13条弧(边):
v1→v10 :8v1→v4 :5v1→v3 :4v1→v2 :6
v2→v5 :1
v3→v5 :1
v4→v6 :2
v5→v8 :7v5→v7 :9
v6→v8 :4
v7→v9 :2
v8→v9 :4
v10→v9 :10
j k dut ee el tag
0 9 8 0 0 *
0 3 5 0 3
0 2 4 0 2
0 1 6 0 0 *
1 4 1 6 6 *
2 4 1 4 6
3 5 2 5 8
4 7 7 7 7 *
4 6 9 7 7 *
5 7 4 7 10
6 8 2 16 16 *
7 8 4 14 14 *
9 8 10 8 8 *
关键活动为:
v1→v10
v1→v2
v2→v5
v5→v8
v5→v7
v7→v9
v8→v9
v10→v9
关键路径为:
v1->v10->v9
或者:
v1->v2->v5->v8->v9
或者:
v1->v2->v5->v7->v9
花费时间最少为:18
-
在使用邻接表存图过程中再次熟悉链表相关操作。
-
复习栈的编写及使用。利用栈求解拓扑序列。
-
在进行拓扑排序时,掌握结点度(入度)求取,学会拓扑有序的应用:利用拓扑排序进行最早发生时间的计算。
-
复习栈的编写及使用。利用栈存储拓扑有序序列,出栈即得到拓扑逆序序列。并利用拓扑逆序求解最晚发生时间的计算。
-
复习图上深度优先搜索。利用DFS输出关键路径。
[1] 严蔚敏,吴伟民.数据结构(C语言版)[M]. 北京:清华大学出版社,1997.4
================================================================================
错误代码:
dfs(G,0);
正确代码:
dfs(G,down);
0
并不是起点的下标,down
才是。
例如测试样例改为:
请输入图的顶点数和边数(空格隔开): 9 11
请输入9个顶点的值(<5个字符):
v2 v1 v3 v4 v5 v6 v7 v8 v9
请顺序输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):
6 v1 v2
4 v1 v3
5 v1 v4
1 v2 v5
1 v3 v5
2 v4 v6
9 v5 v7
7 v5 v8
4 v6 v8
2 v7 v9
4 v8 v9
dfs(G,0)
会输出:
有向图
9个顶点:
v2 v1 v3 v4 v5 v6 v7 v8 v9
11条弧(边):
v2→v5 :1
v1→v4 :5v1→v3 :4v1→v2 :6
v3→v5 :1
v4→v6 :2
v5→v8 :7v5→v7 :9
v6→v8 :4
v7→v9 :2
v8→v9 :4
j k dut ee el tag
0 4 1 6 6 *
1 3 5 0 3
1 2 4 0 2
1 0 6 0 0 *
2 4 1 4 6
3 5 2 5 8
4 7 7 7 7 *
4 6 9 7 7 *
5 7 4 7 10
6 8 2 16 16 *
7 8 4 14 14 *
关键活动为:
v2→v5
v1→v2
v5→v8
v5→v7
v7→v9
v8→v9
关键路径为:
v1->v5->v8->v9 //错误
或者:
v1->v5->v7->v9
花费时间最少为:18
dfs(G,down)
会输出:
有向图
9个顶点:
v2 v1 v3 v4 v5 v6 v7 v8 v9
11条弧(边):
v2→v5 :1
v1→v4 :5v1→v3 :4v1→v2 :6
v3→v5 :1
v4→v6 :2
v5→v8 :7v5→v7 :9
v6→v8 :4
v7→v9 :2
v8→v9 :4
j k dut ee el tag
0 4 1 6 6 *
1 3 5 0 3
1 2 4 0 2
1 0 6 0 0 *
2 4 1 4 6
3 5 2 5 8
4 7 7 7 7 *
4 6 9 7 7 *
5 7 4 7 10
6 8 2 16 16 *
7 8 4 14 14 *
关键活动为:
v2→v5
v1→v2
v5→v8
v5→v7
v7→v9
v8→v9
关键路径为:
v1->v2->v5->v8->v9 //正确
或者:
v1->v2->v5->v7->v9
花费时间最少为:18
char* strcmmp(char *a,int n){
char arr=(char)malloc(n*sizeof(char));
for(int i=0;i<n-1;i++){
arr[i]=a[i];
}
arr[n-1]=‘\0’;
return arr;
}
void dfs(ALGraph G,int u,char arry[])
{
if(G.adjlist[u].vex==G.adjlist[top].vex)
{
//printf(“%s”,G.adjlist[down].vex);
for(int i=0;i<strlen(arry);i++)
{
printf(“%c”,arry[i]);
if(i>=0&&i<strlen(arry)-1)
printf(“->”);
}
printf(“\n”);
return ;
}
EdgeNode *p=G.adjlist[u].firstedge;
for(;p;p=p->next)
{
int k=p->adjvex,w=p->weight;
if(etv[u]==ltv[k]-w)
{ //printf(“%d\n”,k);
arry=strcat(arry,G.adjlist[k].vex);
dfs(G,k,arry);
arry=strcmmp(arry,strlen(arry)-1);
}
}
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define Max_VERTEX_NUM 20
#define ElemType int
#define Status int
#define MAXVEX 100
#define MAX_NAME 5
int top, down;
int *etv, *ltv; //记录事件最早发生时间和最迟发生时间数组
typedef char VertexType[MAX_NAME];
typedef struct nodee //边表节点
{
int adjvex; //邻接点域,存储该顶点对应的下标
int weight; //权值
struct nodee *next; //指向下一个顶点
} EdgeNode;
typedef struct vnode //顶点
{
VertexType vex; //顶点信息
EdgeNode *firstedge; //指向顶点的第一个邻接顶点
} VertexNode, AdjList[Max_VERTEX_NUM];
typedef struct AlGraph
{
AdjList adjlist;
int vexnum; //节点数目
int edgenum; //边的数目
} ALGraph;
//定义一个栈
typedef struct Node
{
ElemType data; //存储数据
struct Node *next; //指向下一个元素
} node, *LinkStackptr;
typedef struct LS
{
LinkStackptr top;
int count; //记录栈中元素的个数
} LinkStack;
Status InitStack(LinkStack *s) //创建一个栈
{
s->top = (LinkStackptr)malloc(sizeof(node));
if (s->top == NULL)
exit(0);
s->top->next = NULL;
s->count = 0;
return 1; //建栈成功返回1
}
Status StackEmpty(LinkStack s) //判断是否为空
{
if (s.count == 0)
return 1; //若栈为空返回1
return 0; //若栈不为空返回 0
}
Status GetTop(LinkStack s, int *e) //返回栈顶元素
{
if (s.top == NULL)
return 0;
*e = s.top->data;
return *e;
}
Status Push(LinkStack *s, ElemType e) //元素入栈(头插)
{
LinkStackptr p = (LinkStackptr)malloc(sizeof(node));
if (p == NULL)
return 0;
p->data = e;
p->next = s->top;
s->top = p; //指向第一个元素的指针
s->count++; //栈中元素个数增加
return 1;
}
Status pop(LinkStack *s, ElemType *e) //返回栈顶元素 ,并删除 (头删)
{
if (s->top == NULL)
return 0;
LinkStackptr p = s->top->next; //指向下一个元素
*e = s->top->data; //将首元素的赋给e
free(s->top);
s->top = p; //删除节点
s->count = s->count - 1; //栈中元素个数减少
return *e; //返回e
}
void CreateALG(ALGraph *ALG, int **indegree) //创建一个图(邻接表存储)
{
printf("请输入节点的数目和边的数目 ");
scanf(“%d%d”, &ALG->vexnum, &ALG->edgenum);
int i, j, k, w;
EdgeNode *e;
for (i = 0; i < ALG->vexnum; i++)
{
getchar();
// printf(“请输入第%d个节点的信息”,i+1);
scanf(“%s”, ALG->adjlist[i].vex); //输入结点信息
ALG->adjlist[i].firstedge = NULL;
}
for (k = 0; k < ALG->edgenum; k++) //边表的建立
{
getchar();
//printf(“请输入第%d条边<vi,vj>上的顶点序号和权值”,k+1);
scanf(“%d%d%d”, &w, &i, &j);
e = (EdgeNode *)malloc(sizeof(EdgeNode));
e->adjvex = j - 1;
e->weight = w;
e->next = ALG->adjlist[i - 1].firstedge;
ALG->adjlist[i - 1].firstedge = e; //将结点插入
}
*indegree = (int *)malloc(ALG->vexnum * sizeof(int)); //创建indegree数组求入度
for (i = 0; i < ALG->vexnum; i++)
{
(*indegree)[i] = 0; //(indegree初始化)
}
}
void FindInDegree(ALGraph ALG, int indegree[]) //求各个结点的入度
{
int i;
EdgeNode *temp;
for (i = 0; i < ALG.vexnum; i++) //对每个顶点的边表都进行遍历
{
temp = ALG.adjlist[i].firstedge;
while (temp != NULL)
{
indegree[temp->adjvex]++;
temp = temp->next;
}
}
}
char *strcmmp(char *a, int n)
{
char *arr = (char *)malloc(n * sizeof(char));
for (int i = 0; i < n - 1; i++)
{
arr[i] = a[i];
}
arr[n - 1] = ‘\0’;
return arr;
}
void dfs(ALGraph G, int u, char arry[])
{
if (G.adjlist[u].vex == G.adjlist[top].vex)
{
//printf(“%s”,G.adjlist[down].vex);
for (int i = 0; i < strlen(arry); i++)
{
printf(“%c”, arry[i]);
if (i >= 0 && i < strlen(arry) - 1)
printf(“->”);
}
printf(“\n”);
return;
}
EdgeNode *p = G.adjlist[u].firstedge;
for (; p; p = p->next)
{
int k = p->adjvex, w = p->weight;
if (etv[u] == ltv[k] - w)
{ //printf(“%d\n”,k);
arry = strcat(arry, G.adjlist[k].vex);
dfs(G, k, arry);
arry = strcmmp(arry, strlen(arry) - 1);
}
}
}
Status TopologicalSort(ALGraph ALG, int indegree[], LinkStack *T) //拓扑排序
{
int i, count = 0, k;
LinkStack s;
EdgeNode *p;
InitStack(T); //创建一个栈 (用于逆序)
InitStack(&s); //创建一个栈(用于正序)
etv = (int *)malloc(ALG.vexnum * sizeof(int));
for (i = 0; i < ALG.vexnum; i++)
{
etv[i] = 0; // 对记录事件最早发生时间的数组进行初始化
}
for (i = 0; i < ALG.vexnum; i++)
{
if (indegree[i] == 0)
{
Push(&s, i); //遍历找到入度为0的元素入栈
GetTop(s, &down);
}
}
while (!StackEmpty(s)) //循环
{
pop(&s, &i); //出栈
Push(T, i); //入栈
printf("%s ", ALG.adjlist[i].vex); //打印出拓扑正序序列
count++; //记录输出的结点数
for (p = ALG.adjlist[i].firstedge; p; p = p->next)
{
k = p->adjvex;
if (!(–indegree[k])) //出栈的同时对各个结点的入度进行更新
Push(&s, k); //进行判断,若入度为0便入栈
if (etv[i] + p->weight > etv[k]) // 求事件的最早发生时间 //前->后
etv[k] = etv[i] + p->weight;
}
}
if (count < ALG.vexnum) //判断是否有回路
return 0; //若有回路返回0
else
{
GetTop(*T, &top);
return 1;
} //若无回路返回1
}
Status CriticalPath(ALGraph ALG, LinkStack *T, int n) //求关键路径
{
if (n == 0) //判断是否有回路(若有回路程序停止执行)
{
printf(“有回路”);
return 0;
}
int i, k, w, j;
int ete, lte; //活动的最早,最迟开始时间
EdgeNode *p;
ltv = (int *)malloc(ALG.vexnum * sizeof(int)); //对求事件最迟开始时间的数组进行初始化
j = etv[0];
for (i = 1; i < ALG.vexnum; i++)
{
if (j < etv[i])
j = etv[i];
}
for (i = 0; i < ALG.vexnum; i++)
{
ltv[i] = j; //最后一个事件的最迟开始时间等于其最早开始时间
}
while (!StackEmpty(*T)) //利用拓扑逆序求事件的最迟开始时间
{
pop(T, &i);
for (p = ALG.adjlist[i].firstedge; p; p = p->next)
{
k = p->adjvex;
w = p->weight;
if (ltv[k] - w < ltv[i]) //后->前
ltv[i] = ltv[k] - w;
}
}
for (i = 0; i < ALG.vexnum; i++)
{
for (p = ALG.adjlist[i].firstedge; p; p = p->next)
{
k = p->adjvex;
w = p->weight;
ete = etv[i];
lte = ltv[k] - w; //求活动的最迟开始和最早开始时间
if (ete == lte) //若相等便是关建活动
printf("<%s,%s>length is %d ", ALG.adjlist[i].vex, ALG.adjlist[k].vex, p->weight); //输出关键路径
}
}
printf(“\n”);
printf(“路径长度为: %d”, j);
printf(“\n”);
dfs(ALG, 0, ALG.adjlist[0].vex);
}
int main()