必赢56net手机版_亚洲必赢手机入口_必赢亚州手机网站
做最好的网站

js寻路格局,用数学来拯救

如何清理烂账

提出建议的我们,当然得负起擦屁股的责任。《亲爱的卧底经济学家》作者蒂姆·哈佛(Tim Harford)设计了一套简单的赛局理论来解决这问题:

两人各自在掌心写下对这项物品的估价(如果是三国迷,拜托也不要在这个时候写“火”),赢的人买下物品,价格即是两人各自估价的平均。例如,你们会把《阅读数学》印出来,纸本上写满了注释跟计算公式,分手时你们都渴望保留这份纸本,你出价700元,对方开价500元,纸本归你所有,但你得付给对方(500 700)/2,也就是600元。

这方法的好处在于,就算你不想要这东西,但估价过低会影响到你的收益,因此不能低估。相反地,估价过高,就算标到也得付出不合理的价格。最终只能在手中写下心中认定的价码。而且,说不定在各自估价时,还发现“怎么那么有默契”,“他怎么把我穿过的衣服估那么高的价格,表示他还是舍不得我吗”,重新思考起两人关系,决定再给彼此一个机会。

要是双方都摆烂估很低,那也可以更确定分手是正确的。

刚刚那是一种一种慢慢来的分法,如果嫌麻烦想直接各分几种快快了事,还有个更简单的分法:

将所有要分的东西都拿出来,排成一条直线。接着,两个人在不知道对方怎么决定的前提下,选择各自认为公平的一刀两断之处。好比,有A、B、C、D、E、F、G物品。

你觉得从C切起,A、B、C一堆,D、E、F、G一堆这样一人拿一堆很公平。而对方则认为从E切起,A、B、C、D、E要一堆,F、G一堆这样才公平。

比对结果后,对方先拿F、G,因为对方认为这样分很公平,他不会有意见。

而你不是拿剩下的A、B、C、D、E,只能拿A、B、C,因为那样对你来说已经是公平的。剩下的D、E,这时就可以再用第一种分法。

再看另一种状况,你还是分A、B、C一堆,D、E、F、G一堆,但对方是分A、B一堆、C、D、E、F、G一堆。这时,对方拿A、B,你拿D、E、F、G,还是一样双方都会觉得很公平。剩下来的C再用第一种分法。

有这两种方法,就可以确保不管怎样,都能顺利分手完成。

现在,诸位情侣们可以开始一起制造属于你们的迷糊帐了。

必赢56net 1

因此,A的保留堆大小是:

撇开常扯淡的恋爱鸡汤,身为理工人,我们将从兼具理性、物质、悲观主义者的角度教导大家一招维系感情的好方法。

因此访问顺序是:A -> C -> B -> D -> F -> G -> E
下面以"有向图"为例,来对深度优先搜索进行演示。

因此,B的保留堆大小是30个字节。

那就是,借着购物,让两个人分不出彼此。

Paste_Image.png

保留堆

在讲数学之前,我们先来一则英文小知识:POSSLQ(Person of the Opposite Sex Sharing Living Quarters)。翻译成中文即是“同居对象”。同居之于结婚,好比暧昧之于交往。

第1步:访问A。
第2步:访问B。
第3步:依次访问C,E,F。
在访问了B之后,接下来访问B的出边的另一个顶点,即C,E,F。前面已经说过,在本文实现中,顶点ABCDEFG按照顺序存储的,因此会先访问C,再依次访问E,F。
第4步:依次访问D,G。
在访问完C,E,F之后,再依次访问它们的出边的另一个顶点。还是按照C,E,F的顺序访问,C的已经全部访问过了,那么就只剩下E,F;先访问E的邻接点D,再访问F的邻接点G。

必赢56net 2

做一笔烂账

好比一起逛厨具店,绝对不能说“那组情侣杯好好看,我要买……”

不说其中一个破掉,另一个杯子得从此守寡的窘境(遇到迷信一点的女朋友搞不好还因此开始怀疑这是否是甚么征兆)。分手时,两个杯子太没难度,你拿一个,我拿一个,就算在新交的对象面前用,也不会被察觉是对杯。

正确的方法应该是“这个Le Creuset的陶瓷炖锅好好看,买回去冬天我帮你炖洋葱汤好吗?”这样一来,总不成分手时一人拿盖子一人拿锅子吧。

去签书会也一样,就算两个人一起排队,也绝对只能签一本。比起各自珍藏一份,两个人在回家的路上打闹说“这本归我”、“归我”、“你的就是我的,我的还是我的”,只要不会不小心把书撕破,这不是更富有情趣吗?

具体到生活物品,更千万不要“电扇你买”、“吹风机用我的”分得清清楚楚,请务必一起去买一个新的,这次你出多一点,下次他出多一点,弄出一笔媲美政府预算般的烂账。如此一来,当日子久了,你们就会分不出彼此,成为共犯集团,不,是你侬我侬尽在不言中。

就算感情没进展,退一万步还有另一个好处:提升分手的技术性难度。要分手可以,先处理这一大堆不知道该怎么分配的物品吧。因为无法清楚切割(越讲越像贪腐案了),只好陷入“明天再想看看”的陷阱。然而说不定隔天就气消了,又能继续看似正常的交往、过日子。这些物品就像小孩子一样,扮演着感情缓冲阀的角色。

其实这不是甚么太了不起的道理,任何兼具理性、物质、悲观主义者的人都会想到。之所以这个好方法无法付诸实行的原因是,当感情不顺遂,分手信号灯在眼前闪起时,这堆烂账该如何处理,总要有一个了结,又不能把谁关了,把谁拖出去枪毙了事。

必赢56net 3比分手更痛苦的就是分财产了。图片来源:shutterstock

正所谓“清官难断家务事”,清官不一定指一个人,而是任何理性判断的泛称。当物品折旧、渗入了两人深浅不一的情感时,没有好好处理归属的问题,往往会引起纠纷,让好聚好散变成“想不到她/他原来这么小气”。

  1. 访问顶点v;
  2. 依次从v的未被访问的邻接点出发,对图进行深度优先遍历;直至图中和v有路径相通的顶点都被访问;
  3. 若此时图中尚有顶点未被访问,则从一个未被访问的顶点出发,重新进行深度优先遍历,直到图中所有顶点均被访问过为止。

A的总保留堆大小将变为40个字节。保留堆大小的所有其他对象将保持不受干扰,因为它们的引用没有变化。

然而,光有大量的相处时间是不够的,还需要各式各样的沟通与相处技巧,用心经营,才能增进感情。若不了解,只要去书店闭着眼睛随便抽一本,很容易就会抽到这种恋爱鸡汤书籍,就算没抽到,也没关系,反正随便抽到的应该都比起那种书更值得看。

必赢56net 4

必赢56net 5

同居好处多多,比方说,送对方回家时可以顺便送自己回家;不用连要聊天都得去咖啡厅、快餐厅或者7-11,视年龄以及经济状况而定;可以看清对方每一个细节;以及最重要,能增加相处的时间。非同居情侣一周见两次面,平均约10小时,同居情侣只要一天就超过了,媲美《七龙珠》的精神时光屋。

在线预览实例 ?[请点这里!!!][]
[请点这里!!!]:http://htmlpreview.github.io/?https://github.com/ferrinte/algorithm/blob/master/road.html

= 70个字节

此乃“男/女怕娶/嫁错娘/郎”、“快餐恋情”、“七日鉴赏期”三种新世代观念整合下出现的产物。

第2步:访问B。
在访问了A之后,接下来应该访问的是A的出边的另一个顶点,即顶点B。
第3步:访问C。
在访问了B之后,接下来应该访问的是B的出边的另一个顶点,即顶点C,E,F。在本文实现的图中,顶点ABCDEFG按照顺序存储,因此先访问C。
第4步:访问E。
接下来访问C的出边的另一个顶点,即顶点E。
第5步:访问D。
接下来访问E的出边的另一个顶点,即顶点B,D。顶点B已经被访问过,因此访问顶点D。
第6步:访问F。
接下应该回溯"访问A的出边的另一个顶点F"。
第7步:访问G。

= A的浅堆大小 B的浅堆大小 C的浅堆大小 D的浅堆大小 E的浅堆大小 F的浅堆大小 G的浅堆大小

关键词:寻路

= B的浅堆大小 D的浅堆大小 E的浅堆大小

第1步:访问A。
第2步:访问(A的邻接点)C。
在第1步访问A之后,接下来应该访问的是A的邻接点,即"C,D,F"中的一个。但在本文的实现中,顶点ABCDEFG是按照顺序存储,C在"D和F"的前面,因此,先访问C。
第3步:访问(C的邻接点)B。
在第2步访问C之后,接下来应该访问C的邻接点,即"B和D"中一个(A已经被访问过,就不算在内)。而由于B在D之前,先访问B。
第4步:访问(C的邻接点)D。
在第3步访问了C的邻接点B之后,B没有未被访问的邻接点;因此,返回到访问C的另一个邻接点D。
第5步:访问(A的邻接点)F。
前面已经访问了A,并且访问完了"A的邻接点B的所有邻接点(包括递归的邻接点在内)";因此,此时返回到访问A的另一个邻接点F。
必赢56net,第6步:访问(F的邻接点)G。
第7步:访问(G的邻接点)E。

保留A的堆大小

Paste_Image.png

对象B持有对象D和E的引用。

广度优先搜索(Breadth-First-Search):
一种图形搜索算法。简单的说,BFS是从根节点开始,沿着树(图)的宽度遍历树(图)的节点。如果所有节点均被访问,则算法中止。BFS同样属于盲目搜索。一般用队列数据结构来辅助实现BFS算法。
步骤:

通过示例学习新概念更容易。假设您的应用程序有一个对象模型,如图#1所示:

对上面的图G2进行深度优先遍历,从顶点A开始。

对象A持有对象B和C的引用,而对象B和C依次保持对对象D,E,F和G的引用。因此,如果对象A是从内存中收集的垃圾,则不再有对象的引用B,C,D,E,F和G.通过这种理解,让我们完成A的保留堆大小计算。

因此访问顺序是:A -> C -> D -> F -> B -> G -> E

= 10个字节 10个字节 10个字节

第1步:访问A。
第2步:依次访问C,D,F。
在访问了A之后,接下来访问A的邻接点。前面已经说过,在本文实现中,顶点ABCDEFG按照顺序存储的,C在"D和F"的前面,因此,先访问C。再访问完C之后,再依次访问D,F。
第3步:依次访问B,G。
在第2步访问完C,D,F之后,再依次访问它们的邻接点。首先访问C的邻接点B,再访问F的邻接点G。
第4步:访问E。
在第3步访问完B,G之后,再依次访问它们的邻接点。只有G有邻接点E,因此访问G的邻接点E。

Eclipse MAT(Memory Analyzer Tool)是一种分析堆转储的强大工具。当您尝试调试与内存相关的问题时,它非常方便。在Eclipse MAT中,报告了两种类型的对象大小:

Paste_Image.png

= 40个字节。

对上面的图G1进行深度优先遍历,从顶点A开始。

D的保留堆大小是10个字节,但是,这仅包括它们的浅大小。这是因为D不保存任何其他对象的任何活动引用。因此,如果D收集垃圾,则不会从内存中删除其他对象。根据相同的解释对象,E,F和G的保留堆大小也只有10个字节。

必赢56net 6

记住:对象的浅堆是它在内存中的大小。因为在我们的示例中,每个对象占用大约10个字节,所以每个对象的浅堆大小为10个字节。非常简单。

    <style type="text/css">
    *{ margin:0; padding:0;}
    li{ list-style:none;}
    #map{ 
        height:auto; 
        overflow:hidden; 
        margin:20px auto; 
        border:1px #ccc solid;     
        border-bottom:none; 
        border-right:none;
    }
    #map li{
        box-sizing: border-box;
        border:1px #ccc solid; 
        border-top:none; 
        border-left:none; 
        float:left;
    }
    #map li.sty1{ background:#e22841;}
    #map li.sty2{ background:orange;}
    #map li.sty3{ background:#00bcda;}
    #btn{ 
        width:160px; 
        height: 40px;
        color: #fff;
        text-align: center;
        line-height: 40px;
        font-size: 16px;
        background-color: #00bcda;
        border: none;
        border-radius: 5px;
        position:absolute; 
        left:0; 
        right: 0;
        margin: auto;
        cursor: pointer;
    }
    </style>

<body>
<ul id="map"></ul>
快去解救公主!
</body>

<script type="text/javascript">
var map = [
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,3,3,3,3,3,3,3,3,3,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,
    0,0,0,0,1,0,0,0,0,0,3,0,0,0,0,2,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,3,3,3,0,3,3,3,0,3,0,
    0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,3,3,0,3,3,3,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
];
var sizeGird = 24;  // 设定网格尺寸
var speed = 100;    // 设定移动速度

(function road(){
  var oUl = document.getElementById('map');
  var aLi = oUl.getElementsByTagName('li');
  var oBtn = document.getElementById('btn');
  var beginLi = oUl.getElementsByClassName('sty1');
  var endLi = oUl.getElementsByClassName('sty2');
  var cols = Math.sqrt(map.length);  
  var openArr = [];   // 存放可能要走的路线
  var closeArr = [];  // 存放不允许走的路线
  // 点击按钮初始化
  init();
  function init(){
    createMap();
    oBtn.onclick = function(){
        openFn();
    };
  }
  // 创建网格
  function createMap(){

    oUl.style.width = cols * (sizeGird)   'px';

    for(var i=0;i<map.length;i  ){
        var oLi = document.createElement('li');
        oLi.style.width = sizeGird   'px';
        oLi.style.height = sizeGird   'px';
        oUl.appendChild(oLi);

        if( map[i] == 1 ){
            oLi.className = 'sty1';
            openArr.push(oLi);
        }
        else if(map[i] == 2){
            oLi.className = 'sty2';
        }
        else if(map[i] == 3){
            oLi.className = 'sty3';
            closeArr.push(oLi);
        }
    }
  }

  function openFn(){
    var nowLi = openArr.shift();
    if( nowLi == endLi[0] ){
        showLine();
        return;
    }
    closeFn(nowLi);
    findLi(nowLi);
    //console.log( openArr );
    openArr.sort(function(li1,li2){
        return li1.num - li2.num;
    });
    //console.log( openArr );
    openFn();  // 递归操作,重复执行函数
  }
  // 过滤走过的路线
  function closeFn(nowLi){
    closeArr.push( nowLi );
  }
  // 找寻所有可能走的网格
  function findLi(nowLi){
    var result = [];
    for(var i=0;i<aLi.length;i  ){
        if( filter(aLi[i]) ){
            result.push( aLi[i] );
    }
    }

    function filter(li){
        for(var i=0;i<closeArr.length;i  ){
            if( closeArr[i] == li ){
                return false;
            }
        }
        for(var i=0;i<openArr.length;i  ){
            if( openArr[i] == li ){
                return false;
            }
        }
        return true;
    }
    // 找到当前网格周围的八个网格
    for(var i=0;i<result.length;i  ){
        if( (Math.abs(nowLi.offsetLeft - result[i].offsetLeft)<= sizeGird) && (Math.  abs(nowLi.offsetTop - result[i].offsetTop)<= sizeGird) ){
            result[i].num = f(result[i]);
            result[i].parent = nowLi;
            openArr.push( result[i] );
        }
    }
  }
  // 显示路线
  function showLine(){
    var result = [];
    var lastLi = closeArr.pop();
    var iNow = 0;
    findParent(lastLi);
    function findParent(li){
        result.unshift(li);
        if( li.parent == beginLi[0] ){
            return;
        }
        findParent(li.parent);
    }

    var timer = setInterval(function(){
        result[iNow].style.background = '#e22841';
        iNow  ;
        if(iNow == result.length){
            clearInterval(timer);
        }
    },speed);
  }
  // 估价函数
  function f(nodeLi){
    return g(nodeLi)   h(nodeLi);
  }
  function g(nodeLi){
    var a = beginLi[0].offsetLeft - nodeLi.offsetLeft;
    var b = beginLi[0].offsetTop - nodeLi.offsetTop;
    return Math.sqrt(a*a   b*b);  // 利用了勾股定理
  }
  function h(nodeLi){
    var a = endLi[0].offsetLeft - nodeLi.offsetLeft;
    var b = endLi[0].offsetTop - nodeLi.offsetTop;
    return Math.sqrt(a*a   b*b);
  } 
})(map,sizeGird,speed)

图3:对象B的新引用

下面以"有向图"为例,来对广度优先搜索进行演示。还是以上面的图G2为例进行说明。

然后我们可以得出结论,A的保留堆大小是70个字节。

Paste_Image.png

因此,C的保留堆大小也是30个字节。

必赢56net 7

图1:内存中的对象


对象C持有对象F和G的引用。

Paste_Image.png

对象C持有对象F和G的引用。因此,如果对象C是从内存中收集的垃圾,则不再有对象F和G的引用。这意味着F和G也可以被垃圾收集。但是,C的保留堆大小是:

因此访问顺序是:A -> B -> C -> E -> D -> F -> G

保留C的堆大小


对象A持有对象B和C的引用。

Paste_Image.png

另外本人从事在线教育多年,将自己的资料整合建了一个公众号,对于有兴趣一起交流学习java可以微信搜索:“程序员文明”,里面有大神会给予解答,也会有许多的资源可以供大家学习分享,欢迎大家前来一起学习进步!

参考链接http://blog.csdn.net/yapian8/article/details/37809023

从图#1中,您可以注意到对象B持有对象D和E的引用。因此,如果对象B是从内存中收集的垃圾,则对象D和E将不再有活动引用。这意味着D和E可以也是垃圾收集。保留堆是特定对象被垃圾回收时将释放的内存量。因此,B的保留堆大小是:

  1. 首先将根节点放入队列中。
  2. 从队列中取出第一个节点,并检验它是否为目标。
    如果找到目标,则结束搜寻并回传结果。
    否则将它所有尚未检验过的直接子节点加入队列中。
  3. 若队列为空,表示整张图都检查过了——亦即图中没有欲搜寻的目标。结束搜寻并回传“找不到目标”。
  4. 重复步骤2。

保留堆D,E,F和G的大小

必赢56net 8

因此,A的保留堆大小是:

下面以"无向图"为例,来对广度优先搜索进行演示。还是以上面的图G1为例进行说明。

= A的浅堆大小 C的浅堆大小 F的浅堆大小 G的浅堆大小

Paste_Image.png

= 10字节 10字节 10字节 10字节 10字节 10字节 10字节

必赢56net 9

= 10个字节 10个字节 10个字节

因此访问顺序是:A -> B -> C -> E -> F -> D -> G
启发式搜索(Heuristically Search):
又称为有信息搜索(Informed Search),它是利用问题拥有的启发信息来引导搜索,达到减少搜索范围、降低问题复杂度的目的,这种利用启发信息的搜索过程称为启发式搜索。
就是在状态空间中的搜索对每一个搜索的位置进行评估,得到最好的位置,再从这个位置进行搜索直到目标。
这样可以省略大量无谓的搜索路径,提高了效率。在启发式搜索中,对位置的估价(估价函数)是十分重要的
利用启发式搜索自动寻路实例

保留B的堆大小

必赢56net 10

浅堆大小

** 1.深度优先搜索(Depth-First-Search):**
沿着树的深度遍历树的节点,尽可能深的搜索树的分支。当节点v的所有边都己被探寻过,搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点,则选择其中一个作为源节点并重复以上过程,整个进程反复进行直到所有节点都被访问为止。DFS属于盲目搜索。
利用深度优先搜索算法可以产生目标图的相应拓扑排序表,利用拓扑排序表可以方便的解决很多相关的图论问题,如最大路径问题等等。一般用堆数据结构来辅助实现DFS算法。
步骤

让我们的研究更有趣

浅堆

必赢56net 11

现在,让我们的研究更有趣一点,这样您就可以深入了解浅堆和保留的堆大小。让对象H开始在示例中保持对B的引用。注意对象B已被对象A引用。现在,两个人A和H持有对对象B的引用。在这种情况下,让我们研究一下我们保留的堆计算会发生什么。

= 30个字节

= C的浅堆大小 F的浅堆大小 G的浅堆大小

= 30个字节

= 10个字节 10个字节 10个字节 10个字节

假设每个对象占用10个字节的内存。现在,有了这个背景,让我们开始我们的研究。

图2:对象浅和保留的堆大小

如果对象A被垃圾收集,那么将不再有对象C,F和G的引用。因此,只有对象C,F和G将被垃圾收集。另一方面,对象B,D和E将继续存在于存储器中,因为H持有对B的有效引用。因此,即使A被垃圾收集,也不会从存储器中移除B,D和E.

希望本文有助于澄清Eclipse MAT中的Shallow堆大小和保留堆大小计算。您还可以考虑探索HeapHero - 另一个功能强大的堆转储分析工具,它显示由于低效的编程实践(例如对象重复,数据结构的过度分配和利用不足,次优数据类型定义等)而浪费的内存量。

在本文中,让我们研究它们之间的区别并探索它们的计算方法

在这种情况下,对象A的保留堆大小将减少到40个字节。奇怪?百思不得其解?

本文由必赢56net手机版发布于必赢56net,转载请注明出处:js寻路格局,用数学来拯救

Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。