7-11 关键活动

7-11 关键活动（30 分）

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

比如完成一个专业的所有课程学习和毕业设计可以看成一个本科生要完成的一项工程，各门课程可以看成是子任务。有些课程可以同时开设，比如英语和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

思路：拓扑排序检验是否有环存在，然后用关键路径来进行输出—>多起点多终点和最大N，随机，可行过不去。这个PTA平台好的地方就是你提交了还能知道自己错在哪，要是在杭电碰到这题那才是真的绝望，按照之前的上课思维默认第一个点都是入度为零的起始节点，最后的结点为出度为零的终止结点，要是这样子的话下面的这组数据输出来的答案肯定是对不上的，于是我想到需要知道起始节点和终止结点，所以在这个题中我借助了change数组在topo函数中该拓扑排序序列，以解决多起点多终点和最大N时，序列号随机且可行的情况。
#include<stdio.h>
#include<limits.h>
#include<queue>
#include<string.h>
#include<iostream>
using namespace std;
#define MAXN 200
typedef struct ArcNode{
    int adjvex;                    //该弧所指向的顶点
    int weight;                //用于存储权值
    struct ArcNode *nextarc;//指向下一条弧的指针
}ArcNode;                    //表结点

typedef struct VNode{
    int date;                //顶点信息
    int into;                //该结点的入度
    ArcNode *firstarc;            //第一个表结点的地址,指向第一条依附该顶点的弧的指针   
}VNode, AdjList[MAXN];        //头结点

typedef struct {
    AdjList vertices;
    int vexnum;            //顶点的数量
    int arcnum;            //弧的数量
}ALGraph;

void CreateALGraph(ALGraph *Gp)
{
    cin >> Gp->vexnum >> Gp->arcnum;
    
    for (int i = 1; i <= Gp->vexnum; i++)                //初始化顶点信息
    {
        Gp->vertices[i].date = i;
        Gp->vertices[i].into = 0;
        Gp->vertices[i].firstarc = NULL;
    }
    for (int i = 0; i < Gp->arcnum; i++)
    {
        int vi, vj, w;
        cin >> vi >> vj >> w;
        ArcNode *arc = new ArcNode;
        arc->adjvex = vj;
        arc->weight = w;
        arc->nextarc = Gp->vertices[vi].firstarc;
        Gp->vertices[vi].firstarc = arc;
        Gp->vertices[vj].into++;
    }
}
bool topo(ALGraph G)
{
    queue<int>que;
    int sum = 0, flag[MAXN];                        //flag用来标记已经输出的顶点
    memset(flag, 0, sizeof(flag));
    for (int i = 1; i <= G.vexnum; i++)            //把入度为0的顶点入栈
    if (G.vertices[i].into == 0){ que.push(i); flag[i] = 1; }
    while (!que.empty()){
        int temp = que.front();
        //cout << temp << endl;
        sum++; que.pop();
        ArcNode *pos = G.vertices[temp].firstarc;
        while (pos != NULL){
            G.vertices[pos->adjvex].into--;
            pos = pos->nextarc;
        }
        
        for (int i = 1; i <= G.vexnum; i++)            //把入度为0的顶点入栈
        if (G.vertices[i].into == 0 && !flag[i]){ que.push(i); flag[i] = 1; }
    }

    return sum == G.vexnum ? true : false;
}
void CriticalPath(ALGraph G)
{
    int ve[MAXN], vl[MAXN];

    //************************
    //    以下是求最早发生时间
    //************************
    for (int i = 1; i <= G.vexnum; i++)
        ve[i] = 0;
    for (int i = 1; i <= G.vexnum; i++)
    {
        ArcNode *pos = G.vertices[i].firstarc;
        while (pos != NULL){
            int temp = pos->adjvex;
            if (ve[i] + pos->weight > ve[temp])
                ve[temp] = ve[i] + pos->weight;
            pos = pos->nextarc;
        }
    }

    //***********************
    //以下是求最迟发生时间
    //***********************
    int max = 0;
    for (int i = 1; i <= G.vexnum;i++)
    if (max < ve[i])max = ve[i];
    cout << max << endl;
    for (int i = 1; i <= G.vexnum; i++)
        vl[i] = max;
    
    for (int i = G.vexnum; i >=1 ; i--)
    {
        ArcNode *pos = G.vertices[i].firstarc;
        while (pos != NULL){
            int temp = pos->adjvex;
            if (vl[temp] - pos->weight < vl[i])
                vl[i] = vl[temp] - pos->weight;
            pos = pos->nextarc;
        }
    }

    //******************************
    for (int i = 1; i <= G.vexnum; i++)
    {
        ArcNode *pos = G.vertices[i].firstarc;
        while (pos != NULL){
            int temp = pos->adjvex;
            int e = ve[i];
            int l = vl[temp] - pos->weight;
            if (e == l)
                cout << i << "->" << temp << endl;
            pos = pos->nextarc;
        }
    }

}
int main()
{
    ALGraph G;
    CreateALGraph(&G);
    if (!topo(G)){
        cout << "0" << endl;
        return 0;
    }
    CriticalPath(G);
    return 0;
}
未AC代码
下面是一组很好的样例：来自http://blog.csdn.net/rxq20081235/article/details/60766993




输入样例：
7 8
3 1 1
3 2 2
1 4 4
2 4 3
4 6 2
4 7 2
6 5 2
7 5 2
输出样例：
9
1->4
2->4
3->2
3->1
4->7
4->6
6->5
7->5




 以下是AC代码：




#include<stdio.h>
#include<limits.h>
#include<queue>
#include<string.h>
#include<iostream>
using namespace std;
#define MAXN 200
typedef struct ArcNode{
    int adjvex;                    //该弧所指向的顶点
    int weight;                //用于存储权值
    struct ArcNode *nextarc;//指向下一条弧的指针
}ArcNode;                    //表结点

typedef struct VNode{
    int date;                //顶点信息
    int into;                //该结点的入度
    ArcNode *firstarc;            //第一个表结点的地址,指向第一条依附该顶点的弧的指针   
}VNode, AdjList[MAXN];        //头结点

typedef struct {
    AdjList vertices;
    int vexnum;            //顶点的数量
    int arcnum;            //弧的数量
}ALGraph;
int change[MAXN];                //借此来保存拓扑排序
void CreateALGraph(ALGraph *Gp)
{
    cin >> Gp->vexnum >> Gp->arcnum;
    
    for (int i = 1; i <= Gp->vexnum; i++)                //初始化顶点信息
    {
        Gp->vertices[i].date = i;
        Gp->vertices[i].into = 0;
        Gp->vertices[i].firstarc = NULL;
    }
    for (int i = 0; i < Gp->arcnum; i++)
    {
        int vi, vj, w;
        cin >> vi >> vj >> w;
        ArcNode *arc = new ArcNode;
        arc->adjvex = vj;
        arc->weight = w;
        arc->nextarc = Gp->vertices[vi].firstarc;
        Gp->vertices[vi].firstarc = arc;
        Gp->vertices[vj].into++;
    }
}
bool topo(ALGraph G)
{
    queue<int>que;
    int sum = 0,  flag[MAXN];                        //flag用来标记已经输出的顶点
    memset(flag, 0, sizeof(flag));
    for (int i = 1; i <= G.vexnum; i++)            //把入度为0的顶点入栈
    if (G.vertices[i].into == 0){ que.push(i); flag[i] = 1; }
    while (!que.empty()){
        int temp = que.front();
        //cout << temp << endl;
        sum++; que.pop();
        change[sum] = temp;
        ArcNode *pos = G.vertices[temp].firstarc;
        while (pos != NULL){
            G.vertices[pos->adjvex].into--;
            pos = pos->nextarc;
        }
        
        for (int i = 1; i <= G.vexnum; i++)            //把入度为0的顶点入栈
        if (G.vertices[i].into == 0 && !flag[i]){ que.push(i); flag[i] = 1; }
    }

    return sum == G.vexnum ? true : false;
}
void CriticalPath(ALGraph G)
{
    int ve[MAXN], vl[MAXN];

    //************************
    //    以下是求最早发生时间
    //************************
    for (int i = 1; i <= G.vexnum; i++)
        ve[i] = 0;
    for (int i = 1; i <= G.vexnum; i++)
    {
        ArcNode *pos = G.vertices[change[i]].firstarc;
        while (pos != NULL){
            int temp = pos->adjvex;
            if (ve[change[i]] + pos->weight > ve[temp])
                ve[temp] = ve[change[i]] + pos->weight;
            pos = pos->nextarc;
        }
    }

    //***********************
    //以下是求最迟发生时间
    //***********************
    for (int i = 1; i <= G.vexnum; i++)
        vl[i] = ve[change[G.vexnum]];
    cout << ve[change[G.vexnum]] << endl;
    for (int i = G.vexnum; i >=1 ; i--)
    {
        ArcNode *pos = G.vertices[change[i]].firstarc;
        while (pos != NULL){
            int temp = pos->adjvex;
            if (vl[temp] - pos->weight < vl[change[i]])
                vl[change[i]] = vl[temp] - pos->weight;
            pos = pos->nextarc;
        }
    }

    //******************************
    for (int i = 1; i <= G.vexnum; i++)
    {
        ArcNode *pos = G.vertices[i].firstarc;
        while (pos != NULL){
            int temp = pos->adjvex;
            int e = ve[i];
            int l = vl[temp] - pos->weight;
            if (e == l)
                cout << i << "->" << temp << endl;
            pos = pos->nextarc;
        }
    }

}
int main()
{
    ALGraph G;
    CreateALGraph(&G);
    if (!topo(G)){
        cout << "0" << endl;
        return 0;
    }
    CriticalPath(G);
    return 0;
}














        

	      

	    

	  

	  

	    
      
        【推广】
        免费学中医，健康全家人
      
	  

    

    

          原文地址：https://www.cnblogs.com/zengguoqiang/p/8447386.html