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

最新推荐文章于 2021-08-17 16:09:02 发布

master-dragon

最新推荐文章于 2021-08-17 16:09:02 发布

阅读量3.7k

点赞数 3

分类专栏： # 拓扑-AOE网

本文链接：https://blog.csdn.net/qq_26437925/article/details/47976341

版权

拓扑-AOE网专栏收录该内容

5 篇文章 0 订阅

订阅专栏

关键路径,关键活动

事件的最早发生时间ve
ve(源点) = 0；
ve(k) = max(ve[j] + weight[j,k]),
事件的最迟发生时间vl
vl（终点） = ve(终点)
vl(j) =min(vl(k) - weght[k,j])
活动的最早开始时间e
表示活动的起点所表示的事件最早发生时间。
活动的最迟开始时间l
表示活动的终点所表示的事件最迟发生时间与该活动所需时间之差。
找到所有活动的差额d(),找出d()=0的活动构成关键路径
指活动完成的事件余量，d(i) = l(i) - e(i)

关键路径的注意
* 关键路径上的所有活动都是关键活动，它是决定整个工程的关键因素
* 关键路径并不唯一。对于有几条关键路径的网，只提高一条关键路径上的关键活动并不能缩短整个工程的工期，只有加快那些包括所有关键路径上的关键活动才能达到缩短工期的目的

例子

08-图9 关键活动

题目地址

https://pta.patest.cn/pta/test/1342/exam/4/question/24940

题目描述

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

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

输入样例 1

输出样例 1

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

输入样例 2

输出样例 2

9
1->2
2->4

ac代码

比较复杂的ac代码
使用了邻接表，按照关键路径的思路来求解

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#include <sstream>

using namespace std;

const int N = 105;
const int INF = 0x7fffffff;

struct activity{
    int sta;
    int end;
    int cost;
    bool flag; // sta是否是活动的起点
};

vector<vector<activity>> vedge; // 某个事件的邻接事件

vector<int> in_degree; // 入度
vector<int> out_degree; // 出度
vector<int> ve; // 事件的最早发生时间
vector<int> vl; // 事件的最迟发生时间

vector<activity> vact; // 所有的活动
vector<int> l; // 活动的最早开始时间
vector<int> e; // 活动的最迟开始时间

int n,m;
vector<int> vSta; // 入度为0的原点
vector<int> vEnd; // 出度为0的终点
int MinTime; // 完成时间

// 拓扑排序是否合理
bool isTop(vector<int> in_degree)
{
    vector<bool> vis(n+1,false);

    int num = 0;
    while(num < n)
    {
        int nowNum = -1;
        for(int i=1;i<=n;i++)
        {
            if(!vis[i] && in_degree[i] == 0)
            {
                nowNum = i;
                break;
            }
        }
        if(nowNum == -1)
            return false;

        vis[nowNum] = true;
        in_degree[nowNum] = -1;

        int len = vedge[nowNum].size();
        for(int i = 0; i< len ; i ++)
        {
            activity tmp =  vedge[nowNum][i];
            if(tmp.flag)
            {
                if(vis[tmp.end] == false)
                    in_degree[tmp.end] --;
            }
        }

        num++;
    }

    if(num == n)
        return true;
    return false;
}

void solve_ve()
{
    vector<int>::iterator it = vSta.begin();
    vector<bool> vis(n+1,false);
    while(it != vSta.end())
    {
        queue<int> que;
        que.push(*it);
        ve[*it] = 0;
        vis[*it] = true;

        while(!que.empty())
        {
            int nowNum = que.front();
            que.pop();

            int len = vedge[nowNum].size();
            for(int i=0;i<len;i++)
            {
                activity tmp = vedge[nowNum][i];
                if(tmp.flag)
                {
                    in_degree[tmp.end] --;
                    ve[tmp.end] = max(ve[tmp.end], ve[nowNum] + tmp.cost);
                    if(in_degree[tmp.end] == 0)
                    {
                        que.push(tmp.end);
                        vis[tmp.end] = true;
                    }
                }
            }
        }
        ++it;
    }
}

// 求事件的最迟发生时间
void solve_vl()
{
    vector<int>::iterator it = vEnd.begin();
    vector<bool> vis(n+1,false);
    while(it != vEnd.end())
    {
        int endP = *it;
        vl[endP] = MinTime; // 所有出度为0时间，其时间最迟发生时间为最大的ve[]
        queue<int> que;
        que.push(endP);

        vis[endP] = true;
        out_degree[endP] = -1;

        while(!que.empty())
        {
            int nowNum = que.front();
            que.pop();

            int len = vedge[nowNum].size();
            for(int i = 0; i< len ; i ++)
            {
                activity tmp =  vedge[nowNum][i];
                if(vis[tmp.sta])
                    continue;

                if(tmp.flag == false)
                {
                    out_degree[tmp.sta] --;
                    vl[tmp.sta] = min(vl[tmp.sta], vl[nowNum] - tmp.cost);
                    if(out_degree[tmp.sta] == 0) // 出度为0 可以确定最迟开始时间了
                    {
                        vis[tmp.sta] = true;
                        que.push(tmp.sta);
                    }
                }
            }
        }

        ++it;
    } // end while
}

bool cmp(activity a1,activity a2)
{
    if(a1.sta < a2.sta)
        return true;
    else if(a1.sta == a2.sta)
    {
        if(a1.end > a2.end)
            return true;
    }
    return false;
}

int main()
{
    //freopen("in.txt","r",stdin);

    scanf("%d%d",&n,&m);
    vedge.resize(n+1);
    in_degree.resize(n+1,0);
    out_degree.resize(n+1,0);
    ve.resize(n+1,0);
    vl.resize(n+1,INF);
    vact.clear();
    l.resize(m + 1);
    e.resize(m + 1);
    activity actTmp;
    for(int i=0;i<m;i++)
    {
        scanf("%d%d%d",&actTmp.sta,&actTmp.end,&actTmp.cost);

        actTmp.flag = true;
        vact.push_back(actTmp);
        in_degree[actTmp.end] ++; // 入度
        out_degree[actTmp.sta] ++ ; // 出度
        vedge[actTmp.sta].push_back(actTmp);
        actTmp.flag = false;
        vedge[actTmp.end].push_back(actTmp);
    }

    if(!isTop(in_degree))
    {
        printf("0\n");
        return 0;
    }

    for(int i = 1;i <= n; i++)
    {
        if(in_degree[i] == 0)
            vSta.push_back(i);
        if(out_degree[i] == 0)
            vEnd.push_back(i);
    }

    // ve求解 
    solve_ve();

    // 完成整个工程项目需要的时间
    MinTime = 0;
    for(int i=1;i<=n;i++)
    {
        if(ve[i] > MinTime)
        {
            MinTime = ve[i];
        }
    }

    // vl 求解
    solve_vl();

    vector<activity> critical;
    int criLen = 0;
    // l, e求解, 并求解关键路径
    for(int i=0;i<m;i++)
    {
        l[i] = ve[vact[i].sta];

        e[i] = vl[vact[i].end] - vact[i].cost;

        if(e[i] == l[i]) // d[] = 0
        {
            critical.push_back(vact[i]);
            criLen ++;
        }
    }

    // 按照输出顺序对结果排序
    sort(critical.begin(),critical.end(),cmp);

    printf("%d\n",MinTime);
    for(int i=0;i<criLen;i++)
    {
        printf("%d->%d\n",critical[i].sta,critical[i].end);
    }

    return 0;
}

参考ac代码

采用邻接矩阵求解
http://blog.csdn.net/asunamashiro/article/details/48858621
上面的代码有错误，就是queue的错误,稍作修改即可

采用邻接矩阵，按照求关键路径的步骤，ac代码如下

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <algorithm>
#include <sstream> 
using namespace std;

const int INF = 0x7fffffff;
const int N = 102;  

int Graph[N][N];
int in_degree[N];
int out_degree[N];
int vearly[N];
int vlate[N];
int n,m;
int MinTime; // 最少花费时间
vector<int> vSta; // 入度为0的原点
vector<int> vEnd; // 出度为0的终点

// 求出vearly，并能据此判断是否是合理的调度
bool sol_vearly()
{
    vector<int>::iterator it = vSta.begin();
    vector<bool> vis(n+1,false);
    while(it != vSta.end())
    {
        queue<int> que;
        que.push(*it);
        vearly[*it] = 0;
        vis[*it] = true;

        while(!que.empty())
        {
            int nowNum = que.front();
            que.pop();

            for(int i=1;i<=n;i++)
            {
                if(Graph[nowNum][i] >= 0 && !vis[i])
                {
                    in_degree[i] --;
                    vearly[i] = max(vearly[i], vearly[nowNum] + Graph[nowNum][i]);
                    if(in_degree[i] == 0)
                    {
                        que.push(i);
                        vis[i] = true;
                    }
                }
            }
        }
        ++it;
    }

    for(int i=1;i<=n;i++){
        if(vis[i] == false)
            return false;
        if(vearly[i] > MinTime)
        {
            MinTime = vearly[i];
        }
    }
    return true;
}

// 求事件的最迟发生时间
void solve_vlate()
{
    vector<int>::iterator it = vEnd.begin();
    vector<bool> vis(n+1,false);
    while(it != vEnd.end())
    {
        int endP = *it;
        vlate[endP] = MinTime; // 所有出度为0时间，其时间最迟发生时间为最大的ve[]
        queue<int> que;
        que.push(endP);

        vis[endP] = true;
        out_degree[endP] = -1;

        while(!que.empty())
        {
            int nowNum = que.front();
            que.pop();

            for(int i = 1; i<=n; i ++)
            {
                if(vis[i] || Graph[i][nowNum] < 0)
                    continue;
                out_degree[i] --;
                vlate[i] = min(vlate[i], vlate[nowNum] - Graph[i][nowNum]);
                if(out_degree[i] == 0) // 出度为0 可以确定最迟开始时间了
                {
                    vis[i] = true;
                    que.push(i);
                }

            }
        }

        ++it;
    } // end while
}

int main(int argc, char const *argv[])  
{  
    //freopen("in.txt", "r", stdin);  

    scanf("%d %d", &n, &m);
    // 初始化数据
    for (int i = 1; i <= n; i++)
    {  
        for (int j = 1; j <= n; j++)
            Graph[i][j] = -1;  
        in_degree[i] = 0;  
        out_degree[i] = 0;  
        vearly[i] = 0;  
        vlate[i] = INF;  
    }

    int s, e, c;  
    for (int i = 0; i < m; i++){  
        scanf("%d %d %d", &s, &e, &c);  
        Graph[s][e] = c;  
        out_degree[s]++;  
        in_degree[e]++;  
    }

    for(int i = 1;i <= n; i++)
    {
        if(in_degree[i] == 0)
            vSta.push_back(i);
        if(out_degree[i] == 0)
            vEnd.push_back(i);
    }

    if(!sol_vearly()){
         printf("0\n");
    }else{
        solve_vlate();

        printf("%d\n", MinTime);  
        for (int i = 1; i <= n; i++)
        {  
            for (int j = n; j >= 1; j--)
            {  
                // 活动的最早开始时间 == 活动的最迟开始时间
                if (Graph[i][j] >= 0 && vearly[i] == (vlate[j] - Graph[i][j]))  
                    printf("%d->%d\n", i, j);  
            }  
        }  

    }
    return 0;  
}