PTA 08-图9 关键活动 (30分)

题目地址

https://pta.patest.cn/pta/test/15/exam/4/question/719

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

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

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

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

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

输入格式:

输入第1行给出两个正整数NN(\le 100≤100)和MM，其中NN是任务交接点（即衔接相互依赖的两个子任务的节点，例如：若任务2要在任务1完成后才开始，则两任务之间必有一个交接点）的数量。交接点按1~NN编号，MM是子任务的数量，依次编号为1~MM。随后MM行，每行给出了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

/*
该问题主体框架与上一题相似，也是拓扑排序，但是这次求关键路径。
不想用太繁琐的解法，想尽量照搬上一题的代码。
提出一个概念——松节点，与该节点相连的所有路径都【不是】关键路径。规则如下：
1 如果该结点【发出的所有边】，距离下个结点的开始时间都有富余，那么该节点是松节点。
2 若一个节点发出的所有边都连到了松节点上，那么该点也是松节点。
3 如果存在多个终点  该节点为终点，且结束时间比最晚的终点要早，那么该终点为松节点。
其中第三条最容易被忽略掉，导致始终不能AC，结果发现添了第三条还是不能AC
另，结果理论上正确，但是题目要求同一节点发出多条路径时，要按输入顺序逆序输出。
那么只好再加个计数了

评测结果
时间	结果	得分	题目	编译器	用时（ms）	内存（MB）	用户
2017-07-05 18:29	部分正确	26	5-11	gcc	2	1
测试点结果
测试点	结果	得分/满分	用时（ms）	内存（MB）
测试点1	答案正确	15/15	2	1
测试点2	答案正确	3/3	2	1
测试点3	答案正确	3/3	1	1
测试点4	答案正确	1/1	1	1
测试点5	答案正确	4/4	1	1
测试点6	答案错误	0/4	2	1

最后一个测试点拿不到成绩，然而手里没有数据能测出问题来
给的提示是【最大N,随机，可行】
然而并不清楚哪出了问题
先这么放着吧
*/
#include<stdio.h>
#define MAXN 120
#define TRUE 1
#define FALSE 0
#define ERROR -1
struct checkpoint{
	int minStratTime;
	int inEdgeCount;
	int finished;
	int loose;
}gCheckpointTable[MAXN];

int gMatrix[MAXN][MAXN];
int gCountInput[MAXN][MAXN]={0};

void InitCheckpointTable()
{
	int i;
	for(i=0;i<MAXN;i++)
	{
		gCheckpointTable[i].minStratTime=0;
		gCheckpointTable[i].inEdgeCount=0;
		gCheckpointTable[i].finished=0;
		gCheckpointTable[i].loose=0;
	}
}
void InitMatrix(N)
{
	int i,j;
	for(i=0;i<N;i++)
		for(j=0;j<N;j++)
			gMatrix[i][j]=ERROR;
}

int FindPoint(N) //返回一个入度为0并且没被访问过的点
{
	int i;
	int p=ERROR;
	for(i=0;i<N;i++)
	{
		if(gCheckpointTable[i].inEdgeCount==FALSE && gCheckpointTable[i].finished==FALSE)
			p=i;
	}
	return p;
}

void SetLoosePoint(int N,int maxtime) //找出所有的松节点，但是如果没有出边不能算松节点
{
	int i,j;
	int isLoose,count,countEdge,allLoose;
	for(i=0;i<N;i++)
	{
		isLoose=TRUE;
		count=0;
		for(j=0;j<N;j++)
		{
			if(gMatrix[i][j]==ERROR)
				continue;
			count++;
			if(gCheckpointTable[i].minStratTime+gMatrix[i][j]==gCheckpointTable[j].minStratTime)
				isLoose=FALSE;
		}
		if(count!=0)
			gCheckpointTable[i].loose=isLoose;
	}

	do
	{
		count=0;
		for(i=0;i<N;i++)
		{
			if(gCheckpointTable[i].loose==TRUE)
				continue;
			allLoose=TRUE;
			countEdge=0;
			for(j=0;j<N;j++)
			{
				if(gMatrix[i][j]==ERROR)
					continue;
				countEdge++;
				if(gCheckpointTable[j].loose==FALSE)
					{
						allLoose=FALSE;
						break;
					}
			}
			if(allLoose==TRUE && countEdge!=0)
			{
				gCheckpointTable[i].loose=TRUE;
//				printf("set %d  loose\n",i+1);
				count++;
			}
			if(countEdge==0 && gCheckpointTable[i].minStratTime<maxtime)
			{
				gCheckpointTable[i].loose=TRUE;
			}
		}
	}
	while(count);
}

int PrintOredr(int N,int i)
{
	int max,maxIDX,j;
	maxIDX=ERROR;
	max=0;
	for(j=0;j<N;j++)
	{
		if(gCountInput[i][j]>max)
		{
			max=gCountInput[i][j];
			maxIDX=j;
		}
	}
	if(maxIDX != ERROR)
		gCountInput[i][maxIDX]=0;

	return maxIDX;
}
void Calc(int N)
{
	int i,j,maxtime,p;
	while( (p=FindPoint(N)) != ERROR ) //如果还能返回入度为0的点 先叫它v1
	{
		gCheckpointTable[p].finished=TRUE; //先设为处理完成
		for(i=0;i<N;i++)//遍历该点所有发出去的边，找一个连接到的点v2
		{
			if(gMatrix[p][i]==ERROR)
				continue;
   			//如果被指向的结点v2，最小完成时间小于此节点v1的最小完成时间 加上  v1到v2的耗时，那么更新v2的最小时间
			if(gCheckpointTable[i].minStratTime<gCheckpointTable[p].minStratTime+gMatrix[p][i])
				gCheckpointTable[i].minStratTime = gCheckpointTable[p].minStratTime + gMatrix[p][i];
			gCheckpointTable[i].inEdgeCount--; //将v2的入度减一
		}
	}
	maxtime=0;
	for(i=0;i<N;i++) //考虑到有多终点问题，算完后把所有节点全扫一遍，挑一个结束时间最大的打出来
	{
		if(gCheckpointTable[i].finished==FALSE)
		{
			printf("0");
			return;
		}
		if(gCheckpointTable[i].minStratTime>maxtime)
			maxtime=gCheckpointTable[i].minStratTime;
	}
	printf("%d\n",maxtime);
	SetLoosePoint(N,maxtime);
	for(i=0;i<N;i++)
	{
		while((j=PrintOredr(N,i))!=ERROR)
		{
			if(gCheckpointTable[i].loose==FALSE && gCheckpointTable[j].loose==FALSE && gMatrix[i][j]!=ERROR && gCheckpointTable[j].minStratTime==gCheckpointTable[i].minStratTime+gMatrix[i][j])
				printf("%d->%d\n",i+1,j+1);
		}
	}
}

int main()
{
	int i;
	int N,M;
	int v1,v2,lastingTime,count;
	scanf("%d %d",&N,&M);
	InitMatrix(N);
	InitCheckpointTable();
	count=1;
	for(i=0;i<M;i++)
	{
		scanf("%d %d %d",&v1,&v2,&lastingTime);
		gMatrix[v1-1][v2-1]=lastingTime;
		gCheckpointTable[v2-1].inEdgeCount++;
		gCountInput[v1-1][v2-1]=count++;
	}
	Calc(N);
}