女人火把过桥：基于状态空间的带权图搜索算法（修改后详细分析版）

最新推荐文章于 2022-05-04 22:28:47 发布

weixin_34248705

最新推荐文章于 2022-05-04 22:28:47 发布

阅读量128

点赞数

文章标签：数据结构与算法 javascript ViewUI

郁闷，本来写了详细的分析文章，结果数据太多，浏览器死了，该死的 IE ，该死的 javascript ，郁闷死了！
首先将问题简单抽象一下：abcd 代表四个人，R 或 L 代表火把位置， - 代表桥

最终结果：2条最短路径，30个状态节点，节点两两之间有112条通路，5层搜索树的情况下可以找到 37 条路线。

基本思想：先找状态节点，再找两两之间通路。然后将起始节点作为 root ，查找邻居一层一层生成树，最后对树搜索，只要搜索范围够大，就可以找到所有的最优路线和一部分可能路线。

能不能找多全部可能路线呢？理论上可以，实际上无法完成。为什么后面讲

另外，这种方法具有通用性，可以查找任意两个节点之间的路线。

1、什么是状态

abcd 四个人，外加一只火把，这五个元素在桥两边的一种可能分布就是一个状态，比如 [abcd - ]L

但 [abcd - ]R 就不是正确的状态，因为右边没人，火把却在右边，不符合实际情况。

2、如何生成状态

首先生成 abcd 的所有子集：['', 'a', 'b', 'c', 'd', 'ab', 'ac', 'ad', 'bc', 'bd', 'cd', 'abc', 'abd', 'acd', 'bcd', 'abcd']

再将这些自己中的所有元素两两组合，如果能组成 abcd ,那么就将这两个元素分别放在桥的两边，再考虑火把在左和在右，这就得到了两个状态。

什么？怎么生成子集？就是循环套循环啊。

这项工作并不消耗多少资源，编程也不复杂，很快就能得到 30 个状态节点

3、查找两两状态之间的通路

如果一个状态能通过一次改变到达另一种状态，那么这两个状态之间就存在一条通路。比如：

[ bc - ad]L bc --->过河 [ - abcd]R time: 5

这就是一条通路

怎么知道两个状态之间有没有通路呢？描述起来有点罗嗦，就不说了。

这项工作消耗资源也不多，编程也不复杂，就是考虑到各种情况

经过一翻运行、检查、修改，程序很快找到了所有 112 条通路。

4、有了通路就可以就可以找到每个状态节点的所有邻居。两节点间存在通路，他们就是邻居，比如起始状态：

[abcd - ] L id:30 neighbor:[11,13,15,17,19,21,23,25,27,29]

他就有 10 个邻居，那些数字是邻居的 id 号

5、直到现在，我们终于生成了整个状态空间：即 所有的状态节点和每个节点的邻接节点。

这其实就组成了一副复杂的、像鱼网一样的路线图。如果你有兴趣，您可以按照我给的节点和通路在纸上画画，很快就成一团乱麻了。

要想在这幅图里面搜索并不容易，因为可能的路线里面允许存在“环”，而且还环里面套环

如果你现在直接使用深度优先搜索，基本上找不到最优路线，甚至有时候找不到路线

6、生成树

我们要把环拆开，就要生成树，将起始节点作为树的根 root ，将他的所有邻居作为他的 child ，然后再为他 child 的加入 child ，循环下去。

注意，添加 child 的时候，如果这个 child 在他的父辈中已经出现过，就放弃他，否则会出现死循环。

比如：A 的孩子是 B，虽然 A 也是 B 的邻居，但因为已经是他的父辈了，你不能再把 A 作为 B的孩子

这样我们就能生成一颗状态树。

7、真的能生成完整的树吗？

理论上可以，实际上无法完成。为什么呢？

考虑一下，从 1 出发，到达 30 ，任意两点间都存在通路，一共有多少条路线呢？

第一层（步）：有 29 走法（去掉 1）

第二层（步）：从第一层任一节点出发向下，有 28 种走法（去掉 1 和当前出发的节点），这样，第二层总计有 29*28 个节点

而到达第二层的全部走法是：29 * （29*28）

怎么样，这才两层已经很惊人了吧，要生成完整的树，肯定是天文数字，有生之年是找不到这样的机器了。

而我们的问题就是 30 个节点，只是并不是两两之间都存在通路，这样，树的深度可能可能达不到 30。

我用程序运行了十分钟，探索到的最深距离暂时是18 层，同样是天文数字。

除非我们能通过别的方法，先排除一些节点，或者设定条件，限制树的生长。

8、限制树的生长

好在我们并不需要找到所有路径，在这个问题中，只需要 5 层就能找到正确答案，所以，每当要加如的新节点超过第五层，就放弃他。

9、搜索树

有了这样一颗包含着正确路线的树，要找到所有路线和最优路线，那就是很简单的问题了，我使用了深度优先搜索，很快找到了37 条路线。

后面是一些数据，不感兴趣可以跳过。

最短路径
[abcd -     ]L    ab --->过河   [ cd -   ab]R time: 2
[ cd -   ab]R     b <---返回   [ bcd -    a]L time: 2
[ bcd -    a]L    cd --->过河   [   b - acd]R time: 10
[   b - acd]R     a <---返回   [ ab -   cd]L time: 1
[ ab -   cd]L    ab --->过河   [     - abcd]R time: 2
合计：17

[abcd -     ]L    ab --->过河   [ cd -   ab]R time: 2
[ cd -   ab]R     a <---返回   [ acd -    b]L time: 1
[ acd -    b]L    cd --->过河   [   a - bcd]R time: 10
[   a - bcd]R     b <---返回   [ ab -   cd]L time: 2
[ ab -   cd]L    ab --->过河   [     - abcd]R time: 2
合计：17

部分其他路径，太多就不全列出

[abcd -     ]L    ab --->过河   [ cd -   ab]R time: 2
[ cd -   ab]R     a <---返回   [ acd -    b]L time: 1
[ acd -    b]L    ad --->过河   [   c - abd]R time: 10
[   c - abd]R     a <---返回   [ ac -   bd]L time: 1
[ ac -   bd]L    ac --->过河   [     - abcd]R time: 5
合计：19

[abcd -     ]L    ab --->过河   [ cd -   ab]R time: 2
[ cd -   ab]R     b <---返回   [ bcd -    a]L time: 2
[ bcd -    a]L    bc --->过河   [   d - abc]R time: 5
[   d - abc]R     c <---返回   [ cd -   ab]L time: 5
[ cd -   ab]L    cd --->过河   [     - abcd]R time: 10
合计：24

30 个状态节点，neighbor 是他的邻居，可以改变过去
[     - abcd] R id: 1 neighbor:[2,4,6,8,10,12,14,16,18,20]
[   a - bcd] L id: 2 neighbor:[1]
[   a - bcd] R id: 3 neighbor:[10,12,14,22,24,26]
[   b - acd] L id: 4 neighbor:[1]
[   b - acd] R id: 5 neighbor:[10,16,18,22,24,28]
[   c - abd] L id: 6 neighbor:[1]
[   c - abd] R id: 7 neighbor:[12,16,20,22,26,28]
[   d - abc] L id: 8 neighbor:[1]
[   d - abc] R id: 9 neighbor:[14,18,20,24,26,28]
[ ab -   cd] L id:10 neighbor:[1,3,5]
[ ab -   cd] R id:11 neighbor:[22,24,30]
[ ac -   bd] L id:12 neighbor:[1,3,7]
[ ac -   bd] R id:13 neighbor:[22,26,30]
[ ad -   bc] L id:14 neighbor:[1,3,9]
[ ad -   bc] R id:15 neighbor:[24,26,30]
[ bc -   ad] L id:16 neighbor:[1,5,7]
[ bc -   ad] R id:17 neighbor:[22,28,30]
[ bd -   ac] L id:18 neighbor:[1,5,9]
[ bd -   ac] R id:19 neighbor:[24,28,30]
[ cd -   ab] L id:20 neighbor:[1,7,9]
[ cd -   ab] R id:21 neighbor:[26,28,30]
[ abc -    d] L id:22 neighbor:[3,5,7,11,13,17]
[ abc -    d] R id:23 neighbor:[30]
[ abd -    c] L id:24 neighbor:[3,5,9,11,15,19]
[ abd -    c] R id:25 neighbor:[30]
[ acd -    b] L id:26 neighbor:[3,7,9,13,15,21]
[ acd -    b] R id:27 neighbor:[30]
[ bcd -    a] L id:28 neighbor:[5,7,9,17,19,21]
[ bcd -    a] R id:29 neighbor:[30]
[abcd -     ] L id:30 neighbor:[11,13,15,17,19,21,23,25,27,29]
节点数：30

两两之间112条通路
[   a - bcd]L     a --->过河   [     - abcd]R time: 1
[   b - acd]L     b --->过河   [     - abcd]R time: 2
[   c - abd]L     c --->过河   [     - abcd]R time: 5
[   d - abc]L     d --->过河   [     - abcd]R time: 10
[ ab -   cd]L    ab --->过河   [     - abcd]R time: 2
[ ab -   cd]L     b --->过河   [   a - bcd]R time: 2
[ ab -   cd]L     a --->过河   [   b - acd]R time: 1
[ ac -   bd]L    ac --->过河   [     - abcd]R time: 5
[ ac -   bd]L     c --->过河   [   a - bcd]R time: 5
[ ac -   bd]L     a --->过河   [   c - abd]R time: 1
[ ad -   bc]L    ad --->过河   [     - abcd]R time: 10
[ ad -   bc]L     d --->过河   [   a - bcd]R time: 10
[ ad -   bc]L     a --->过河   [   d - abc]R time: 1
[ bc -   ad]L    bc --->过河   [     - abcd]R time: 5
[ bc -   ad]L     c --->过河   [   b - acd]R time: 5
[ bc -   ad]L     b --->过河   [   c - abd]R time: 2
[ bd -   ac]L    bd --->过河   [     - abcd]R time: 10
[ bd -   ac]L     d --->过河   [   b - acd]R time: 10
[ bd -   ac]L     b --->过河   [   d - abc]R time: 2
[ cd -   ab]L    cd --->过河   [     - abcd]R time: 10
[ cd -   ab]L     d --->过河   [   c - abd]R time: 10
[ cd -   ab]L     c --->过河   [   d - abc]R time: 5
[ abc -    d]L    bc --->过河   [   a - bcd]R time: 5
[ abc -    d]L    ac --->过河   [   b - acd]R time: 5
[ abc -    d]L    ab --->过河   [   c - abd]R time: 2
[ abc -    d]L     c --->过河   [ ab -   cd]R time: 5
[ abc -    d]L     b --->过河   [ ac -   bd]R time: 2
[ abc -    d]L     a --->过河   [ bc -   ad]R time: 1
[ abd -    c]L    bd --->过河   [   a - bcd]R time: 10
[ abd -    c]L    ad --->过河   [   b - acd]R time: 10
[ abd -    c]L    ab --->过河   [   d - abc]R time: 2
[ abd -    c]L     d --->过河   [ ab -   cd]R time: 10
[ abd -    c]L     b --->过河   [ ad -   bc]R time: 2
[ abd -    c]L     a --->过河   [ bd -   ac]R time: 1
[ acd -    b]L    cd --->过河   [   a - bcd]R time: 10
[ acd -    b]L    ad --->过河   [   c - abd]R time: 10
[ acd -    b]L    ac --->过河   [   d - abc]R time: 5
[ acd -    b]L     d --->过河   [ ac -   bd]R time: 10
[ acd -    b]L     c --->过河   [ ad -   bc]R time: 5
[ acd -    b]L     a --->过河   [ cd -   ab]R time: 1
[ bcd -    a]L    cd --->过河   [   b - acd]R time: 10
[ bcd -    a]L    bd --->过河   [   c - abd]R time: 10
[ bcd -    a]L    bc --->过河   [   d - abc]R time: 5
[ bcd -    a]L     d --->过河   [ bc -   ad]R time: 10
[ bcd -    a]L     c --->过河   [ bd -   ac]R time: 5
[ bcd -    a]L     b --->过河   [ cd -   ab]R time: 2
[abcd -     ]L    cd --->过河   [ ab -   cd]R time: 10
[abcd -     ]L    bd --->过河   [ ac -   bd]R time: 10
[abcd -     ]L    bc --->过河   [ ad -   bc]R time: 5
[abcd -     ]L    ad --->过河   [ bc -   ad]R time: 10
[abcd -     ]L    ac --->过河   [ bd -   ac]R time: 5
[abcd -     ]L    ab --->过河   [ cd -   ab]R time: 2
[abcd -     ]L     d --->过河   [ abc -    d]R time: 10
[abcd -     ]L     c --->过河   [ abd -    c]R time: 5
[abcd -     ]L     b --->过河   [ acd -    b]R time: 2
[abcd -     ]L     a --->过河   [ bcd -    a]R time: 1
[     - abcd]R     a <---返回   [   a - bcd]L time: 1
[     - abcd]R     b <---返回   [   b - acd]L time: 2
[     - abcd]R     c <---返回   [   c - abd]L time: 5
[     - abcd]R     d <---返回   [   d - abc]L time: 10
[     - abcd]R    ab <---返回   [ ab -   cd]L time: 2
[     - abcd]R    ac <---返回   [ ac -   bd]L time: 5
[     - abcd]R    ad <---返回   [ ad -   bc]L time: 10
[     - abcd]R    bc <---返回   [ bc -   ad]L time: 5
[     - abcd]R    bd <---返回   [ bd -   ac]L time: 10
[     - abcd]R    cd <---返回   [ cd -   ab]L time: 10
[   a - bcd]R     b <---返回   [ ab -   cd]L time: 2
[   a - bcd]R     c <---返回   [ ac -   bd]L time: 5
[   a - bcd]R     d <---返回   [ ad -   bc]L time: 10
[   a - bcd]R    bc <---返回   [ abc -    d]L time: 5
[   a - bcd]R    bd <---返回   [ abd -    c]L time: 10
[   a - bcd]R    cd <---返回   [ acd -    b]L time: 10
[   b - acd]R     a <---返回   [ ab -   cd]L time: 1
[   b - acd]R     c <---返回   [ bc -   ad]L time: 5
[   b - acd]R     d <---返回   [ bd -   ac]L time: 10
[   b - acd]R    ac <---返回   [ abc -    d]L time: 5
[   b - acd]R    ad <---返回   [ abd -    c]L time: 10
[   b - acd]R    cd <---返回   [ bcd -    a]L time: 10
[   c - abd]R     a <---返回   [ ac -   bd]L time: 1
[   c - abd]R     b <---返回   [ bc -   ad]L time: 2
[   c - abd]R     d <---返回   [ cd -   ab]L time: 10
[   c - abd]R    ab <---返回   [ abc -    d]L time: 2
[   c - abd]R    ad <---返回   [ acd -    b]L time: 10
[   c - abd]R    bd <---返回   [ bcd -    a]L time: 10
[   d - abc]R     a <---返回   [ ad -   bc]L time: 1
[   d - abc]R     b <---返回   [ bd -   ac]L time: 2
[   d - abc]R     c <---返回   [ cd -   ab]L time: 5
[   d - abc]R    ab <---返回   [ abd -    c]L time: 2
[   d - abc]R    ac <---返回   [ acd -    b]L time: 5
[   d - abc]R    bc <---返回   [ bcd -    a]L time: 5
[ ab -   cd]R     c <---返回   [ abc -    d]L time: 5
[ ab -   cd]R     d <---返回   [ abd -    c]L time: 10
[ ab -   cd]R    cd <---返回   [abcd -     ]L time: 10
[ ac -   bd]R     b <---返回   [ abc -    d]L time: 2
[ ac -   bd]R     d <---返回   [ acd -    b]L time: 10
[ ac -   bd]R    bd <---返回   [abcd -     ]L time: 10
[ ad -   bc]R     b <---返回   [ abd -    c]L time: 2
[ ad -   bc]R     c <---返回   [ acd -    b]L time: 5
[ ad -   bc]R    bc <---返回   [abcd -     ]L time: 5
[ bc -   ad]R     a <---返回   [ abc -    d]L time: 1
[ bc -   ad]R     d <---返回   [ bcd -    a]L time: 10
[ bc -   ad]R    ad <---返回   [abcd -     ]L time: 10
[ bd -   ac]R     a <---返回   [ abd -    c]L time: 1
[ bd -   ac]R     c <---返回   [ bcd -    a]L time: 5
[ bd -   ac]R    ac <---返回   [abcd -     ]L time: 5
[ cd -   ab]R     a <---返回   [ acd -    b]L time: 1
[ cd -   ab]R     b <---返回   [ bcd -    a]L time: 2
[ cd -   ab]R    ab <---返回   [abcd -     ]L time: 2
[ abc -    d]R     d <---返回   [abcd -     ]L time: 10
[ abd -    c]R     c <---返回   [abcd -     ]L time: 5
[ acd -    b]R     b <---返回   [abcd -     ]L time: 2
[ bcd -    a]R     a <---返回   [abcd -     ]L time: 1

深度为 5 的状态树，这里面总共有37条路，深度越大找到的路越多，但是生成的树就太大了
有了这棵树，手工也能很快找到一条路线