PTA_23_08_图9 _关键活动

最新推荐文章于 2023-12-11 22:38:35 发布

瀛台夜雪

最新推荐文章于 2023-12-11 22:38:35 发布

阅读量85

点赞数

分类专栏：数据结构文章标签：数据结构 c++ 开发语言

本文链接：https://blog.csdn.net/sxycylq/article/details/121921884

版权

数据结构专栏收录该内容

29 篇文章 0 订阅

订阅专栏

PTA_23_08_图9 _关键活动

题目描述

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

比如完成一个专业的所有课程学习和毕业设计可以看成一个本科生要完成的一项工程，各门课程可以看成是子任务。有些课程可以同时开设，比如英语和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为该任务开始和完成涉及的交接点编号。关键活动输出的顺序规则是：任务开始的交接点编号小者优先，起点编号相同时，与输入时任务的顺序相反。

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

算法分析

本题是上一题How long does it take 的变形。其时间的判定流程与上一题实现的流程基本相似。但是需要增加一个显示输出关键活动路径的结点。

同时在上文的基础上，我们需要根据出度定义最晚完成时间。同时算出根据最早完成时间和最短完成时间的关系，我们需要设置机动时间。

机动时间如果为0，那么那条路径就是关键路径。

通过对机动时间是否为0，便可以得到整个系统的关键路径

代码实现

#include<stdio.h>
#include<iostream>
#include<queue>

using namespace std;
#define MAXSIZE 100
#define INFINITY 65535

struct Node
{
	int N;
	int M;
	int A[MAXSIZE][MAXSIZE];
};
typedef struct Node* Pgraph;
int action[MAXSIZE][MAXSIZE];//机动时间
int collect_time;//统计时间
int idx;//记录最早完成时间的那一组最大值的下标
int EarliestTime[MAXSIZE] = { 0 };//记录最早完成的时间
//注意本题输入序列的编号是从1开始的，而非上题中从0开始
void Creategraph(Pgraph graph)
{
	int i, j;
	int tmpstart, tmpend, tmptime;
	cin >> graph->N >> graph->M;
	//初始化边集
	for (i = 0; i < graph->N; i++)
	{
		for (j = 0; j < graph->N; j++)
		{
			graph->A[i][j] = INFINITY;
			action[i][j] = INFINITY;
		}
	}
	//将边集输入
	for (i = 0; i < graph->M; i++)
	{
		cin >> tmpstart >> tmpend >> tmptime;
		//因为是有相图
		graph->A[tmpstart-1][tmpend-1] = tmptime;
	}
}


int getmax(int arr[], Pgraph graph)
{
	int max = 0;
	for (int i = 0; i < graph->N; i++)
	{
		if (arr[i] > max)
		{
			max = arr[i];
			idx = i;
		}
	}
	return max;
}

//early是从入度为0的点开始往上计算
//last是从出度为0的点开始往下计算
void topsort_last(Pgraph graph)
{
	int v,i,j;
	int outdegree[MAXSIZE] = { 0 };//记录各点的出度
	int Lasttime[MAXSIZE] = { 0 };
	queue<int>q;//新建一个队列来存储结点

	//计算各点的出度
	for (i = 0; i < graph->N; i++)
	{
		for (j = 0; j < graph->N; j++)
		{
			if (graph->A[i][j] != INFINITY)
			{
				outdegree[i]++;//对所有的有向边<i,j>计算起点i的出度
			}
		}
	}

	//出度为0的结点入队
	for ( i = 0; i < graph->N; i++)
	{
		if (outdegree[i] == 0)
		{
			q.push(i);
		}
	}

	//初始化lasttime数组
	for (i = 0; i < graph->N; i++)
	{
		Lasttime[i] = INFINITY;
	}
	Lasttime[idx] = collect_time;//将最后一个活动的最晚完成时间设为他的最早完成时间

	while (!q.empty())
	{
		v = q.front();
		q.pop();

		for (j = 0; j < graph->N; j++)
		{
			if (graph->A[j][v] != INFINITY)//<j,v>是有向边
			{
				if (Lasttime[v] - graph->A[j][v] <= Lasttime[j])
				{//此处必须用<=,若只采用<的话，便只能算的出一条关键路径，<=才能得到所有的关键路径
					Lasttime[j] = (Lasttime[v] - graph->A[j][v]);
					action[j][v] = Lasttime[v] - EarliestTime[j] - graph->A[j][v];//得到的就是关键路径的值
				}
				if (--outdegree[j] == 0)//去掉v后，如果j的出度为0
					q.push(j);//下一个出度为0的结点入队
			}
		}
	}

	for (i = 0; i < graph->N; i++)
	{
		for (j = graph->N - 1; j >= 0; j--)
		{
			if (action[i][j] == 0)
				cout << i + 1 << "->" << j+1 << endl;
		}
	}
}




int topsort_early(Pgraph graph)//最早完成时间
{
	int v, i, j;
	int cnt = 0;//计算出队列元素的个数
	int indrgree[MAXSIZE] = { 0 };//记录各点的入度

	queue<int>q;
	//计算各结点的入度
	for (i = 0; i < graph->N; i++)
	{
		for (j = 0; j < graph->N; j++)
		{
			if (graph->A[i][j] != INFINITY)
			{
				indrgree[j]++;//对于有向边<i,j>累计记录终点为j的度
			}
		}
	}

	//入度为0的i入队
	for (int i = 0; i < graph->N; i++)
	{
		if (indrgree[i] == 0)
			q.push(i);
	}

	while (!q.empty())//当队列不空时
	{
		v = q.front();//v等于要出队列的元素
		q.pop();
		cnt++;
		for (j = 0; j < graph->N; j++)
		{
			if (graph->A[v][j] != INFINITY)//如果<v,j>存在有向边
			{
				if (EarliestTime[v] + graph->A[v][j] > EarliestTime[j])
				{//如果v的最早完成时间+j所需时间>j的最早完成时间
					EarliestTime[j] = EarliestTime[v] + graph->A[v][j];
					//由关键路径的算法定义得出的
				}
				if (--indrgree[j] == 0)//去掉v后，j的入度如果为0,这个--是对每一个j都有效
				{
					q.push(j);
				}
			}
		}
	}

	collect_time = getmax(EarliestTime, graph);
	if (cnt != graph->N)
	{
		cout << "0";
		return 0;
	}
	else
	{
		cout << collect_time<<endl;
		topsort_last(graph);//最晚完成时间
	}
}

int main()
{
	Pgraph graph;
	graph = (Pgraph)malloc(sizeof(struct Node));
	Creategraph(graph);
	topsort_early(graph);
}