08-图9 关键活动（浙大数据结构PTA习题）

08-图9 关键活动

分数 30        作者 DS课程组        单位 浙江大学

问题：

假定一个工程项目由一组子任务构成，子任务之间有的可以并行执行，有的必须在完成了其它一些子任务后才能执行。“任务调度”包括一组子任务、以及每个子任务可以执行所依赖的子任务集。

比如完成一个专业的所有课程学习和毕业设计可以看成一个本科生要完成的一项工程，各门课程可以看成是子任务。有些课程可以同时开设，比如英语和C程序设计，它们没有必须先修哪门的约束；有些课程则不可以同时开设，因为它们有先后的依赖关系，比如C程序设计和数据结构两门课，必须先学习前者。

但是需要注意的是，对一组子任务，并不是任意的任务调度都是一个可行的方案。比如方案中存在“子任务A依赖于子任务B，子任务B依赖于子任务C，子任务C又依赖于子任务A”，那么这三个任务哪个都不能先执行，这就是一个不可行的方案。

任务调度问题中，如果还给出了完成每个子任务需要的时间，则我们可以算出完成整个工程需要的最短时间。在这些子任务中，有些任务即使推迟几天完成，也不会影响全局的工期；但是有些任务必须准时完成，否则整个项目的工期就要因此延误，这种任务就叫“关键活动”。

请编写程序判定一个给定的工程项目的任务调度是否可行；如果该调度方案可行，则计算完成整个工程项目需要的最短时间，并输出所有的关键活动。

输入格式:

输入第1行给出两个正整数N(≤100)和M，其中N是任务交接点（即衔接相互依赖的两个子任务的节点，例如：若任务2要在任务1完成后才开始，则两任务之间必有一个交接点）的数量。交接点按1~N编号，M是子任务的数量，依次编号为1~M。随后M行，每行给出了3个正整数，分别是该任务开始和完成涉及的交接点编号以及该任务所需的时间，整数间用空格分隔。

输出格式:

如果任务调度不可行，则输出0；否则第1行输出完成整个工程项目需要的时间，第2行开始输出所有关键活动，每个关键活动占一行，按格式“V->W”输出，其中V和W为该任务开始和完成涉及的交接点编号。关键活动输出的顺序规则是：任务开始的交接点编号小者优先，起点编号相同时，与输入时任务的顺序相反。

输入样例:

7 8
1 2 4
1 3 3
2 4 5
3 4 3
4 5 1
4 6 6
5 7 5
6 7 2

输出样例:

17
1->2
2->4
4->6
6->7

代码长度限制: 16 KB        时间限制: 400 ms        内存限制: 64 MB

答案：

此题为图论中经典的“关键活动”问题，但编程实现仍有一些细节值得注意，如有向图中是否含有环以及如何应对多个起点与终点的情况。

示例推演：

 

特殊情况：

代码展示 ：

# include<stdio.h>
# include<stdlib.h>
# include<stdbool.h>
# define MaxVertexNum 101
# define MaxWeight 65535

// 图结构（采用邻接矩阵存储图，邻接矩阵中结点从1开始编号）
typedef struct MGraphNode* MGraph;
struct MGraphNode{
    int Martrix[MaxVertexNum][MaxVertexNum];
    int Nv;		// 顶点数量 
    int Ne;		// 边数量 
};

// 图结点结构 
struct VertexNode{
    int InDegree;    // 进度
    int TopDegree;   // 备用进度，拓扑排序时使用
    int OutDegree;   // 出度
    int Earliest;    // 最早完工时间
    int Lastest;     // 最晚完工时间
};

MGraph CreateMGraph(int Nv,int Ne,struct VertexNode Array[]);
bool TopSort(MGraph Graph, struct VertexNode Array[]); 
int EarliestTime(MGraph Graph, struct VertexNode Array[], int Vertex);
int LastestTime(MGraph Graph, struct VertexNode Array[], int Vertex);
void PrintSecret(MGraph Graph, struct VertexNode Array[]);

int main(){
	// 接收顶点数和边数
	int Nv,Ne;
	scanf("%d %d",&Nv,&Ne);
	// 使用结构数组存储元素结点，数组从下标1开始存储，并进行初始化
	struct VertexNode Array[Nv+1];
	int i;
	for(i=1;i<=Nv;i++){
		// 初始化出入度为0，最早晚完工时间为"正无穷大" 
		struct VertexNode Node = {0,0,0,MaxWeight,MaxWeight};
		Array[i] = Node;
	}
	// 创建图
	MGraph Graph = CreateMGraph(Nv,Ne,Array); 
	
	// 使用拓扑排序判读有向图中是否存在回路
	bool Acylic = TopSort(Graph,Array);
	if(Acylic==false){
		// 程序结束，没必要进行后续步骤 
		printf("0");
		return 0;
	}
	
	// 递归更新每个结点的最早完工时间
	for(i=1;i<=Graph->Nv;i++){
		EarliestTime(Graph,Array,i);
	}
	
	// 可能存在多个终点，找出最早完工时间最大的那个终点 
	int MinTime = 0;
	for(i=1;i<=Graph->Nv;i++){
		if(Array[i].OutDegree==0){
			if(Array[i].Earliest>MinTime){
				MinTime = Array[i].Earliest;
			}
		}
	}
	
	// 更新所有终点的最晚完工时间
	for(i=1;i<=Graph->Nv;i++){
		if(Array[i].OutDegree==0)Array[i].Lastest = MinTime;
	}
	// 递归更新每个结点的最晚完工时间
	for(i=1;i<=Graph->Nv;i++){
		LastestTime(Graph,Array,i);
	}
	
	// 输出该项目的最早完工时间
	printf("%d\n",MinTime);
	// 找出关键活动并输出
	PrintSecret(Graph,Array);
	// 释放图
	free(Graph);
	return 0; 
	
} 

// 创建图 
MGraph CreateMGraph(int Nv,int Ne,struct VertexNode Array[]){
	MGraph Graph = (MGraph)malloc(sizeof(struct MGraphNode));
	Graph->Nv = Nv;
	Graph->Ne = Ne;
	// 初始化邻接矩阵 
	int i,j;
	for(i=1;i<=Graph->Nv;i++){
		for(j=1;j<=Graph->Nv;j++){
			Graph->Martrix[i][j] = MaxWeight;
		}
	}	 
	// 插入边（根据题意使用的是有向边，因此只插入一次），并统计每个结点的出入度 
	int V1,V2,Weight;
	for(i=1;i<=Graph->Ne;i++){
		scanf("%d %d %d",&V1,&V2,&Weight);
		Graph->Martrix[V1][V2] = Weight;
		Array[V1].OutDegree++;
		Array[V2].InDegree++;
		Array[V2].TopDegree++; 
	} 
	return Graph;
}

// 对一个图进行拓扑排序，不过拓扑的主要目的检测图中是否有回路
bool TopSort(MGraph Graph, struct VertexNode Array[]){
	// 收录数组，数组从下标1开始存储 
	int Flag[Graph->Nv+1]; 
	int i,j;
	for(i=1;i<=Graph->Nv;i++){
		Flag[i] = 0;
	}
	// 拓扑排序
	int valid;
	do{
		// 用于判读是否还有结点可以被收录的标志 
		valid = 0;
		for(i=1;i<=Graph->Nv;i++){
			if(Array[i].TopDegree==0 && Flag[i]==0){
				// 收录
				Flag[i] = 1;
				valid = 1; 
				// 更新其指向的邻接点的入度
				for(j=1;j<=Graph->Nv;j++){
					if(Graph->Martrix[i][j]<MaxWeight && Flag[j]==0){
						Array[j].TopDegree--;
					}
				}
			} 
		}
	}while(valid!=0);
	// 判读收录的结点个数，若存在结点未被收录，说明该有向图中存在环，返回false； 
	for(i=1;i<=Graph->Nv;i++){
		if(Flag[i] == 0)return false;
	}
	return true; 
}

// 递归计算每个结点的最早完工时间
int EarliestTime(MGraph Graph, struct VertexNode Array[], int Vertex){
    int i,Time,MinTime = 0;
    if(Array[Vertex].InDegree == 0){
        // 如果这个顶点是起点
        MinTime = 0;
    }else{
        // 递归：Max{指向其的邻接点的最早完工时间+该任务时间}
        for(i=1;i<=Graph->Nv;i++){
            if(Graph->Martrix[i][Vertex]<MaxWeight){
                Time = EarliestTime(Graph,Array,i) + Graph->Martrix[i][Vertex];
                if(Time > MinTime){
                    MinTime = Time;
                }
            }
        }
    }
    Array[Vertex].Earliest = MinTime; 
    return MinTime;
}

// 递归计算每个结点的最晚完工时间
int LastestTime(MGraph Graph, struct VertexNode Array[], int Vertex){
    int i,Time,MaxTime = MaxWeight;
    if(Array[Vertex].OutDegree == 0){
        // 如果这个顶点是终点
        MaxTime = Array[Vertex].Lastest;
    }else{
        // 递归：Min{邻接点的最玩时间-邻接边权重}
        for(i=1;i<=Graph->Nv;i++){
            if(Graph->Martrix[Vertex][i]<MaxWeight){
                Time = LastestTime(Graph,Array,i) - Graph->Martrix[Vertex][i];
                if(Time < MaxTime){
                    MaxTime = Time;
                }
            }
        }
    }
    Array[Vertex].Lastest = MaxTime;
    return MaxTime;
}

// 寻找图中的关键活动并输出
void PrintSecret(MGraph Graph, struct VertexNode Array[]){
    int i,j,Weight;
    // 根据题意这里先默认输入任务时起点编号相同时，终点编号较小者先输入(事实证明，默认成立)
    for(i=1;i<=Graph->Nv;i++){
        for(j=Graph->Nv;j>=1;j--){
            if(Graph->Martrix[i][j] < MaxWeight){
                // 如果j是i的邻接点
                Weight = Array[j].Lastest - Array[i].Earliest - Graph->Martrix[i][j];
                // 关键活动是不能延误的活动
                if(Weight==0){
                    printf("%d->%d\n",i,j);
                }
            }
        }
    }
    return;
}

运行结果：