7-11 关键活动

最新推荐文章于 2022-06-26 23:42:17 发布

开在初夏-命名忧伤

最新推荐文章于 2022-06-26 23:42:17 发布

阅读量307

点赞数 1

分类专栏： PAT-数据结构与算法题目集（中文）

本文链接：https://blog.csdn.net/fdkNeverStopLearning/article/details/82986604

版权

PAT-数据结构与算法题目集（中文）专栏收录该内容

11 篇文章 0 订阅

订阅专栏

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为该任务开始和完成涉及的交接点编号。关键活动输出的顺序规则是：任务开始的交接点编号小者优先，起点编号相同时，与输入时任务的顺序相反。

输入样例:

输出样例:

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

思路：该题是经典的关键路径问题，做的时候很吃力就多写点分析当复习了。首先在关键路径之前得先用拓扑排序判断是否存在有向无环图，其次在找出关键路径。关键路径是指那些不能被推迟的路径，一旦被推迟就会影响整个工期。拓扑排序是首先将入度为0的顶点入队列中，并依次输出每输出一个顶点时，将与该顶点相关联的其他顶点的入度减一，如果入度为0也加入队列中。循环下去直至队列为空。如果最后输出的顶点和原图中的顶点的数目相同则存在拓扑序，否则则不存在。关键路径的寻找方式：如果存在顶点i到顶点j的路径i->j,用j的最晚开始时间-i的最早开始时间-w(i,j)=0.如果为0则为关键路径。至于j和i的最早和最晚开始时间的怎么求，网上和教材中都有介绍，不清楚的可以看看书。代码中关键路径的实现方法为：定义两个数组，分别为late和early其中存储每个顶点的最晚和最早开始时间，通过循环输出所有的关键路径。

代码如下：

/************************************************************************
*
* 文件名：8.1.1.cpp
*
* 文件描述：
*
* 创建人：  fdk

* 时  间：  2018-10-06
*
* 版本号：1.0
*
* 修改记录：
*
************************************************************************/

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#include<limits.h>
#define MAXVER 105
#define INFINITYS 65535

int G[MAXVER][MAXVER]; //图的邻接矩阵存储
int early[MAXVER];     //最早发生时间
int late[MAXVER];      //最迟发生时间
int in[MAXVER];        //入度
int out[MAXVER];       //出度
int nv, ne;            //顶点数目，边数目

void CreatGraph();
int EarlyTime();
void LateTime(int Scost);
int FindMax(int a, int b);
int FindMin(int a, int b);
using namespace std;

int main()
{
    int flag;
    int i, j;
    cin >> nv >> ne; //输入顶点数和边数

    CreatGraph();   //创建图
    flag = EarlyTime(); //获取到最后一个顶点的最早开始时间（也是最大的）
                        //并将求出每个顶点的最早开始时间
    /*如果不存在有向无环图，则输出0*/
    if (flag == -1)
    {
        cout << "0";
    }
    else
    {
        cout << flag << endl;
        LateTime(flag); //求出每个顶点的最晚开始时间
        for (i = 1; i <= nv; i++)
        {
            for (j = nv; j >= 1; j--)
            {
                if (G[i][j] >= 0 && late[j]-early[i]-G[i][j] == 0)
                {
                    //i,j均在关键路径上
                    cout << i << "->" << j << endl;
                }
            }
        }

    }
    return 0;
}

/*创建图*/
void CreatGraph()
{
    int i, j;
    int s, d, cost; //获取从s到d的花费的时间

    /*初始化矩阵*/
    for (i = 1; i <= nv; i++)
    {
        for (j = 1; j <= nv; j++)
        {
            G[i][j] = -1;
        }
        early[i] = 0;
        late[i] = INFINITYS;
        in[i] = 0;
        out[i] = 0;
    }
    for (i = 0; i < ne; i++)
    {
        cin >> s >> d >> cost;
        G[s][d] = cost; //获取输入顶点和输出顶点以及对应的时间
        in[d]++; //d顶点的入度加一
        out[s]++; //s顶点的出度加一
    }
}

/*求最早开始时间*/
int EarlyTime()
{
    queue<int> q;//声明一个整型队列
    int counts = 0;
    int i, temp, ret = 0;
    /*利用拓扑排序，判断该给定的工程项目是否可行*/
    for (i = 1; i <= nv; i++)
    {
        if (in[i] == 0)
        {
            //如果入度为0则入队
            q.push(i);
        }
    }
    /*如果队列不为空从队列中取出入度为0的顶点*/
    while (!q.empty())
    {
        /*取出队列中的首元素*/
        temp = q.front();
        q.pop();
        counts++;
        for (i = 1; i <= nv; i++)
        {
            /*如果从当前顶点到其它顶点的距离存在，则入度减一*/
            if (G[temp][i] >= 0)
            {
                in[i]--;
                /*从到i点的所花费的时间中选出一个最大的*/
                early[i] = FindMax(early[i], early[temp]+G[temp][i]);
                if (in[i] == 0)
                {
                    q.push(i);
                }
            }
        }
    }
    /*如果为有向有环图则没有拓扑序*/
    if (counts != nv)
    {
        ret = -1;
    }
    else
    {
        ret = early[i];
        for (i = 2; i <= nv; i++)
        {
            if (early[i] > ret)
            {
                /*找出最大的early[i]*/
                ret = early[i];
            }
        }
    }
    return ret;
}

/*最晚开始时间*/
void LateTime(int Scost)
{
    int i;
    queue<int> q;
    int temp;
    for (i = 1; i <= nv; i++)
    {
        /*出度为0的顶点的最早开始时间和最晚开始时间*/
        if (out[i] == 0)
        {
            q.push(i);
            late[i] = Scost;
        }
    }
    /*如果队列不为空，则从队列中取出出度为空的顶点*/
    while (!q.empty())
    {
        /*取出队列中的首元素*/
        temp = q.front();
        q.pop();
        for (i = nv; i >= 1; i--)
        {
            /*如果存在从其他顶点到当前顶点的路径，则将其它顶点的出度减一*/
            if (G[i][temp] >= 0)
            {
                late[i] = FindMin(late[i], late[temp]-G[i][temp]);
                out[i]--;
                /*如果顶点i的出度为0的话，将顶点i入队列*/
                if (out[i] == 0)
                {
                    q.push(i);
                }
            }
        }
    }
}

/*找最大值*/
int FindMax(int a, int b)
{
    if (a > b)
    {
        return a;
    }
    else
    {
        return b;
    }
}

/*找最小值*/
int FindMin(int a, int b)
{
    if (a < b)
    {
        return a;
    }
    else
    {
        return b;
    }
}

参考博客https://www.cnblogs.com/yuxiaoba/p/8358088.html

开在初夏-命名忧伤

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
7-11 关键活动

7-11 关键活动（30 分）假定一个工程项目由一组子任务构成，子任务之间有的可以并行执行，有的必须在完成了其它一些子任务后才能执行。“任务调度”包括一组子任务、以及每个子任务可以执行所依赖的子任务集。比如完成一个专业的所有课程学习和毕业设计可以看成一个本科生要完成的一项工程，各门课程可以看成是子任务。有些课程可以同时开设，比如英语和C程序设计，它们没有必须先修哪门的约束；有些课程则不可...
复制链接

扫一扫