精华内容
下载资源
问答
  • 软件设计师--最早开始时间和最晚开始时间

    万次阅读 热门讨论 2018-04-20 18:03:53
    先求最早开始时间:A是开始节点,所以A的最早开始时间是0,并且最早开始时间等于最晚开始时间。等得到图中红色的部分。 其他节点的最早开始时间为以该节点作为弧头的所有有向弧的值+弧尾的值 的最大值,看例子就...

    题目如图所示,解法如下:

     

    方法:

    先求最早开始时间:A是开始节点,所以A的最早开始时间是0,并且最早开始时间等于最晚开始时间。等得到图中红色的部分。

    其他节点的最早开始时间为以该节点作为弧头的所有有向弧的值+弧尾的值 的最大值,看例子就明白了:

    然后求其B的最早开始时间,由B作为弧头的有向弧只有<A,B>且值为2,A的最早开始时间为0,所以B的最早开始时间为0+2=2,得到绿色的结果。

    求C的最早开始时间,以C为弧头的弧只有<B,C>且值为3,B的最早开始时间为2,所以C的最早开始时间为2+3=5,得到黄色结果。

    同理D、G、E的最早开始时间如图所示。

    求F的最早开始时间:以F为弧头的弧有<E,F> <B,F> <G,F> 所对应的值分别为 13 6 13,取MAX{13,6,13}得F的最早开始时间为13,得到紫色结果.

    后面的都一样...

    然后由于J是结束节点,所以最早开始时间与最晚开始时间一样,得到图中的 这个色结果。

     

    接着求最晚开始时间从后往前推。

    先求I的最晚开始时间。应为以I为弧尾的只有弧<I,J>所以,I的最晚开始时间为J的最晚开始时间减去<I,J>的值 18-2=16

    同理F H的最晚开始时间也可以得到。

    求E的最晚开始时间: 以E为弧尾的弧有 <E,H> <E,F> H的最晚开始时间减去<E,H>的值为12   F的最晚开始时间减去<E,F>的值为13-3=10 ,取MIN{12,10}得到E的最晚开始时间为10

    ....

    后面都一样了....

     

    完成项目的最少时间就是结束节点的最早或最晚开始时间 18

    两条关键路径都画在图中了

    BC在关键路径上,所以一天也不能晚;

    BF可以耽搁的时间为 F的最晚-B的最早-<B,F>的值,也就是 13-4-2=7

     

    口诀:最早开始从前往后用加法看弧头最大,最晚开始从后往前用减法看弧尾最小

     

    展开全文
  • 工作M的最迟开始时间为第23天(23+5=28,第28天要开始另外的工作了,所以最晚必须第23天开始),最早开始时间为第16天,所以总时差有7天。 最早完成工作M的时间是第21天,下次项目开始的最早是第25天,所以自由时差...
    工作M的最迟开始时间为第23天(23+5=28,第28天要开始另外的工作了,所以最晚必须第23天开始),最早开始时间为第16天,所以总时差有7天。
    最早完成工作M的时间是第21天,下次项目开始的最早是第25天,所以自由时差是25-21=4天。
    (自由时差,简称FF(Free Float),指一项工作在不影响其紧后工作最早开始时间的条件下,本工作可以利用的机动时间。 )
    总时差就是拖拖拖,可以拖多少天才做工作M,自由时差就是早早完成,然后在下次工作委派之前可以休息多少天。
    展开全文
  • 对于每个活动,列出它的前驱,并计算最早开始时间、最晚开始时间和时差,然后确定出关键路径。 —— 《软件工程 第 4 版》中的原题 写文缘由 网上的文章大都是对于 “点” 求最早开始时间和最晚开始时间。在我看来...

    题目

    下图是一个软件开发项目的活动图,对于图中每条边的数字表示完成这条边代表的活动的天数。例如,完成终止于里程碑E的活动需要 4 天时间。
    对于每个活动,列出它的前驱,并计算最早开始时间、最晚开始时间和时差,然后确定出关键路径。
    —— 《软件工程 第 4 版》中的原题

    写文缘由

    网上的文章大都是对于 “点” 求最早开始时间和最晚开始时间。在我看来,是不准确的。

    对于边的解法,有的写得又太复杂,还是自己写吧。顺便写个程序自动化一下,舒服~

    误区在哪

    需要注意的是,图中的点,并不代表活动,并不能说活动 AA33 天到达活动 BB,这是不准确的,图上的点应该理解为 “里程碑”。如果说到达 里程碑 II 的边有两条 DID \rightarrow IBIB \rightarrow I,意思是有两个活动,完成后到达里程碑 II,并不能说 II 是个活动,如果这么理解会在计算最晚开始时间时出现错误。

    还有一点,时间轴从 11 开始算,即从点 AA 出发时,时刻为 11。有些解法是从 00 开始算的,本文从 11 开始算。

    解法

    • 正推求最早开始时间
      • 公式:ETB=MAX(ETAB+wAB)\text{ET}_{B·} = \text{MAX}(\text{ET}_{AB} + w_{AB} )
      • 已知条件:起点的最早开始时间直接为 1
    • 倒推求最晚开始时间
      • 公式:LTJK=MIN(LTKwJK)\text{LT}_{JK} = \text{MIN}(\text{LT}_{K·} - w_{JK} )
      • 已知条件:终点的最晚开始时间 LTL=ETL\text{LT}_{L·}=\text{ET}_{L·} (因为终点一定在关键路径上,关键路径上的点最早开始时间等于最晚开始时间)

    解题示例


    解:

    先求最早开始时间 (Earliest Time Start):

    • AA 是起点,所有由 AA 出发的边的最早开始时间都为 11。即 ETAB=ETAE=ETAC=ETA=1\text{ET}_{AB} = \text{ET}_{AE} = \text{ET}_{AC} =\text{ET}_{A·}= 1
    • 来算 BB 的最早开始时间,ETBD=ETBI=ETB=MAX(ETAB+wAB)=4\text{ET}_{BD} = \text{ET}_{BI} = \text{ET}_{B·} =\text{MAX}(\text{ET}_{AB}+w_{AB}) =4。因为只有 AA 才能到达 BB,所以 MAX 内只有一个值。
    • 来算 EE 的最早开始时间,ETEG=MAX(ETAE+wAE)=5\text{ET}_{EG} =\text{MAX}(\text{ET}_{AE}+w_{AE}) =5。因为只有 AA 才能到达 EE,所以 MAX 内只有一个值。
    • 来算 CC 的最早开始时间,ETCF=MAX(ETAC+wAC)=6\text{ET}_{CF} =\text{MAX}(\text{ET}_{AC}+w_{AC}) =6。因为只有 AA 才能到达 CC,所以 MAX 内只有一个值。
    • 接下来 DGFD、G、F 同理,省去废话,结果是:ETDI=MAX(ETBD+wBD)=9\text{ET}_{DI} =\text{MAX}(\text{ET}_{BD}+w_{BD}) =9ETGJ=ETGH=ETG=MAX(ETEG+wEG)=8\text{ET}_{GJ} =\text{ET}_{GH}=\text{ET}_{G·} =\text{MAX}(\text{ET}_{EG}+w_{EG}) =8ETFH=MAX(ETCF+wCF)=9\text{ET}_{FH} =\text{MAX}(\text{ET}_{CF}+w_{CF}) =9
    • 看一下 II,入度为 22ETIJ=MAX(ETDI+wDI,ETBI+wBI)=MAX(11,10)=11\text{ET}_{IJ} =\text{MAX}(\text{ET}_{DI}+w_{DI}, \text{ET}_{BI}+w_{BI}) =\text{MAX}(11, 10) =11,下面的同理
    • ETHK=MAX(ETGH+wGH,ETFH+wFH)=MAX(11,10)=11\text{ET}_{HK} =\text{MAX}(\text{ET}_{GH}+w_{GH}, \text{ET}_{FH}+w_{FH}) =\text{MAX}(11, 10) =11
    • ETJL=ETJK=MAX(ETIJ+wIJ,ETGJ+wGJ)=MAX(13,10)=13\text{ET}_{JL}=\text{ET}_{JK} =\text{MAX}(\text{ET}_{IJ}+w_{IJ}, \text{ET}_{GJ}+w_{GJ}) =\text{MAX}(13, 10) =13
    • ETKL=MAX(ETJK+wJK,ETHK+wHK)=MAX(15,15)=15\text{ET}_{KL}=\text{MAX}(\text{ET}_{JK}+w_{JK}, \text{ET}_{HK}+w_{HK}) =\text{MAX}(15, 15) =15
    • ETL=MAX(ETJL+wJL,ETKL+wKL)=MAX(21,18)=21\text{ET}_{L·}=\text{MAX}(\text{ET}_{JL}+w_{JL}, \text{ET}_{KL}+w_{KL}) =\text{MAX}(21, 18) =21

    自此,最早开始时间全部算完。

    再求最晚开始时间 (Latest Time Start):

    • 从终点倒着推,LTJL=MIN(LTLwJL)=13\text{LT}_{JL}=\text{MIN}(\text{LT}_{L·}-w_{JL}) =13LTKL=MIN(LTLwKL)=18\text{LT}_{KL}=\text{MIN}(\text{LT}_{L·}-w_{KL}) =18
    • LTJK=MIN(LTKLwJK)=16\text{LT}_{JK}=\text{MIN}(\text{LT}_{KL}-w_{JK}) =16
    • LTIJ=MIN(LTJLwIJ,LTJKwIJ)=11\text{LT}_{IJ}=\text{MIN}(\text{LT}_{JL}-w_{IJ}, \text{LT}_{JK}-w_{IJ}) =11
    • LTGJ=MIN(LTJLwGJ,LTJKwGJ)=11\text{LT}_{GJ}=\text{MIN}(\text{LT}_{JL}-w_{GJ}, \text{LT}_{JK}-w_{GJ}) =11
    • LTHK=MIN(LTKLwHK)=14\text{LT}_{HK}=\text{MIN}(\text{LT}_{KL}-w_{HK}) =14
    • LTDI=MIN(LTIJwDI)=9\text{LT}_{DI}=\text{MIN}(\text{LT}_{IJ}-w_{DI}) =9
    • LTBI=MIN(LTIJwBI)=5\text{LT}_{BI}=\text{MIN}(\text{LT}_{IJ}-w_{BI}) =5
    • LTGH=MIN(LTHKwGH)=11\text{LT}_{GH}=\text{MIN}(\text{LT}_{HK}-w_{GH}) =11
    • LTBD=MIN(LTDIwBD)=4\text{LT}_{BD}=\text{MIN}(\text{LT}_{DI}-w_{BD}) =4
    • LTEG=MIN(LTGJwGH,LTGHwEG)=8\text{LT}_{EG}=\text{MIN}(\text{LT}_{GJ}-w_{GH}, \text{LT}_{GH}-w_{EG}) =8
    • LTFH=MIN(LTHKwFH)=13\text{LT}_{FH}=\text{MIN}(\text{LT}_{HK}-w_{FH}) =13
    • LTCF=MIN(LTFHwCF)=10\text{LT}_{CF}=\text{MIN}(\text{LT}_{FH}-w_{CF}) =10
    • LTAB=MIN(LTBDwAB,LTBIwAB)=1\text{LT}_{AB}=\text{MIN}(\text{LT}_{BD}-w_{AB},\text{LT}_{BI}-w_{AB}) =1
    • LTAE=MIN(LTEGwAE)=4\text{LT}_{AE}=\text{MIN}(\text{LT}_{EG}-w_{AE}) =4
    • LTAC=MIN(LTCFwAC)=5\text{LT}_{AC}=\text{MIN}(\text{LT}_{CF}-w_{AC}) =5

    (上述过程,看似繁琐,但是考试计算时,在图中对应的边上边写边算,还是挺快的)

    根据上述数据,列表如下(其中冗余时间等于最早最晚两者的差):

    活动 前驱 最早开始时间 最晚开始时间 时差(冗余时间)
    AB 1 1 0
    BD AB 4 4 0
    BI AB 4 5 1
    DI AB,BD 9 9 0
    IJ AB,BD,DI,BI 11 11 0
    AE 1 4 3
    EG AE 5 8 3
    GJ AE,EG 8 11 3
    JL AB,BD,BI,DI,IJ,AE,EG,GJ 13 13 0
    AC 1 5 4
    CF AC 6 10 4
    FH AC,CF 9 13 4
    GH AE,EG 8 11 3
    HK AE,EG,GH,AC,CF,FH 11 14 3
    JK AB,BD,BI,DI,IJ,AE,EG,GJ 13 16 3
    KL AB,BD,BI,DI,IJ,AE,EG,GJ,JK,GH,AC,CF,FH,HK 15 18 3

    由上述表格可知,ABBDDIIJJLAB、BD、DI、IJ、JL 活动的时差为 00,即为关键节点,因此关键路径为 ABDIJL=20A\rightarrow B\rightarrow D\rightarrow I\rightarrow J\rightarrow L=20

    程序实现

    诶,写个程序验证一下手算的正确与否吧。

    #include <bits/stdc++.h>
    using namespace std;
    #define rep(i,s,t) for(int i=s;i<=t;i++)
    const int maxn = 105;
    const int INF = 0x3f3f3f3f;
    
    int n, m, S, T;
    
    struct Edge {
        int u, v, w, ET, LT;
        Edge(int _u,int _v,int _w,int _ET,int _LT):u(_u),v(_v),w(_w),ET(_ET),LT(_LT){}
    };
    vector<Edge*> G[maxn], GT[maxn], Edges; // 正图和反图
    
    int calcET(Edge *e)
    {
    	if (e->u == S)
            return e->ET = 1;
    
        for(Edge *ee : GT[e->u])
            e->ET = max(e->ET, (ee->ET==-1?calcET(ee):ee->ET) + ee->w);
    
    	return e->ET;
    }
    
    int calcLT(Edge *e)
    {
    	if (e->u == T)
            return e->LT = e->ET;
    
        for(Edge *ee : G[e->v])
            e->LT = min(e->LT, (ee->LT==INF?calcLT(ee):ee->LT) - e->w);
    
        return e->LT;
    }
    
    bool vis[maxn];
    vector<int> path;
    void dfs(int u)
    {
        if (u == T)
        {
            path.push_back(u);
            for(int i=0;i<path.size();i++)
                printf(i!=path.size()-1?"%c->":"%c\n", path[i]+'A'-1);
            path.pop_back();
            return;
        }
        vis[u] = true;
        for (Edge *e : G[u])
            if(!vis[e->v] && e->ET==e->LT)
            {
                path.push_back(u);
                dfs(e->v);
                path.pop_back();
            }
        vis[u] = false;
        return;
    }
    
    char s[5];
    int main()
    {
        freopen("out.txt", "w", stdout);
        scanf("%d%d",&n,&m);
        rep(i,1,m)
        {
            int u, v, w;
            scanf("%s", s); u = s[0]-'A'+1;
            scanf("%s", s); v = s[0]-'A'+1;
            scanf("%d", &w);
            Edge* e = new Edge(u, v, w, -1, INF);
            G[u].push_back(e);
            GT[v].push_back(e);
            Edges.push_back(e);
        }
        // 默认 1 是起点, n 是终点,起点入度为 0,终点出度为 0,数据合法。不是的话得改造程序求个拓扑之类的。
    	S = 1;
    	T = n;
    	// 算 ET
    	G[T].push_back(new Edge(T, -1, 0, -1, INF));
    	calcET(G[T].back());
    	// 算 LT
    	calcLT(new Edge(-1, S, 0, -1, INF));
    	// 输出表
        for(Edge *e : Edges)
            printf("%c%c\t%d\t%d\t%d\n", e->u+'A'-1, e->v+'A'-1, e->ET, e->LT, e->LT-e->ET);
        printf("%c.\t%d\t%d\t%d\n", G[T].back()->u+'A'-1, G[T].back()->ET, G[T].back()->LT, G[T].back()->LT-G[T].back()->ET);
        // 求关键路径
        dfs(S);
    	return 0;
    }
    /*
    12 16
    A B 3
    A E 4
    A C 5
    B D 5
    B I 6
    E G 3
    C F 3
    D I 2
    I J 2
    G J 2
    G H 3
    F H 1
    J L 8
    J K 2
    H K 4
    K L 3
    
    
    12 15
    A B 2
    B C 3
    B F 4
    B D 2
    C E 5
    D G 3
    E H 2
    E F 3
    F I 5
    G I 6
    I J 2
    I K 4
    J L 1
    K L 2
    H L 3
    
    
    12 17
    A B 5
    A E 3
    A C 4
    B D 6
    B I 4
    E G 4
    C F 3
    D I 3
    I J 3
    G I 2
    G J 7
    F G 6
    F H 3
    J L 9
    H J 3
    H K 6
    K L 2
    
    12 17
    A B 5
    A E 3
    A C 4
    B D 6
    B I 4
    E G 4
    C F 3
    D I 5
    I J 4
    G I 2
    G J 7
    F G 6
    F H 3
    J L 9
    H J 3
    H K 6
    K L 2
    
    12 17
    A B 6
    A E 10
    A C 4
    B D 6
    B I 4
    E G 4
    C F 3
    D I 5
    F G 6
    G I 2
    G J 7
    I J 4
    F H 3
    J L 9
    H J 3
    H K 6
    K L 2
    
    */
    

    尾巴

    好的,感谢你看到这里,对文章有错误的地方欢迎指出,谢谢。
    如果觉得本文写得不错,不妨点赞、评论、收藏、分享,你的三连是对我最大的支持!

    我的 Github:zhangt2333’s Github
    我的 CSDN:zhangt2333’s CSDN
    我的 博客园:zhangt2333’s cnblog
    我的 小书房:https://zhangt.top/

    本文作者:zhangt2333
    版权声明:本博客所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议 。转载请注明出处!

    展开全文
  • 这篇文章通过求aoe最早开始时间以及最迟开始时间来求关键路径 在求之前需要把图放到一个邻接链表之中 关键路径 关键路径是指设计中从输入到输出经过的延时最长的逻辑路径。优化关键路径是一种提高设计工作速度的...

    这篇文章通过求aoe最早开始时间以及最迟开始时间来求关键路径
    在求之前需要把图放到一个邻接链表之中
    关键路径

    关键路径是指设计中从输入到输出经过的延时最长的逻辑路径。优化关键路径是一种提高设计工作速度的有效方法。一般地,从输入到输出的延时取决于信号所经过的延时最大路径,而与其他延时小的路径无关。在优化设计过程中关键路径法可以反复使用,直到不可能减少关键路径延时为止。EDA工具中综合器及设计分析器通常都提供关键路径的信息以便设计者改进设计,提高速度。

    所以先给出用的顶点结构以及边结构

    typedef struct arc {
    	int index; // 指向顶点下标
    	int info; //边值
    	struct arc *nextArc;  //指向下一条边
    }arcNode;	//边结构
    
    typedef struct vertex {
    	int info;    // 顶点值
    	arcNode *firstArc;  //指向第一条边
    }vertexNode,*verList;		//顶点结构
    
    typedef struct {
    	verList vertices; 	//邻接表 
    	int vexNum, arcNum; 	//图的顶点数和边数 
    }Graph,*ALGraph;
    

    在求的过程中用到拓扑排序,先给栈定义

    typedef struct stack{
    	int *base;
    	int *top;
    	int stackSize;
    }stack;
    

    求最早开始时间

    下标0太麻烦,所以统一从1开始

    
    /*	G1为邻接链表
    *	G2为逆邻接链表,用于求各顶点入度
    *	T 用于之后求之后的最迟开始时间,这里没有作用
    */
    bool topologicalsort(ALGraph &G1, ALGraph &G2, stack &T)
    {
    	stack S;
    	init_stack(S, G1->vexNum + 1);//初始化栈
    	int* inDegree = findinDegree(G2); //对各顶点求入度
    
    	for (int i = 1;i <= G1->vexNum;i++)
    	{
    		if (inDegree[i] == 0)  //将入度为 0 的顶点入栈
    		{
    			push(S, i);
    		}
    	}
    	int count = 0; //记录栈中元素的个数
    	int i = 1,k = 0;
    	while (!isEmpty(S))
    	{
    		pop(S, i);  //i为当前链表中入度为0的顶点
    		push(T, i);
    		count++;
    		arcNode* p = G1->vertices[i].firstArc;
    		for (;p;p = p->nextArc) //遍历一个顶点的所有后继顶点
    		{
    			k = p -> index;
    			if (!(--inDegree[k]))//i顶点的后继顶点入度减一,如果入度为0,则入栈
    				push(S, k);
    			if (G1->vertices[i].info + p->info > G1->vertices[k].info)
    			{
    				G1->vertices[k].info = G1->vertices[i].info + p->info;
    				G2->vertices[k].info = G1->vertices[k].info;
    			}//如果前驱顶点加上边的值比当前顶点值大,则赋值
    		}
    	}
    	if (count < G1->vexNum)
    		return false;
    	return true;
    }
    

    求最迟发生时间

    //返回各个顶点最迟发生时间
    //path用于存放关键路径
    int* latestTime(ALGraph &G1, stack &T,int* &path)
    {
    	int* lt = new int[G1->vexNum+1];
    
    
    	int i = 0,j = 1, k = 1,data=1;
    	if (!pop(T, i)) //弹出T中最后一个元素,即收束节点
    	{
    		return NULL;
    	}
    	lt[i] = G1->vertices[i].info; //收束节点的值等于本身
    	for (int n = 0;n <= G1->vexNum;n++)//初始化各个顶点的最迟发生时间
    	{
    		lt[n] = lt[i];
    	}
    	while (!isEmpty(T))
    	{
    		pop(T, k);
    		arcNode* p = G1->vertices[k].firstArc;
    		if(p) //给第 k 个节点赋值
    			path[k] = p->index;
    		for (;p;p = p->nextArc) //遍历k节点的所有后继
    		{
    			j = p -> index; 
    			if (lt[k] > G1->vertices[j].info - p->info)
    			{
    				lt[k] = G1->vertices[j].info - p->info;
    				G1->vertices[k].info = G1->vertices[j].info - p->info;
    				path[k] = p->index;
    			}
    		}
    	}
    	return lt;
    }
    

    最后给出测试函数

    int main()
    {
    	ALGraph G1 = new Graph;
    	ALGraph G2 = new Graph;
    	stack T;
    	init_adjList(G1); //初始化邻接表
    	init_conAdjList(G1,G2); //初始化逆邻接表
    	init_stack(T, G1->vexNum + 1);//初始化栈
    	topologicalsort(G1,G2, T);
    	int k = *(T.base+1);
    	int *a,*c;
    	a = traAdjList(G1);
    	for (int i = 1;i <= G1->vexNum;i++) 
    	{
    		cout <<"v"<<i<<"的最早发生时间为"<< a[i]<<'\t';
    	}
    	cout << endl;
    	int* path = new int[G1->vexNum + 1];
    	int *b = latestTime(G1,T,path);
    	for (int i = 1;i <= G2->vexNum;i++) 
    	{
    		cout << "v" << i << "的最晚发生时间为" << b[i] << '\t';
    	}
    	cout << endl;
    	cout << "关键路径为:";
    	for (int i = 1;k>0;i++)
    	{
    		cout << k << " -> ";
    		k = path[k];
    	}
    	return 0;
    }
    

    测试值
    在这里插入图片描述

    在这里插入图片描述

    有错误欢迎大家指正

    展开全文
  • /**抓取切割之后的一级包材工位序号最早开始时间*/ //key=包材+工位+序号,value=开始时间 Map&lt;String,Date&gt; supStartime = new HashMap&lt;String,Date&gt;(); Date startTime = null;/...
  • 1)一个点的最早/最晚时间是有公式或者技巧求出来的 2)一个活动的最晚开始几天不影响,或者一...一、一个点的最早开始时间:从起点到该点的最长(大)的值 A:起点,最早开始时间为0 B:起点到B只有AB=2 C:起点到...
  • ![图片](https://img-ask.csdn.net/upload/201512/06/1449378627_834004.jpg)
  • 场景:一张定单有多个环节,一个环节可能出现多次,计算每个环节从派发到完成的时间1.介绍 LAST_VALUE 和 FIRST_VALUE 函数2.sql实战示例 1.介绍 LAST_VALUE 和 FIRST_VALUE 函数 函数的作用恰如其名,取出首尾记录...
  • 简而言之,就是earliest time和latest time的定义,两者都是基于Activity的,就是字面意思,但是都是(最早/最晚)开始时间 还定义了 ;">关键Activity ,即earliest time == latest time的Activity ...
  • 每次从队列中弹出一个结点作为当前结点进行处理,将其后继结点的入度减一,若为0则入队列,若当前结点的最早开始时间加上该结点到后继节点的路径时间大于后继节点原有的最早开始时间,则更新后继节点的最早开始时间...
  • 数据结构AOE网关键路径问题,不算活动差,直接看事件最迟最早差,差为0的就是关键路径,这样做对么? 数据结构AOE网关键路径问题,不算活动差,直接看事件最迟最早差,差为0的就是关键路径,这样做对么?我做了几道...
  • } } } //-----------------前面基本和拓扑排序一样,只加了最早开始时间的计算 //倒着来 for(int i=result.size()-1;i>=0;i--){ int u=result[i]; if(graph[u].size()==0){ latetime[u]=earlytime[u]; }else{ ...
  • 关键路径:最早开始时间 计算方式:每个节点找它到下个节点的最大路径 具有最大路径长度的路径为关键路径。因为你得保证每个人都到场才能去看电影嘛,那你肯定得等到最后一个人到了才能走。图中就是v...
  • 关键路径法将项目分解成为多个独立的活动并确定每个活动的工期,然后用逻辑关系(结束-开始、结束-结束、开始-开始开始结束)将活动连接,从而能够计算项目的工期、各个活动时间特点(最早最晚时间、时差)等。...
  • 关键路径法将项目分解成为多个独立的活动并确定每个活动的工期,然后用逻辑关系(结束-开始、结束-结束、开始-开始开始结束)将活动连接,从而能够计算项目的工期、各个活动时间特点(最早最晚时间...
  • select nvl(min(to_date(start_time,'mm/dd/yy hh24:mi:ss')),sysdate) as trancDate from sys.v_$transaction 如果存在事务,去最早事务的开始时间,不存在事务就取当前系统时间;
  • 仿滴滴时间选择器,最早最晚出发时间开始结束时间。过滤时间。自定义时间选择器,效果图https://mp.csdn.net/console/editor/html/109441069
  • storm-kafka 使用SpoutConfig 设置startOffsetTime 为指定时间戳读取kafka中数据,为什么还是每次从最早的位置读取,求解决,急急

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,898
精华内容 1,159
关键字:

最早开始时间