精华内容
下载资源
问答
  • 本文不光会说明常见的轮胎规格参数是什么意思,代表什么档次,也会跟大家聊聊一些不常见的轮胎符号是什么含义。家用车我们以日产轩逸为例来说明轮胎的基本规格参数含义一般来说在轮胎的胎壁上会有如图这样一串数字,...

    本文不光会说明常见的轮胎规格参数是什么意思,代表什么档次,也会跟大家聊聊一些不常见的轮胎符号是什么含义。

    家用车我们以日产轩逸为例来说明轮胎的基本规格参数含义

    一般来说在轮胎的胎壁上会有如图这样一串数字,不同的轮胎写的位置不一样,有的比较靠中间,有的比较靠边缘,字体大小也不一样,不过他们的基本组成不会变。

    21093f365b2d83ffff231b40d6fc3dc9.png

    日产轩逸的轮胎

    215/50R17 91V

    • 215表示轮胎的宽度为215mm
    • 50:表示轮胎的扁平比,也就是断面高度占其宽度的百分比。扁平比计算方式如下图。
    dd2213ff0e7d2bf1dcbb1cef69a736bc.png

    扁平比含义

    • R:子午线轮胎,英文单词radial 首字母,表示的是一种轮胎帘线的排布方法,子午线轮胎的帘线层排布是与轮胎横截面垂直排布,就像地球的本初子午线那样,所以称之为子午线轮胎。
    5494e635e4a91125cbf0dd6577664df5.png

    轮胎的结构

    子午线轮胎的优缺点

    优点:使用寿命长,滚动阻力小,承载能力大,减震性能好。

    缺点:胎侧薄,成本高,不能与斜线轮胎混装,需按规定轮胎换位,不能超载。

    • 17:表示轮毂的直径,也是大家最能直观感受的外观,一般来说高配车的轮毂尺寸更大。1英寸约等于2.54厘米。
    378795e28b0bc1d22aa920b5eb39dae0.png

    轮辋直径

    91:单胎载重系数,即表示单个轮胎最大承重能力。该系数单位并不是kg,需要换算一下才能变成kg,下列是换算表。Li就表示承重系数,经过换算得知轩逸的最高配车型,单轮最大承重为615kg。

    4622424abc4ddb04cae54cbf66a7d606.png
    • V:表示轮胎的最大许可速度。一般来说,轮胎的最大许可速度跟轮胎的成本直接相关,一般来说许可速度越高的轮胎其使用寿命就越长,抗疲劳性能越好。查表得知,轩逸轮胎所对应的的最许可速度为240km/h,比较良心。要知道顶配的大众帕萨特,轮胎许可速度也才是V的等级,而一般的中级轿车都是W级别的。
    470c00ecee3648c3f1381a9852f705ff.png

    以上介绍完了常见的轮胎的规格参数,我们再来看看其他一些特殊的轮胎参数。

    • 轮胎产地和生产日期

    如下图所示,轮胎上有YYY2720的标志,YYY代表轮胎厂家工厂代号,而2720表示20年第27周生产的,推算以下生产时间是2020年5月11至5月17日。

    9688563f58466bb52c5457bab707a75f.png

    轮胎产地和日期

    • 轮胎上的特殊符号

    除了以上一些常规的数字之外,轮胎上通常还会有一些特殊的符号,比如说下图的符号,依次表示的节能、环保、耐磨、静音。节能和环保就是省油,低排放的意思,一般是说明该轮胎滚阻较小,消耗燃油更少,排出的有害气体就更少。

    abe606f5b21ca027edee11f05ee5bccf.png

    除此之外,还有四季胎或者雪胎的符号。M+S表示该轮胎可以适应雪地和泥地,一般来说这样的轮胎等同于四季胎,这样的轮胎相比普通轮胎,在雪地的抓地力大10%左右。

    7626cb6f660e167c5fc68f769054357c.png

    冬季胎或者叫四季胎

    最后,利用以上学习的知识,我们做实战演练:

    前段时间新款的飞度在做麋鹿测试的时候,发生了爆胎,你们猜本田飞度的轮胎最大承重系数是多少?欢迎评论留言。

    d61c10a8fb5a8f990f485467009dcb86.png

    飞度麋鹿测试爆胎

    展开全文
  • 尤其空字符和数字0之间。 为了明确的指出,0空字符的含义,用用到了: ((void *) 0) 这个表达式。表示把0强制转换为空字符,不管以前代表的什么含义。 在c的标准头文件中,就是这样定义NULL的: #define NULL...

    一、在c语言中,0是一个特殊的值,它可以表示:整型数值0,空字符,逻辑假(false)。表示的东西多了,有时候不好判断。尤其是空字符和数字0之间。

    为了明确的指出,0是空字符的含义,用用到了: ((void *) 0) 这个表达式。表示把0强制转换为空字符,不管以前代表的什么含义。

    在c的标准头文件中,就是这样定义NULL的:

    #define NULL     ((void *) 0)

    关于void在指针的应用:

    void表示“无类型”,void *表示无类型指针。在定义指针的时候,必须声明指针的类型,因为类型决定了指针移动的字节数。

    例题:

    double d=3.14;
    double *dptr=&d;
    int *iptr=dptr;   //错误,double和int占用不同的字节,编译报错。
    double d=3.14;
    double *dptr=&d;
    void *vptr=dptr  //正确,无类型指针可以接受任何类型的指针。

    二、那么这种“无类型的指针”能进行取值操作吗?可以,但是要注意:

    下面的做法是正确的:

    #include <stdio.h>
    int main(int argc, char *argv[])
    {
        double d=3.14;
        double *dptr=&d;
        void *vptr=dptr;
        printf("vptr's value %f.\n",*((double*)vptr));
        int i=10;
        vptr=&i;
        printf("vptr's value %d.\n",*((int*)vptr));
    
        return 0;
    }

    *((double*)vptr)的含义是:把vptr强制转换为double类型指针,再用*号取值。

    因为:*为单目运算符,优先级由右至左,所以去掉外层括号也是可以的。*((double *)vptr) 等价  *(double *)vptr

    三、不能把“无类型指针”赋给“有类型指针”,比如:可以说,“男人女人都是人”,但不能说,“人是男人”或者“人是女人”。看例题:

    void *vptr;
    double *dptr
    
    dptr=vptr      //错误,不能把无符号指针赋给有符号指针

     

    展开全文
  • 首先,你需要了解每一个 Support ...而这里,v 之后的数字,就代表着它能够被使用的最低版本等级,之所以无法在更低版本进行使用的原因,因为随着版本的升级,在新版本中有很多之前不支持的特性或者 API,因此如果你

      首先,你需要了解每一个 Support 包版本后缀 vX 所代表的含义。当然诸位都一定知道 Android 对于每一个版本都有一个版本号,例如1.6是4,2.1是7,3.2是13,4.0是14,4.4是19,6.0是23。而这里,v 之后的数字,就代表着它能够被使用的最低版本等级,之所以无法在更低版本进行使用的原因,是因为随着版本的升级,在新版本中有很多之前不支持的特性或者 API,因此如果你在老版本中使用了这些支持包,就可能会导致应用崩溃。

    现在,我们从头开始逐个浏览目前所支持的 support 包:

    (1)support-v4

    support-v4包算是 Android 最低等级的支持包。所谓的 v4,代表着它最低支持 Android1.6(API 4),这个版本算得上是一个真正意义上比较成熟的 Android版本,更何况现在我们写应用的时候一般都只最低支持到 Android 2.x 系统,对于1.x 的系统基本已经已经完全抛弃了,因此你可已经他作为最基本的系统组件使用。

    在 support-v4包中,它所拥有的类还是很多的,主要包含了对应用组件的支持,用户交互体验的一些工具类,一些数据网络方面的工具类,相面我们将详细来看看它里面具体的一些类。

    1.系统组件部分

    Fragment:其实 Fragment 是直到 Android3.0才正式进入 Android 框架体系的,但是 Android 为了低版本的兼容,因此他帮我们在低版本也适配了 Fragment 框架。

    NotificationCompat:这是通知栏的一些适配,可以帮助你在低版本的通知栏显示更加丰富的信息。

    LocalBroadcastManager:这个是用于本地广播通知的,当你希望发送的通知只被本应用接收时,你就应该使用它。

    2.用户界面交互部分

    ViewPager,这个相信我不用怎么说了,他主要用于帮助我们进行界面间的滑动交互。

    PagerTitleStrip,PagerTabStrip 这两个算是 ViewPager 的帮助类吧,他们的作用是进行 Tab 栏的切换辅助显示。

    DrawerLayout,主要用于侧滑栏的实现。

    SlidingPaneLayout,这个类也是用于侧滑栏的实现,和 DrawerLayout 不同的是,DrawerLayout 侧滑栏出来的时候,默认是覆盖在当前页面上,而 SlidingPaneLayout 则是会将当前页面移走。

    3. Accessbility访问的帮助类

    ExploreByTouchHelper,帮助自定义 View 实现 Accessibility 的工具类。

    AccessibilityEventCompat, AccessibilityNodeInfoCompat, AccessibilityNodeProviderCompat, AccessibilityDelegateCompat,这几个都是用作 Accessibility 功能适配的类。

    4.数据访问帮助类

    Loader,主要用于异步加载数据首先

    FileProvider,提供应用间的文件分享功能。 

    (2)support-v7

    1.Appcompat*

    这个包的主要作用是为了在低版本实现 Android 的 Holo 风格界面而引入的,与之类似的有一个开源项目叫做 SherlockActionbar。

    2.Card*

    卡片布局是最近在 android 5.0发布的时候才引入的新包,在我看来,他主要效果是让应用进行卡片花显示。

    3.GridLayout

    网格布局能够帮助你将整个布局按照一格两格的格子形式进行排列。

    4.MediaRouter

    这个布局主要是用来支持 GoogleCast 的,主要用于进行设备间的音频,视频交换显示。

    5.Palette

    这个包也是最新出来的,他的作用是帮助 Android 实现他的 MaterialDesign,让你的 Actionbar 能够根据界面进行对应的颜色改变。

    7.RecyclerView

    这个包同样也是刚出来的,他的作用是替换 ListView 和 GridView,但是可惜是没有实现 OnItemClick 这些接口,你需要自己处理它。 

    (3)support-v8

    support-v8中其实只有一格特性,就是用来渲染脚本。 

    (4)support-v13

    这个包的作用主要是为 Android 3.2级以上的系统提供更多地 Fragment 特性支持,使用它的原因在于,android-support-v4包中虽然也对 Fragment 做了支持,由于要兼容低版本,导致他是自行实现的 Fragment 效果,在高版本的 Fragment 的一些特性丢失了,而对于 v13以上的 sdk 版本,我们可以使用更加有效,特性更多的代码。 

    (5)support-v17

    这个包得主要作用是用于支持电视设备,并为电视设备提供了很多组件。例如下面的:

    BrowseFragment, DetailFragment, PlaybasckOverlayFragment, SearchFragment

    但是原谅我没有做过 Android TV 开发,我也不知道他们的用处是什么,如果真的想要查看,请去官网看看吧


    转自:http://www.2cto.com/kf/201411/350928.html

    展开全文
  • 两个开关的组合决定了整个模拟通道的总放大倍数, 对应的刻度范围 0.1V、 0.2V、0.5V、 1V、 2V 和 5V。 SEC/DIV( 时基) 该参数决定屏幕上水平方向的一格长度所代表的时间长短。 例如, 如果你选的时基 5ms,...
  • 33、数字转字符有多少种方式,分别是什么 22 34、Java创建对象有几种方式 22 35、写出验证Email的正则表达式 22 39、说出十种常见的异常 22 40什么是检查性异常和非检查性异常? 23 41、Java的异常处理机制是什么? ...
  • * 修正了在IP1里不能用快捷建 "Ctrl+C" "Ctrl+V" 等问题! 使复制和粘贴更方便! * 软件介面大小可以自由调整!使用更方便! * "肉鸡查找"增加了识别对方系统版本功能!使"肉对查找"有更体贴的感受! * "木马种植"可以只...
  • PT80-NEAT开发指南v1.1

    2014-06-24 18:38:34
    V 1.0 初始版本。 2012-04-12 V1.1 修改前三章内容 2012-09-25 目录 第一章 关于本手册..........................................................................................................................
  • ``` <svg xmlns="http://www.w3.org/2000/svg" width="54" height="100"><path fill="#EBEEEF" d="M6 0h42c3.312 0 6 2.688 6 6v88c0 3.312-2.688 6...后面跟的一些数字是什么的?为什么不能换行谢谢,感激不尽。
  • 1.0.28 可分离性假设的含义是什么? 32 B1.4 可分离矩阵方程的正式推导 32 1.0.29 本章要点 34 1.0.30 式(1.108)在线性图像处理中的意义是什么? 34 1.0.31 这本书有些什么内容呢? 36 第2章 图像变换 37 ...
  • 最大流

    千次阅读 2019-05-25 22:06:06
    1. 什么是最大流问题? 首先要先清楚最大流的含义,就是说从源点到经过的所有路径的最终到达汇点的所有流量和。 流网络G=(V,E)一个有向图,其中每条边(u,v)∈E均有一个非负容量c(u,v)>=0。如果(u,v)不属于E,则...

    1. 什么是最大流问题?

    首先要先清楚最大流的含义,就是说从源点到经过的所有路径的最终到达汇点的所有流量和。

    流网络G=(V,E)是一个有向图,其中每条边(u,v)∈E均有一个非负容量c(u,v)>=0。如果(u,v)不属于E,则假定c(u,v)=0。流网络中有两个特别的顶点:源点s和汇点t。下图展示了一个流网络的实例(其中斜线左边的数字表示实际边上的流,右边的数字表示边的最大容量):

    2.基础概念

    容量网络:设G(V,E),是一个有向网络,在V中指定了一个顶点,称为源点(记为Vs),以及另一个顶点,称为汇点(记为Vt);对于每一条弧<u,v>属于E,对应有一个权值c(u,v)>0,称为弧的容量.通常吧这样的有向网络G称为容量网络.

    弧的流量:通过容量网络G中每条弧<u,v>,上的实际流量(简称流量),记为f(u,v);

    网络流: 所有弧上流量的集合f={f(u,v)},称为该容量网络的一个网络流.

    可行流: 在容量网络G中满足以下条件的网络流f,称为可行流.

    a.弧流量限制条件:   0<=f(u,v)<=c(u,v);
    b. 斜对称性:f(u,v) = -f(v,u)
    c:平衡条件:即流入一个点的流量要等于流出这个点的流量,(源点和汇点除外).
    

    若网络流上每条弧上的流量都为0,则该网络流称为零流.

    伪流: 如果一个网络流只满足弧流量限制条件,不满足平衡条件,则这种网络流为伪流,或称为容量可行流.(预流推进算法有用)

    最大流: 在容量网络中,满足弧流量限制条件,且满足平衡条件并且具有最大流量的可行流,称为网络最大流,简称最大流.

    弧的类型:

    a.饱和弧:即f(u,v)=c(u,v);

    b.非饱和弧:即f(u,v)<c(u,v);

    c.零流弧:即f(u,v)=0;

    d.非零流弧:即f(u,v)>0.

    :在容量网络中,称顶点序列(u1,u2,u3,u4,…,un,v)为一条链要求相邻的两个顶点之间有一条弧.

    设P是G中一条从Vs到Vt的链,约定从Vs指向Vt的方向为正方向.在链中并不要求所有的弧的方向都与链的方向相同.

    a.前向弧:(方向与链的正方向一致的弧),其集合记为P+,

    b.后向弧:(方向与链的正方向相反的弧),其集合记为P-.

    增广路:

    设f是一个容量网络G中的一个可行流,P是从Vs到Vt 的一条链,若P满足以下条件:

    a.P中所有前向弧都是非饱和弧,

    b.P中所有后向弧都是非零弧.

    则称P为关于可行流f 的一条增广路.

    沿这增广路改进可行流的操作称为增广.

    残留容量:残留容量的定义为:cf(u,v)=c(u,v)-f(u,v)。而由所有属于G的边的残留容量所构成的带权有向图就是G的残留网络。下图就是上面的流网络所对应的残留网络:
    对应

    残余网络为:
    在这里插入图片描述

    在一个连通图中,如果删掉若干条边,使图不联通,则称这些边为此图的一个割集。在这些割集中流量和最小的一个称为最小割。
    最大流最小割定理:一个图的最大流等于最小。
    https://www.cnblogs.com/TreeDream/p/5929429.html

    增广路径
    增广路径算法的思想是每次从源点出发找到一条到达汇点的可行路径,那么从源点到汇点的网络流至少可以增加w(w为这条路径上的边的最小容量)。此时,将最大流增加w,这条路径称为增广路径,同时从源到汇沿着增广路径将经过的每条正向边(从源指向汇)的流量都减去w,并将每条边的反向边的流量加上w。这个操作就为增广操作
    不断的进行增广操作,直到无法从源到达汇停止。那么,此时得到最大流的流量。同时,可以得到在获得最大流的时候,每条边上的流量分布(只需要将原图中每条边的容量减去最后的残余网络中每条边对应的流量即可)

    反向边

    下面是所有最大流算法的精华部分:引入反向边
    为什么要有反向边呢?

    在这里插入图片描述

    我们第一次找到了1-2-3-4这条增广路,这条路上的delta值显然是1。于是我们修改后得到了下面这个流。(图中的数字是容量)

    在这里插入图片描述

    这时候(1,2)和(3,4)边上的流量都等于容量了,我们再也找不到其他的增广路了,当前的流量是1。

    但这个答案明显不是最大流,因为我们可以同时走1-2-4和1-3-4,这样可以得到流量为2的流。

    那么我们刚刚的算法问题在哪里呢?问题就在于我们没有给程序一个”后悔”的机会,应该有一个不走(2-3-4)而改走(2-4)的机制。那么如何解决这个问题呢?回溯搜索吗?那么我们的效率就上升到指数级了。

    而这个算法神奇的利用了一个叫做反向边的概念来解决这个问题。即每条边(I,j)都有一条反向边(j,i),反向边也同样有它的容量。

    我们直接来看它是如何解决的:

    在第一次找到增广路之后,在把路上每一段的容量减少delta的同时,也把每一段上的反方向的容量增加delta。即在Dec(c[x,y],delta)的同时,inc(c[y,x],delta)

    我们来看刚才的例子,在找到1-2-3-4这条增广路之后,把容量修改成如下

    在这里插入图片描述

    这时再找增广路的时候,就会找到1-3-2-4这条可增广量,即delta值为1的可增广路。将这条路增广之后,得到了最大流2。

    在这里插入图片描述

    那么,这么做为什么会是对的呢?我来通俗的解释一下吧。

    事实上,当我们第二次的增广路走3-2这条反向边的时候,就相当于把2-3这条正向边已经是用了的流量给”退”了回去,不走2-3这条路,而改走从2点出发的其他的路也就是2-4。(有人问如果这里没有2-4怎么办,这时假如没有2-4这条路的话,最终这条增广路也不会存在,因为他根本不能走到汇点)同时本来在3-4上的流量由1-3-4这条路来”接管”。而最终2-3这条路正向流量1,反向流量1,等于没有流量。

    这就是这个算法的精华部分,利用反向边,使程序有了一个后悔和改正的机会

    3. 算法介绍

    1. Fold-Fulkerson算法
      Fold-Fulkerson算法就是朴素的增广路径思想。
      求最大流的过程,就是不断找到一条从源到汇的路径,然后构造残余网络,再在残余网络的基础上寻找新的路径,使总流量增加,然后形成新的残余网络,在寻找新路径… 直到某个残余网络上找不到从源到汇的路径为止
      每用DFS执行一次找路径,增广的操作,都会使得最大流增加,假设最大流为C,那么时间复杂度可以达到 C*(m+n), m为边的数目,n为顶点的数目。

    2. Edmonds-Karp算法
      O(N * M^2)
      Edmonds-Karp算法是在Fold-Fulkerson思想上进行改进:
      每次寻找增广路径的时候,总是寻找一条从源到汇经过节点数目最少的路径,即最短路径。这是一种“最短增广路径” Shortest Augmenting Path(SAP)的算法。
      在实现的时候,每次利用BFS搜索,找到一条从源到汇的最短路径,然后进行增广操作;再进行BFS…直到无法找到从源到汇的路径为止。
      时间复杂度可以达到 nmm, n为顶点的数目,m为边的数目。

    3. dinic算法
      O(n^2 * m)
      Dinic算法最核心的内容就是多路增广!!!划重点
      沿着EK算法的过程:
      在这里插入图片描述
      我们有一个图,如图一。
      按照套路,我们先BFS,找S−T最短路。所有的距离标号都画在了图二上(EK算法可能用不到,但Dinic得到)。
      假设我们选的是S−3−T这条路,增广。。。(如图三,绿色)
      然后我们再来一遍BFS。。。 等等!
      细心的你可能也发现了,S−1−T也是一条S−T最短路。
      那就增广吧!(如图四)
      您可以检查一下,这时候没有长度为2的最短路了。
      但EK算法不会这样。它会再笨拙地从头再BFS一遍,这就浪费了不少时间。
      所以说,多路增广是很重要的。

    4. ISPA算法
      http://www.renfei.org/blog/isap.htm
      复杂度分析:https://www.cnblogs.com/owenyu/p/6852664.html
      ISAP算法为优化的最短增广路径算法(Improved Shortest Augmenting Path)。相比Dinic,ISAP算法不需要在回溯到源点之后再次进行BFS分层操作,而是在DFS以及回溯的过程中就进行了节点的重标号(即分层操作);以及ISAP算法进行gap优化大大提升效率。
      具体流程为:
      1----- 定义dist[v] 为点v到达汇点的距离(即经过几个点到达汇点),定义gap[d]在当前残余网络中到达汇点(经过路径上流量不能为0)距离为d的点的个数。
      2-----从汇点到源点进行反向BFS,标记下每个节点到达汇点的最短距离,即和Dinic算法相反的分层操作。
      3----- 当前点u从源点出发,用DFS找到一条到达汇点的路径…
      4----- 若点u为汇点,则找到了一条增广路径,进行增广操作;若点u可以向前走到v,且u–>v为一条可行边(dist[u] = dist[v]+1,且边u–>v流量不为0),则u走到v;若u无法向前推进到任何点,则对u进行重标号,然后回溯u到原来的增广路径中上一个点 pre[u].
      5------ 在重标号和回溯之前,可以进行gap优化。gap[d]在当前残余网络中到达汇点(经过路径上流量不能为0)距离为d的点的个数。 若从u无法找到一条可行边,则表明可以经过 dist[u] 条边到达汇点的点数目少了一个,即 gap[dist[u]] --。若此时 gap[dist[u]] = 0,则说明当前残余网络中,没有任何一个点可以经过dist[u]条边到达汇点,源点到汇点的距离肯定大于等于dist[u],若源点能够到达汇点,那么要求源点到汇点的路径中肯定有到达汇点距离为dist[u]的点,所以,无法从源点到达汇点此时,可以直接返回结果。

    5. 重标号,是将点u重新分层,重新设置点u经过不为0的边可达汇点的最短距离。具体是 dist[u] = min{dist[v]|u连接到v,且u–>v边流量不为0} + 1. 若从u出发的边流量均为0,则无法找到下一个点,则直接将dist[u]置为n(n为节点个数),这样就说明u点不可达。
      优化:
      1----- GAP优化:
      如果一次重标号时,出现距离断层即Gap[i] = 0,则可以证明ST无可行流,此时则可以直接退出算法。
      2----- 当前弧优化:
      为了使每次找增广路的时间变成均摊O(V),还有一个重要的优化是对于每个点保存“当前弧”:初始时当前弧是邻接表的第一条弧;在邻接表中查找时从当前弧开始查找,找到了一条允许弧,就把这条弧设为当前弧;改变距离标号时,把当前弧重新设为邻接表的第一条弧。

    小结:

    增广路算法核心都是一样的:寻找增广路径,更新路径上的流量(残余网络),直到找不到可行流。
    在寻找增广路径上,EK最笨拙,每次bfs只找一条增广路径,Dinic每次bfs分层后的dfs可能找到多条增广路径,因此在稠密图中dinic要远好于EK。ISPA除了刚开始的bfs分配距离标号外,其他操作都是dfs+重标号,交错进行,直到出现断层。

    代码:

    hdu1532
    EK:

    // 最大流  EK 
    #include <cstdio>
    #include <vector> 
    #include <queue>
    #include <cstring>
    #include <algorithm>
    #define fi first
    #define se second
    #define pii pair<int,int>
    using namespace std;
    typedef long long LL;
    const int INF = 0x3f3f3f3f;
    const int maxn = 200+5;
    int n;
    
    // 图 
    struct Edge{
    	int u, v, cap, flow;
    	Edge(int a, int b, int c, int d):u(a),v(b),cap(c),flow(d){}
    };
    vector<Edge> edges;
    vector<int> G[maxn];
    
    int asc[maxn];	// 从起点到i的可改进量
    int p[maxn]; 	// 最短路树上p的入弧编号
    
    void init(){
    	for(int i = 0; i < maxn; ++i) G[i].clear();
    	edges.clear();
    }
    
    void addEdge(int u, int v, int cap){
    	edges.push_back(Edge(u,v,cap,0));
    	edges.push_back(Edge(v,u,0,0));		// 反向弧
    	int m = edges.size();
    	G[u].push_back(m-2);
    	G[v].push_back(m-1); 
    }
    
    // 最大流 
    int MaxFlow(int s, int t){
    	int flow = 0;
    	while(1){
    		memset(asc, 0, sizeof(asc));
    		asc[s] = INF;
    		queue<int> Q;
    		Q.push(s);
    		while(!Q.empty()){
    			int x = Q.front(); Q.pop();
    			for(int i = 0; i < G[x].size(); ++i){ // 枚举 x-> 
    				Edge e = edges[G[x][i]];
    				if(0 == asc[e.v]&&e.cap > e.flow){
    					p[e.v] = G[x][i];
    					asc[e.v] = min(asc[x], e.cap-e.flow);
    					Q.push(e.v);
    				}
    			}
    			if(asc[t]) break;
    		}
    		if(0 == asc[t]) break; // 找不到增广路径了
    		// 找到一条增广路径,更新流量
    		for(int u = t; u != s; u = edges[p[u]].u) {
    			edges[p[u]].flow += asc[t];
    			edges[p[u]^1].flow -= asc[t];
    		}
    		flow += asc[t];
    	}
    	return flow;
    }
    
    int main()
    {
    	freopen("in.txt","r",stdin);
    	int n, m;
    	while(scanf("%d%d",&m,&n) == 2&&n){
    		init();
    		for(int i = 0; i < m; ++i){
    			int a,b,c; scanf("%d%d%d",&a,&b,&c);
    			addEdge(a-1,b-1,c);
    		}
    		int ans = MaxFlow(0, n-1);
    		printf("%d\n", ans);
    	}
    
    	return 0;
    }
    
    
    

    Dinic:

    // 最大流 dinic算法
    #include <cstdio>
    #include <vector> 
    #include <queue>
    #include <cstring>
    #include <algorithm>
    #define fi first
    #define se second
    #define pii pair<int,int>
    using namespace std;
    typedef long long LL;
    const int INF = 0x3f3f3f3f;
    const int maxn = 200+5;
    int n;
    
    // 图 
    struct Edge{
    	int u, v, cap, flow;
    	Edge(int a, int b, int c, int d):u(a),v(b),cap(c),flow(d){}
    };
    vector<Edge> edges;
    vector<int> G[maxn];
    
    int dis[maxn];	// 分层的编号 
    
    void init(){
    	for(int i = 0; i < maxn; ++i) G[i].clear();
    	edges.clear();
    }
    
    void addEdge(int u, int v, int cap){
    	edges.push_back(Edge(u,v,cap,0));
    	edges.push_back(Edge(v,u,0,0));		// 反向弧
    	int m = edges.size();
    	G[u].push_back(m-2);
    	G[v].push_back(m-1); 
    }
    
    // 分层 
    bool bfs(int s, int t){
    	memset(dis, -1, sizeof(dis));
    	dis[s] = 0;
    	queue<int> Q;
    	Q.push(s);
    	while(!Q.empty()){
    		int x = Q.front(); Q.pop();
    		for(int i = 0; i < G[x].size(); ++i){
    			Edge e = edges[G[x][i]];
    			if(dis[e.v] == -1&&e.cap > e.flow){
    				dis[e.v] = dis[x] + 1;
    				Q.push(e.v);
    			}
    		}
    	}
    	return dis[t] != -1;
    }
    
    int dfs(int s, int t, int cur_flow){
    	if(s == t||cur_flow == 0) return cur_flow;
    	int ans = 0;
    	for(int i = 0; i < G[s].size(); ++i){
    		int c = G[s][i];
    		Edge e = edges[c];
    		if(dis[e.v] == dis[s] + 1&&e.cap > e.flow){
    			int a2 = min(cur_flow, e.cap-e.flow);
    			int w = dfs(e.v, t, a2);
    			edges[c].flow += w;
    			edges[c^1].flow -= w; 
    			cur_flow -= w;
    			ans += w;
    			if(cur_flow <= 0) break;
    		}
    	}
    	return ans;
    }
    
    int Dinic(int s, int t){
    	int ans = 0;
    	while(bfs(s,t)){
    		ans += dfs(s,t,INF);
    	}
    	return ans;	
    }
    
    int main()
    {
    	freopen("in.txt","r",stdin);
    	int n, m;
    	while(scanf("%d%d",&m,&n) == 2&&n){
    		init();
    		for(int i = 0; i < m; ++i){
    			int a,b,c; scanf("%d%d%d",&a,&b,&c);
    			addEdge(a-1,b-1,c);
    		}
    		int ans = Dinic(0, n-1);
    		printf("%d\n", ans);
    	}
    
    	return 0;
    }
    
    

    ISPA:

    #include <cstdio>
    #include <vector>
    #include <queue>
    #include <cstring>
    #include <algorithm>
    #define fi first
    #define se second
    #define pii pair<int,int>
    using namespace std;
    typedef long long LL;
    const int INF = 0x3f3f3f3f; 
    const int maxn = 200+5;
    
    // 图
    struct Edge{
    	int u, v, cap, flow;
    	Edge(int a, int b, int c, int d):u(a),v(b),cap(c),flow(d){}
    }; 
    vector<Edge> edges;
    vector<int> G[maxn];
    
    int n, m;
    int dis[maxn];	// 分层,从汇点 -> 源点 
    int pre[maxn];  // 可增广路上的上一条弧的编号
    int Gap[maxn];	// 距离汇点最短距离为 i 的点有多少个 
    int cur[maxn]; // 当前弧下标. (优化)
    
    void init(){
    	for(int i = 0; i < maxn; ++i) G[i].clear();
    	edges.clear();
    }
    
    void addEdge(int u, int v, int cap){
    	edges.push_back(Edge(u,v,cap,0));
    	edges.push_back(Edge(v,u,0,0));		// 反向弧
    	int m = edges.size();
    	G[u].push_back(m-2);
    	G[v].push_back(m-1); 
    }
    
    // 从(汇点)t -> s(源点),反向bfs建立距离标号d , 并统计Gap[d] 
    void bfs(int s, int t){
    	memset(dis, -1, sizeof(dis));
    	memset(Gap, 0, sizeof(Gap));
    	dis[t] = 0; 
    	Gap[0] = 1;
    	queue<int> Q;
    	Q.push(t);
    	while(!Q.empty()){
    		int x = Q.front(); Q.pop();
    		for(int i = 0; i < G[x].size(); ++i){
    			Edge e = edges[G[x][i]^1];
    			if(dis[e.u] == -1){
    				
    				dis[e.u] = dis[x] + 1;
    				++Gap[dis[e.u]];
    				Q.push(e.u);
    			}
    		}
    	}
    }
    
    // 增广 
    int augument(int s, int t){
    	int min_flow = INF;
    	// 从汇点到源点通过 p 追踪增广路径, df 为一路上最小的残量
    	for(int u = t; u != s; u = edges[pre[u]].u){
    		Edge e = edges[pre[u]];
    		min_flow = min(min_flow, e.cap - e.flow);
    	}
    	// 从汇点到源点更新流量
    	for(int u = t; u != s; u = edges[pre[u]].u){
    		edges[pre[u]].flow += min_flow;
    		edges[pre[u]^1].flow -= min_flow;
    	}
    	return min_flow;
    }
    
    int ISPA(int s, int t){
    	bfs(s, t);
    	memset(cur, 0, sizeof(cur));
    	int u = s;
    	int ans = 0;
    	while(dis[s] < n){
    		if(u == t){
    			ans += augument(s, t);
    			u = s;
    		}
    		// 寻找可行弧,看是否可以前进 
    		bool advanced = false;
    		for(int i = cur[u]; i < G[u].size(); ++i){
    			Edge e = edges[G[u][i]];
    			if(dis[u] == dis[e.v] + 1&&e.cap > e.flow){
    				advanced = true;
    				pre[e.v] = G[u][i];
    				cur[u] = i;		// 记录节点u访问到哪一条弧了,下次接着访问
    				u = e.v;		// 前进到下一个点 
    				break;
    			}
    		}
    		// 节点u找不到可行弧,回退. 
    		if(!advanced){
    			// 改变 u 的距离标号为所有u->v中d[v]的最小值+1 
    			int d1 = n-1;
    			for(int i = 0; i < G[u].size(); ++i){
    				Edge e = edges[G[u][i]];
    				if(e.cap > e.flow)
    					d1 = min(d1, dis[e.v]);
    			} 
    			if(--Gap[dis[u]] == 0) break;  // 一旦发现某个距离值没有对应的点了,结束
    			dis[u] = d1 + 1;
    			++Gap[dis[u]];
    			cur[u] = 0;
    			if(u != s) u = edges[pre[u]].u; // 回退到弧尾 
    		}
    	}
    	return ans;
    }
    
    int main()
    {
    	freopen("in.txt","r",stdin);
    	while(scanf("%d%d",&m,&n) == 2&&n){
    		init();
    		for(int i = 0; i < m; ++i){
    			int a,b,c; scanf("%d%d%d",&a,&b,&c);
    			addEdge(a-1,b-1,c);
    		}
    		int ans = ISPA(0, n-1);
    		printf("%d\n", ans);
    	}
    	return 0;
    }
    
    

    参考: https://blog.csdn.net/x_y_q_/article/details/51999466
    https://www.cnblogs.com/qiucz/p/4601241.html,
    https://blog.csdn.net/vonmax007/article/details/64921089

    展开全文
  • 错了啊

    2019-09-18 23:24:33
    cp命令的(-V)选项可以在拷贝的时候看到拷贝的过程。 cp一个文件,如果目标已经存在,会问我们是否要覆盖,如何做可以不让它询问? 使用绝对路径/bin/cp ...ls -l的时候,第二列的数字表示什么含义...
  • Ethernet以太网作用

    2020-08-29 14:52:01
    由于单纯的电平信号"0"和"1"没有任何意义,在实际应用中,我们会将电平信号进行分组处理,多少位一组、每组什么意思,这样数据才有具体含义。数据链路层的功能就是定义电平信号的分组方式。 1:以太网协议: 数据链路...
  • DTV 学习(一) 基本概念、分类

    千次阅读 2010-09-16 17:28:00
    o(≧v≦)o什么是数字电视?  数字电视(Digital television, or DTV)含义并不是指我们一般人家中的电视机,而是采用数字信号广播图像和声音的新的电视系统,它从节目采编、压缩、传输到接收电视节目的全过程...
  • 在电源设计中,安全往往是第一位的,在开关电源中也是如此,接地能够保护使用者的人身安全,并且确保电力设备的正常运行,那么在开关电源中合适的接地方式是什么?常见的接地符号又有哪些呢?本文就将对开关电源当中的...
  • 4.1.5 用过哪些Map类,都有什么区别,HashMap是线程安全的吗,并发下使用的Map是什么,他们内部原理分别是什么,比如存储方式,hashcode,扩容,默认容量等。 4.1.6 JAVA8的ConcurrentHashMap为什么放弃了分段锁,有...
  • 物理层

    2020-01-09 15:17:02
    透明传输的含义:不关系比特流里携带的信息是什么,只关心比特流的正确搬运。 信号在信道上传输会发生衰减和变形。 奈奎斯特定理(理想信道):当物理带宽为BHz,信号离散等级为V级,该信道能提供的最大传输速率...
  • s7-300工程实战总结.pdf

    2009-07-24 18:50:49
    50. 在点到点通信中,协议 3964(R)和RK 512 之间的区别是什么? 13 51. 当一个DP从站出故障,如何在输入的过程映像被清成“0”以前保存它们? 13 52. 加密的300PLC MMC处理方法 13 53. 以314C为例计数时如何清计数器...
  • Dialogic从入门到系统工程师_完整版

    热门讨论 2010-04-27 10:20:27
    2.6.14 DTMF/MF/脉冲拨号是什么 33 2.6.15 Fax集成 35 2.7硬件原理类概念 36 2.7.1处理器 36 2.7.2语音卡与PC机的接口 36 2.7.3 语音卡与电话网的接口 37 2.7.4资源总线 37 2.7.5固件原理 37 2.8 CTI应用...
  • 2.6.14 DTMF/MF/脉冲拨号是什么 33 2.6.15 Fax集成 35 2.7硬件原理类概念 36 2.7.1处理器 36 2.7.2语音卡与PC机的接口 36 2.7.3 语音卡与电话网的接口 37 2.7.4资源总线 37 2.7.5固件原理 37 2.8 ...
  • Linux系统总复习.txt

    2015-06-04 19:39:59
    rwx对文件和目录不同的含义,缺省创建文件不能具有x权限 3)文件搜索命令 which 别名 whereis 帮助文档 find -name -iname -size -user -atime -ctime -mtime -type -inum -perm -exec(查询结果中直接执行) ...
  • 1.0.22 点扩散函数的含义是什么?.........................................................................10 B1.1 在连续空间中一个点源的正式定义.............................................................
  • when wh【=w什么,表疑问】,e【眼睛-睁开眼睛,表刚睡醒】,n【知道】 →一个刚睡醒的睁开眼睛的时候,就想知道:现在是什么时候、何时→当时、那时 then th【=t钉、站,指时间上的点】,e【眼睛-睁开眼睛,表刚...
  • 正则表达式到底是什么东西? 字符是计算机软件处理文字时最基本的单位,可能是字母,数字,标点符号,空格,换行符,汉字等等。字符串是0个或更多个字符的序列。文本也就是文字,字符串。说某个字符串匹配某个正则...
  • costas_loop代码

    2012-10-08 14:40:33
    掌握一个跟踪环路的本质重要的,光Costas环就有好多种,关键看你要应用在什么场合,实现复杂度有什么要求。 % 如果楼主想对costas环有点更深入的认识,建议考虑一下低SNR环境下或者高动态环境的载波跟踪这种例子...
  • 通过截获大量的数据包,我们判断第4个字节代表指令,也就是说客户端告诉服务器进行的是什么操作。例如向服务器请求战斗指令为"30",战斗中移动指令为"D4"等。 接下来,我们就需要分析一下上面第一个包"F4 44 1F ...
  • 5、将三用表拔至直流电压档,然后测量TP91,TP92,TP93,TP94,TP95的电压是否正常:TP91为-12V,TP92为-48V,TP93为+5V,TP94为+12V,TP95为-5V。(-48V允许误差±10%,其它为±5%) 6、将四个用户接上电话单机...
  • 入门学习Linux常用必会60个命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    它会使mount不执行实际挂上的动作,而是模拟整个挂上的过程,通常会和-v一起使用。 -t vfstype:显示被加载文件系统的类型。 -n:一般而言,mount挂上后会在/etc/mtab中写入一笔资料,在系统中没有可写入文件...
  • 下面的代码输出是什么,为什么? 1、sizeof()和strlen()的使用? 答: 1.从功能定义上,strlen函数,用来求字符串的长度,sizeof函数是用来求指定变量或变量类型等所占用内存的 大小; 2.sizeof是运算符,而strlen是C...
  • 12.在光(电磁波)的传播形态中,TEM波的含义是__在传播方向上没有电场和磁场分量__(横电磁波)______. 13.在薄膜波导中,可能产生的三种类型的波是导波、__衬底辐射模_和敷层辐射模. 14.对称薄膜波导中截止波长的...

空空如也

空空如也

1 2 3
收藏数 53
精华内容 21
关键字:

v什么数字含义是什么