精华内容
下载资源
问答
  • 关键链(Critical Chain)是由高德拉特(Eli Goldratt)博士提出的一种基于约束理论(Theory of Constraints)的项目管理方法。关键链项目管理基于从约束理论导出的方法和算法。
  • 关键在线 内联关键路径css并异步加载现有样式表。 现有的链接标记也将被包装在因此禁用了javascript的用户将看到该网站正常呈现。 安装 该模块通过npm安装: $ npm install inline-critical 用法示例 const inline ...
  • Laravel软件包,用于生成和使用内联关键路径CSS。 为什么? 为了获得最佳性能,您可能需要考虑将关键CSS直接内联到HTML文档中。 这消除了关键路径中的其他往返,并且如果操作正确,可用于传递“一个往返”关键路径...
  • 该插件将提取关键CSS并在所有文件发出后运行,因此您可以在Mini CSS Extract插件和HTML Webpack插件之后使用它。 查看或阅读博客文章以获取更多用法信息。 安装 npm i --save-dev html-critical-webpack-plugin ...
  • 关键路径: 即决定一项工程的完成时间的路径。 如下图所示,是一辆汽车的生产流程,其中外壳、发动机、轮子等的生产过程都是可以并行进行的,但是发送机生产需要的时间最长,而只有所有零部件生产完成才才能进行下...

    背景:本文是在小甲鱼数据结构教学视频中的代码的基础上,添加详细注释而完成的。该段代码并不完整,仅摘录了核心算法部分,结合自己的思考,谈谈理解。

    关键路径:

    即决定一项工程的完成时间的路径。

    如下图所示,是一辆汽车的生产流程,其中外壳、发动机、轮子等的生产过程都是可以并行进行的,但是发送机生产需要的时间最长,而只有所有零部件生产完成才才能进行下一步,因此图中用红色加粗的那一条路径即为该工程的关键路径(即决定工程的实际完成时间的路径)。

    CriticalPath算法理解:

    此算法是在拓扑排序的基础上进行的,首先对AOE图完成拓扑排序,并将排序结果保存在栈中(代码中是栈stack2)。

    在拓扑排序完成之后,计算各个事件(顶点)、活动(弧)的etv、ltv、ete、lte的值。

    其中lte = ete的活动(弧)即为关键活动,关键活动连接成为关键路径。

    代码如下:(有详细注释)(较容易理解)

    /* 弧 edge */
    typedef struct EdgeNode
    {
    	int adjvex;	// 弧指向的顶点位置(下标)
    	struct EdgeNode *next;
    }EdgeNode;
    
    /* 顶点 node */
    typedef struct VertexNode
    {
    	int in;		// 顶点入度
    	int data;
    	EdgeNode *firstedge;	// 第1个依附于该顶点的弧
    }VertexNode, AdjList[MAXVEX];
    
    /* 邻接表 */
    typedef struct
    {
    	AdjList adjList;
    	int numVertexes;
    	int numEdges;
    }graphAdjList, *GraphAdjList;
    
    int *etv, *ltv;
    int *stack2;		// 用于存储拓扑序列的栈
    int top2;				// stack2的栈顶指针
    
    /* 拓扑排序算法 */
    /* 若GL无回路 则输出拓扑排序序列并返回OK 否则返回ERROR */
    /* 拓扑排序仅改变这些顶点的排列顺序(这里是按顺序存放在stack2中) 而并不改变顶点之间的连接关系 */
    Status TopologicalSort(GraphAdjList GL)
    {
    	EdgeNode *e;
    	int i, k, gettop;
    	int top = 0;		// 用于栈指针下标索引
    	int count = 0;	// 用于统计输出顶点的个数
    	int *stack;			// 用于存储入度为0的顶点(用于拓扑排序的栈)
    
    	stack = (int *)malloc(GL->numVertexes * sizeof(int));
    
    	for( i=0; i < GL->numVertexes; i++ )
    	{
    		if( 0 == GL->adjList[i].in )
    		{
    			/* 将入度为0的顶点下标入栈 */
    			stack[++top] = i;
    		}
    	}
    
    
    	top2 = 0;
    	etv = (int *)malloc(GL->numVertexes*sizeof(int));
    	/* 初始化etv都为0 */
    	for( i=0; i < GL->numVertexes; i++ )
    	{
    		etv[i] = 0;
    	}
    	stack2 = (int *)malloc(GL->numVertexes*sizeof(int));
    
    	/* 拓扑排序 */
    	while( 0 != top )
    	{
    		/* 出栈 */
    		gettop = stack[top--];
    		/* 原本拓扑排序这里需要打印 */
    		// printf("%d -> ", GL->adjList[gettop].data);
    		/* 保存拓扑序列顺序 */
    		stack2[++top2] = gettop;
    		/* 记录拓扑排序输出顶点个数(用以判断是否存在环路) */
    		count++;
    
    		/* 取出一个入度为0的顶点后 以它为前驱的顶点入度-1 */
    		for( e=GL->adjList[gettop].firstedge; e; e=e->next )
    		{
    			k = e->adjvex;
    			/* 入度-1后若为0 则入栈 */
    			if( !(--GL->adjList[k].in) )
    			{
    				stack[++top] = k;
    			}
    
    			/* 如果某一个顶点有多个入度 则该事件需要等待这几个活动都完成才能有效 */
    			/* 故这里判断如果有更长的路径 则替代原本的etv */
    			if( (etv[gettop]+e->weight) > etv[k] )
    			{
    				etv[k] = etv[gettop] + e->weight;
    			}
    		}
    	}
    
    	/* 如果count小于顶点数 说明存在环 */
    	if( count < GL->numVertexes )
    	{
    		return ERROR;
    	}
    	else
    	{
    		return OK;
    	}
    }
    
    /* 求关键路径 */
    /* GL为有向图 输出GL的各项关键活动 */
    void CriticalPath(GraphAdjList GL)
    {
    	EdgeNode *e;
    	int i, gettop, k, j;
    	int ete, lte;
    
    	/* 调用改进后的拓扑排序 */
    	/* 求出etv数组(事件最早发生时间)和stack2(拓扑序列) */
    	TopologicalSort(GL);
    
    	/* 初始化ltv(事件最晚发生时间)都为汇点的时间(ltv是由汇点开始倒推的) */
    	ltv = (int *)malloc(GL->numVertexes*sizeof(int));
    	for( i=0; i < GL->numVertexes; i++ )
    	{
    		/* 汇点的发生时间(汇点etv=ltv) */
    		ltv[i] = etv[GL->numVertexes-1];
    	}
    
    	/* 从汇点倒推计算ltv */
    	while( 0 != top2 )
    	{
    		/* 第一个出栈的是汇点 */
    		gettop = stack2[top2--];
    
    		/* 汇点无firstedge 故直接出栈下一个点 */
    		/* 只有有出度的顶点 firstedge才不为空 */
    		for( e=GL->adjList[gettop].firstedge; e; e=e->next )
    		{
    			k = e->adjvex;
    
    			/* 如果某一个顶点有多个出度 则在计算ltv时需要选择通过这几条出度算得的ltv的最小值 */
    			/* 为了因为如果没有选择其中的最小值 则计算出更小的ltv的那条出度的路径将导致汇点延时 */
    			/* 故这里判断如果有更小的ltv结果 则替代原本的ltv */
    			if( (ltv[k] - e->weight) < ltv[gettop] )
    			{
    				ltv[gettop] = ltv[k] - e->weight;
    			}
    		}
    	}
    
    	/* 通过etv和ltv 求ete和lte */
    	for( j=0; j < GL->numVertexes; j++ )
    	{
    		for( e=GL->adjList[j].firstedge; e; e=e->next )
    		{
    			k = e->adjvex;
    			/* 顶点(事件)的etv即它的出度的弧(活动)的ete */
    			ete = etv[j];
    			/* 弧(活动)的lte即它所指向的下一个顶点(事件)的ltv-弧的权值weight */
    			lte = ltv[k] - e->weight;
    
    			/* ete = lte的事件即为关键活动 连接成为关键路径 */
    			if( ete == lte )
    			{
    				/* 输出关键路径 */
    				printf("<v%d,v%d> length: %d , ", GL->adjList[j].data, GL->adjList[k].data, e->weight );
    			}
    		}
    	}
    }

     

    ——cloud over sky

     ——2020/3/12

     

     

     

     

    展开全文
  • 关键CSS直接内联到HTML文档中可以消除额外的请求,并且可以用来传递“单向”关键路径,其中只有HTML是阻塞资源。 您可以将此插件与一起使用, 联您的其他资产/源,例如小图像,SVG或渲染阻止脚本。 用法和输入 要...
  • Critical-css-inliner允许您提取和内嵌HTML页面中的关键(折叠)CSS。 加快可能会有所帮助。 这个怎么运作 Critical-css-inliner查找所有外部样式表( <link rel="stylesheet" href="..."> )。 它提取关键...
  • webpack-关键-css-inliner 这是一个Webpack插件,可使用Puppeteer内嵌关键的(折叠的)CSS。 Webpack-critical-css-inliner在后台使用 ,因此它非常快。 如果您使用自适应设计,那么webpack-critical-css-inliner...
  • CriticalPath Algorithm implementation for critical path in c++ and javascript Use(用途) Estimate time for plans(用于做计划,预估时间) For usage LICENSE MIT
  • AOE网中求解关键路径(Critical Path)

    千次阅读 2020-06-03 01:24:14
    首先推荐有个b站视频,讲关键路径讲的非常好,20min可搞懂:https://www.bilibili.com/video/BV1PW41187vc?from=search&seid=40093726432206649 ...找到图的关键路径属于项目管理的范围,应由项目经理严格

    首先推荐有个b站视频,讲关键路径讲的非常好,20min可搞懂:https://www.bilibili.com/video/BV1PW41187vc?from=search&seid=40093726432206649

    一、概念

    AOE网: 用顶点表示事件,用边表示活动,权表示活动持续的时间。

    AOE网可回答的问题有:完成整个工程至少需要多长时间?哪些活动是影响工程进度的关键?活动的最早开始时间和最晚开始时间?活动的总浮动和自由浮动时间?

    找到AOE网的关键路径属于项目管理的范围,应由项目经理严格把控和协调每个活动的最早/最晚开始时间,以致于不影响项目的完成日期。

    关键路径:决定项目最早完成时间的一系列活动。如果两个或多个路径的长度相同,则可以有多个关键路径。项目经理应密切监控关键路径上活动的表现,以避免项目延迟完成。

    free float自由浮动:一项活动可以被延迟的时间,而不会延迟任何紧随其后的活动的提前开始。

    total float总浮动:一个活动可能从其早期开始被延迟的时间量,而不会延迟计划的项目完成日期。

    Forward pass:确定较早的开始和完成日期   ES(最早开始时间)

    Backward pass :确定较晚的开始和完成日期  LF (最晚开始时间)

    二、例子:

    1.  Construct the CPM Network Diagram

    用结点表示事件,边表示活动,括号里的数值代表活动的持续时间。

     2.  Calculate the Forward Pass, Backward Pass, Free Float

    先规定一下: Dij来表示一条边,则i表示出度,j表示入度。比如A12 , F56。v来表示结点,如v1 , v2。

    ES:最早开始时间

    顶点(事件)的最早开始时间:如上公式,比如求V(4)的最早开始时间,V(4)可由V(2)+D(4)得来,也可以由V(5)+E(5)得来,取两者最大值作为v(4)的ES。通俗讲,结点4可由结点2或结点5得来,将这些代价算出来取最大值即可。最早开始时间不应该尽可能取最小吗,这里为什么取最大值呢?因为结点4要开始,则它之前的工作必须全部做完,假设它之前需要做两份工作,一份花费1h,一份花费2h,则必须等这两份工作都做完后(等待一个两者中时间的最大值)才能开始开启结点4的事件。

    边(活动Dij )的最早开始时间 = V(i),比如活动G,该活动的最早开始时间等于结点4的最早开始时间。

    LF:   最晚开始时间

    顶点(事件)的最晚开始时间:从Finish结点开始,往前去计算。比如结点2,既可以通过3返回,也可以通过4返回,这时取这俩值中的最小值。可以这样理解,比如由结点3的LF推得结点2的LF为第一天,由结点4的LF推得结点2的LF为第二天。这里可得结点2的LF应为第一天,如果结点2选择第二天开始的话,则结点4就不能在指定时间完成了,会延误。

    边(活动Dij )的最晚开始时间 = V(J)的最晚开始时间-duration(活动持续时间)。比如G(6)的最晚开始时间等于V(7)-6。

    Total float: 一个活动可以被延迟多久,而不会影响项目的完成日期。对于每个活动,直接用最晚开始时间-最早开始时间。

    Free float: 一个活动可以被延迟多久,而不会影响紧随其后的活动的提前开始。该活动入度结点的最早开始时间-该活动入度结点的最早开始时间-该活动持续时间。比如F(7).free float = V(6).ES - V(5).ES - F.duration = 23 - 16 - 7 = 0.

     

     3. Critical Path:

    从结点的表格和边的表格都可以看出关键路径。首先明确关键路径上的边没有松弛时间,即最早开始时间=最晚开始时间,关键路径经过的结点也没有松弛时间,最早开始时间=最晚开始时间。

    从结点角度看,1,2,3,4,5,7,8,9的ES等于LF。将这些结点相连,就为关键路径。

    从边的角度看,A,B,C,E,G,I,J的ES等于LF。将这些边用红线标出,如下图。

    从结点表格看,

    1->2->3->5->4->7->8->9

    A-B-C-E-G-I-J = 5+8+3+5+6+6+5 = 38

    展开全文
  • 批判性的 Grunt插件可从HTML提取并内嵌关键路径CSS 入门 如果您以前从未使用过 ...通过为关键CSS指定目标目的地(文件)来使用grunt-critical任务。 下面是test/generated/critical.css 。 同时,指定要扫描的输入HTML
  • 关键路径问题(Critical Path)——图】

    千次阅读 多人点赞 2020-11-27 23:37:59
    关键路径问题(Critical Path)一、基本术语三级目录二级目录三级目录二级目录三级目录 AOE网(Activity On Edges)------用边表示活动的网络 1、用一个有向图表示一个工程的各子工程及其相互制约的关系,弧表示活动...


    AOE网(Activity On Edges)------用边表示活动的网络
    1、用一个有向图表示一个工程的各子工程及其相互制约的关系,弧表示活动,权表示活动持续的时间,顶点表示事件(活动的开始或结束时间),称这种有向图为边表示活动的网,简称AOE网。
    2、AOE网用来估算工程的完成时间。

    一、基本术语

    源点:入度为0的顶点(只有一个)
    汇点:出度为0的顶点(只有一个)
    路径长度:路径上各活动持续时间之和
    整个工程完成的时间:从有向图的源点到汇点的最长路径
    关键路径:路径长度最长的路径

    在这里插入图片描述

    在这里插入图片描述

    二、如何求关键路径

    1、问题分析

    在这里插入图片描述

    2、求关键路径的步骤

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    三、算法实现

    1、算法思想

    (1)设每个结点的最早发生时间为0,将入度为0的结点进栈
    (2)将栈中入度为0的结点V取出,并压入另一个栈,用于形成逆向拓扑排序的序列
    (3)根据邻接表找到结点V的所有的邻接结点,将结点V的最早发生时间+活动的权值 得到的和同邻接结点的原最早发生时间进行比较;如果该值大,则用该值取代原最早发生时间。另外,将这些邻接结点的入度减一。如果某一结点的入度变为0,则进栈。
    (4)反复执行2、3;直至栈空为止。

    2、算法描述

    Status CriticalPath(ALGraph G)
    {
    	//G为邻接表存储的有向网,输出G的各项关键活动
    	if (!TopologicalOrder(G, topo)) return ERROR;
    	//调用拓扑排序算法,使拓扑序列保存在topo中,若调用失败,则存在有向环
    	n = G.vexnum;			//n为顶点的个数
    	for (i = 0;i < n;i++)			//给每个事件的最早发生时间置初值为0
    		ve[i] = 0;
    	/*按照拓扑次序求每个事件的最早发生时间*/
    	for (i = 0;i < n;i++)			//for循环结束才能求得最早发生时间
    	{
    		k = topo[i];			//取得拓扑序列中的顶点序号k
    		p = G.vertices[k].firstarc;			//p指向k的第一个邻接点
    		while (p != NULL)			//依次更新k的所有邻接顶点的最早发生时间
    		{
    			j = p->adjvex;			//j为邻接顶点的序号
    			if (ve[j] < ve[k] + p->weight)			//更新顶点j的最早发生时间ve[j]
    				ve[j] = ve[k] + p->weight;
    			p = p->nextarc;			//p指向k的下一个邻接顶点
    		}
    	}
    	for (i = 0;i < n;i++)			//给每个事件的最迟发生时间置初值为ve[n-1]
    		vl[i] = ve[n - 1];
    	/*按逆拓扑次序求每个事件的最迟发生时间*/
    	for (i = n - 1;i >= 0;i--)
    	{
    		k = topo[i];			//取得拓扑序列中的顶点序号k
    		ArcNode* p = G.vertices[k].firstarc;			//p指向k的第一个邻接顶点
    		while (p != NULL)
    		{	//根据k的邻接点,更新k的最迟发生时间
    			j = p->adjvex;			//j为邻接顶点的序号
    			if (vl[k] > vl[j] - p->weight)			//更新顶点k的最迟发生时间vl[k]
    				vl[k] = > vl[j] - p->weight;
    			p = p->nextarc;			//p指向下一个邻接顶点
    		}
    	}
    	/*判断每一活动是否为关键活动*/
    	for (i = 0;i < n;i++)
    	{ //每次循环针对vi为活动开始点的所有活动
    		p = G.vertices[i].firstarc;			//p指向i的第一个邻接顶点
    		while (p != NULL)
    		{
    			j = p->adjvex;			//j为i的邻接顶点的序号
    			e = ve[i];			//计算活动<vi,vj>的最早开始时间
    			l = vl[j] - p->weight;			//计算活动<vi,vj>的最迟开始时间
    			if (e == l)		//若为关键活动,输出<vi,vj>
    				cout << G.vertices[i].data << G.vertices[j].data;
    			p = p->nextarc;			//p指向i的下一个邻接顶点
    		}
    	}
    }
    
    展开全文
  • 条件2:关键路径是最长路径的那条,最长意味着这条路径的最后一个任务的完成时间最长。用来表示完成整个工程至少需要多少时间。 PS:其他例子 【例2】 【例3】 Other XMind简答题和填空题复习笔记、选择题Doc文档:...


    一、画任务框 task box

    任务框通常用六个框画。 持续时间和浮动在中间,四个任务日期在角落,就像这样:
    在这里插入图片描述

    1. Duration:持续时间。意思是要花几天搞完。
    2. Early Start (ES): 最早开始,意思是从第几天开始。
    3. Early Finish (EF): 最早结束,意思是直到第几天结束,包含这天。
    4. Late Start (LS): 最晚开始。
    5. Late Finish (LF): 最晚结束。意思是Deadline。
    6. Float:浮动时间。意思是可以拖延几天直到Deadline,Float = LF – EF(最晚结束-最早结束)

    二、过程

    1. Draw Box

    根据任务的前后关系,如题目一般会给出Predecessor,画出各任务框,并用线按顺序连起来。
    在这里插入图片描述

    2. Enter Durations

    填入题目给出的Duration。
    在这里插入图片描述

    3. ES & EF

    • Forward Pass:从左到右计算。
    • 从第1天开始:第一个任务的ES=1
    • 同一个任务框中:EF=ES+Duration-1。(因为包含这天所以-1)
    • 计算下一个任务框:ES2=EF1+1。其中,对于有两个前驱节点的,选择更大的EF(更晚的最早完成)。
      在这里插入图片描述

    4. LS & LF

    • Backward Pass:从右到左计算。
    • 最后的任务的 LF=所有task中最大的EF。(如例3就是搞错了这个)
    • 同一个任务框中:LS = LF – Duration + 1。(因为包含这天所以+1)
    • 计算上一个任务框:LF2=LS1-1。其中,对于有两个后继节点的,选择更小的LS(更早的最晚开始)。
      在这里插入图片描述

    5. Float

    Float = LF – EF(最晚结束-最早结束)
    在这里插入图片描述

    6. Float=0 & LS/FS最大

    关键路径:
    条件1:Float=0(或最小)的任务在所形成的路径。
    条件2:关键路径是最长路径的那条,最长意味着这条路径的最后一个任务的完成时间最长。用来表示完成整个工程至少需要多少时间。

    在这里插入图片描述

    PS:其他例子
    【例2】
    在这里插入图片描述
    在这里插入图片描述
    【例3】
    在这里插入图片描述


    Other

    XMind简答题和填空题复习笔记、选择题Doc文档:98uq

    展开全文
  • 关键CSS解析器 Critical-css-parser使您可以接收critical(首屏)和其余CSS。 加快网页的初始呈现可能会有所帮助。 。 输入信息有3种类型: HTML和CSS , URL和localServer 。 Critical-css-parser在使用和 ,...
  • 关键Critical Section

    2013-04-13 11:09:46
    关键CRITICAL_SECTION一共就四个函数,使用很是方便。下面是这四个函数的原型和使用说明。   函数功能:初始化 函数原型: void InitializeCriticalSection(LPCRITICAL_SECTIONlpCriticalSection); ...
  • 关键路径 计算通过任务网络的。 假设给定的图是非循环的(没有循环)。 任务网络由节点组成,但它也组织在父节点中。 这允许我的节点/任务模型支持任务的递归嵌套。 例如,包含多个任务的整体“项目”节点本身...
  • 紧急关键css Eleventy插件,用于从HTML模板中提取和内嵌关键(折叠)CSS。 您只需两步即可轻松地将此插件添加到Eleventy项目中,或者可以将index.js用作自己的关键CSS实现的参考! 开始使用 安装eleventy-critical...
  • 演示示例这里一个有关键区锁死问题的程序,运行之后依次点击“CS锁死”按钮、右上角退出按钮,程序就会卡死。(图1) 对于眼下的这个问题,界面完全失去响应,这说明负责消息处理的UI线程阻塞了。对于几乎所有的...
  • void criticalpath(graph g) { if(!topulogicalsort(g)) { cout存在回路"; return ; } for(int i=0;i;i++) //初始化事件最迟开始时间 vl[i]=ve[g.vertexnum-1]; while(!ss.empty()) { int k=ss.top()...
  • 一种用于检测关键节点的新本地化算法的免费开源实现。 该软件使用无编码编程技术(PWCT)开发 http://doublesvsoop.sourceforge.net
  • void criticalpath(graph g) { if(!topulogical(g)) { cout存在回路"; return ; } for(int i=0;i;i++) { vl[i]=ve[g.vertexnum-1]; //初始化事件最迟开始时间,等于汇点的最早开始时间, //当然除...
  • const critical = require('critical'); critical.generate({ inline: true, base: 'D:/love.github.io/AmJson/md5/', src: 'md5.html', target: { html: 'index-critical.html', css: 'critical.css', }, ...
  • Applications are increasingly critical for ensuring business success, mission completion, and even human safety.The standard approach to building critical applications relies on a bottom-up strategy: ...
  • 用于关键 Css 的 Broccoli 插件 安装 $ npm install --save-dev broccoli-critical 用法 var broccoli - critical = require ( 'broccoli-critical' ) ; tree = broccoli - critical ( tree ) ; 应用程序接口 ...
  • Critical:在HTML页面中提取和内联CSS关键路径
  • 关键信息基础结构 研究针对关键信息基础架构的攻击的防护的安全性和有效性
  • 关键CSS生成器 用于从URL生成关键CSS的Docker服务 用法 将必须生成关键CSS的网站URL...保存critical.css文件的位置。 默认为/output URL=<website> LOCATION=/<your> docker-compose up 该位置是相对于当前目录的。
  • 强烈反对 gulp模块,针对文件或url生成关键CSS 地位 此模块正在开发中,如果现在实施,只会破坏您的过程。 当它以一种或另一种方式可用时,它将更新状态。 执照
  • 在多线程环境,对资源进行访问的...1、关键段与互斥量,两者都因为有“线程所有权”,所以只能用于线程的互斥,不可以用于线程的同步。 2、在同一个进程的多线程同步锁,宜用关键段锁,它的效率比互斥量要高!  
  • 线程同步--关键CRITICAL_SECTION

    千次阅读 2016-06-06 16:31:37
    关键CRITICAL_SECTION一共就四个函数,使用很是方便。下面是这四个函数的原型和使用说明。 函数功能:初始化 函数原型: VOID WINAPI InitializeCriticalSection( __out LPCRITICAL_SECTION lpCriticalSection ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,740
精华内容 11,896
关键字:

关键critical