用动态规划秒掉一道拓朴排序题目

题目如下

题目描述

John的农场在给奶牛挤奶前有很多杂务要完成，每一项杂务都需要一定的时间来完成它。比如：他们要将奶牛集合起来，将他们赶进牛棚，为奶牛清洗乳房以及一些其它工作。尽早将所有杂务完成是必要的，因为这样才有更多时间挤出更多的牛奶。当然，有些杂务必须在另一些杂务完成的情况下才能进行。比如：只有将奶牛赶进牛棚才能开始为它清洗乳房，还有在未给奶牛清洗乳房之前不能挤奶。我们把这些工作称为完成本项工作的准备工作。至少有一项杂务不要求有准备工作，这个可以最早着手完成的工作，标记为杂务1。John有需要完成的n个杂务的清单，并且这份清单是有一定顺序的，杂务k(k>1)的准备工作只可能在杂务1至k−1中。

写一个程序从1到n读入每个杂务的工作说明。计算出所有杂务都被完成的最短时间。当然互相没有关系的杂务可以同时工作，并且，你可以假定John的农场有足够多的工人来同时完成任意多项任务。

输入格式

第1行：一个整数n，必须完成的杂务的数目(3 ≤n≤10,000)；

第2至(n+1)行： 共有n行，每行有一些用1个空格隔开的整数，分别表示：

* 工作序号(1至n,在输入文件中是有序的)；

* 完成工作所需要的时间(1≤len≤100)；

* 一些必须完成的准备工作，总数不超过100个，由一个数字0结束。有些杂务没有需要准备的工作只描述一个单独的0，整个输入文件中不会出现多余的空格。

输出格式

一个整数，表示完成所有杂务所需的最短时间。

输入输出样例

输入 #1复制

7
1 5 0
2 2 1 0
3 3 2 0
4 6 1 0
5 1 2 4 0
6 8 2 4 0
7 4 3 5 6 0

输出 #1复制

23

思路分析一

拓朴排序:

看到在..前提下...才能去做,,,, ,显然是拓朴排序题,只要在每个节点进队列的时候计算所需时间即可

显然每个结点所需的时间为:所有准备工作最大的时间+自身完成所需的时间(即木桶效应)

OK,思路就是这么简单,直接上代码,

没什么可说的.拓朴排序的模板,这里采用了邻接矩阵

#include<bits/stdc++.h>
using namespace std;

const int MAX = 5e4+5;
const int INF = 0x7fffffff;

int M,N;

struct Work{
    int len,index;
    int inDegree;
    int res;
    vector<int> pre;
    vector<int> next;
}work[MAX];

void topoSort() {
    queue<Work> queue;
    for (int i = 1; i <= N; ++i) {
        if(work[i].inDegree==0) {
            work[i].res=work[i].len;
            queue.push(work[i]);
        }
    }

    while (!queue.empty()) {
        Work root = queue.front();
        queue.pop();
        for (int i = 0; i < root.next.size(); ++i) {
            work[root.next[i]].inDegree--;
            if(work[root.next[i]].inDegree==0) {
                int t = 0;
                for (int j = 0; j < work[root.next[i]].pre.size(); ++j) {
                    t = max(t,work[work[root.next[i]].pre[j]].res);
                }
                work[root.next[i]].res = t+work[root.next[i]].len;
                queue.push(work[root.next[i]]);
            }
        }
    }
}

int main() {
    cin >> N;
    for (int i = 1; i <= N; ++i) {
        int x,condition;
        cin >> x;cin >> work[x].len;
        work[x].index=x;
        while (cin >> condition,condition) {
            work[x].inDegree++;
            work[x].pre.push_back(condition);
            work[condition].next.push_back(x);
        }
    }
    topoSort();
    int res = 0;
    for (int i = 1; i <= N; ++i) {
        res = max(work[i].res,res);
    }
    cout << res << endl;
}

动态规划

思路和之前一样,只要多想一步,就能想到.

状态就是每个结点完成所需的时间,显然它只取决于它自身的准备工作

OK,直接上代码.

#include<iostream> 
#include<cstdio> 
using namespace std;
int main(){ 
    int t[10001],n,ans=0,k,num,ti,x,y,i;//定这么一大坨东西 
    scanf("%d",&n);
    for(i=1;i<=n;i++){ 
        scanf("%d%d",&k,&ti);
        t[k]=ti;
        scanf("%d",&x);
        while(x!=0){ 
               t[k]=max(t[k],ti+t[x]);
               ans=max(ans,t[k]);//更新操作
            scanf("%d",&x);
        } 
    } 
    printf("%d",ans);
    return 0;
}