【数学模型】商人们怎样过河？

发表于 | 分类于 | 0 comments | 阅读次数

这篇博文中，同样是一个很简单的数学问题，但是解决起来比上一个的问题要复杂一些。在这次模型求解中，我会使用两种方法，一种是纯粹的数学方法，另一种是通过计算机程序来计算，通过计算机求解我们可以求解一些规模更大的问题。由于这篇文章篇幅我预计会比较长，为了不混淆，上一篇文章《椅子能在不平的地面上放平吗？》中的延伸问题我会再写一篇文章单独解答。

#问题引出

问题： 三名商人各带一个随从过河，一只小船只能容纳两个人，随从们约定，只要在河的任何一岸，一旦随从人数多于商人人数就杀人越货，但是商人们知道了他们的约定，并且如何过河的大权掌握在商人们手中，商人们该采取怎样的策略才能安全过河呢？

这次的问题是一个很经常遇到的过河问题，其实对于该类问题，我们经过逻辑思考就可以得到答案。但是通过数学模型的建立，我们可以得到一个通用的解答，并且通过计算机的计算我们可以大大扩大问题的规模。

#问题分析

因为这个问题已经理想化了，所以我们无需对模型进行假设，该问题可以看作一个多步决策问题。

每一步，船由此岸划到彼岸或者由彼岸划回此岸，都要对船上的人员进行决策（此次渡河船上可以有几名商人和几名随从），在保证安全（两岸的随从都不比商人多）的前提下，在有限次的决策中使得所有人都到对岸去。

因此，我们要做的就是要确定每一步的决策，达到渡河的目标。

#建立模型

记第 k 次过河前此岸的商人数为 xk , 随从数为 yk , k = 1, 2, 3…, xk ,yk = 0, 1, 2, 3

定义状态： 将二维向量 sk = ( xk , yk ) 定义为状态

将安全渡河状态下的状态集合定义为允许状态集合， 记为

S = {(x,y) | x=0,y=0,1,2,3; x=y=1; x=y=2; x=3,y=0,1,2,3}

记第 k 次渡河船上的商人数为 uk ， 随从数为 vk

定义决策： 将二维向量 dk = (uk , vk) 定义为决策

允许决策集合 记作

D = {(u,v) | 1 ≤ u+v ≤ 2, u,v = 0,1,2}

因为小船容量为2，所以船上人员不能超过2，而且至少要有一个人划船，由此得到上式。

由我们定义的状态 sk 和决策 dk ，我们可以发现它们之间是存在联系的：

  • k 为奇数是表示船由此岸划向彼岸，k 为偶数时表示船由彼岸划回此岸

  • 状态 sk 是随着决策 dk 变化的，规律为：

sk+1 = sk + (-1)kdk

我们把上式称为状态转移律，因此渡河方案可以抽象为如下的多步决策模型：

求决策 dk ∈ D(k = 1,2,…,n) , 使状态 sk ∈ S 按照转移率，初始状态 s1 = (3,3) 经有限步 n 到达状态 sn+1 = (0,0)

到这里，整个数学模型就已经非常清晰了，接下来要做的就是求解模型得出结果。

#求解模型

在这个模型的求解中，我将会使用两种方法，一种是数学图解法，用于解决和当前题目一样的规模比较小的问题，优点是比较简便，但是对于规模比较大的问题就无能为力了，比如说有50个商人携带50个随从过河，第二种方法是通过计算机编程，使用程序来解决该问题，即使问题规模增大，我们也可以利用计算机强大的计算能力来解决。

数学图解法

我们首先在 xOy 平面坐标系中画出如下方格，方格中的点表示状态 s = (x,y)

image

起始状态（下图绿色点） s1 = (3,3) , 终止状态（下图红色点） sn+1 = (0,0)

image

允许决策 dk 表示的是在方格中的移动，根据允许决策 dk 的定义，它每次的移动范围为1~2格，并且 k 为奇数时向左或下方或左下方移动，k 位偶数时向右或上方或右上方移动。

于是，这个问题就变成了，根据允许决策 dk ，在方格中在状态（方格点）之间移动，找到一条路径，使得能从起始状态（上图绿色点） s1 = (3,3) ,到达终止状态（上图图红色点） sn+1 = (0,0)

在下图中，我们给出了一种方案，我们可以很清楚的看到该方案绝对不是最佳方案（渡河次数最少），它只是给出了一种方案，而且我们看来是一种极其不优化的方案，但是可以很清楚地看出图解法是如何工作的。

image

根据上图，我们得出的方案如下：

  • d1：两个随从划到对岸
  • d2：一个随从划回来
  • d3：两个随从划到对岸
  • d4：一个随从划回来
  • d5：两个商人划到对岸
  • d6：一个商人和一个随从划回来
  • d7：两个商人划到对岸
  • d8：一个随从划回来
  • d9：两个随从划到对岸
  • d10：一个商人划回来
  • d11：一个商人和随从划到对岸

最终商人们安全渡河

##程序求解

我们看到上面介绍的图解法对于小规模问题很直观也很简单，但是无法应对大规模的问题，于是我们采用编程的方法来再次解决上述问题，这次我使用的编程语言为Python.

###创建允许状态集合

对于允许状态集合，我们要去使用算法对其进行计算，所谓允许状态无非就是，河岸两边的商人们都是安全的：

  • 一种情况是：两岸的商人人数都比随从人数多（对于随从和商人人数相同的情况就是河的任一岸，商人人数等于随从人数）
  • 另一情况为：所有商人都在河的任何一岸，此时另一岸没有任何商人，对于随从的人数在河的任一岸的数量不论是多少，此时都是安全的

按照以上方法编程如下：

1
2
3
4
5
6
7
8
9
10
11
12
'''创建允许状态集合'''    
def allowset(self):
    allowset = []
    for i in range(self.merchants + 1):
        for j in range(self.servants + 1):
            if i == 0:
                allowset.append([i,j])
            elif i == self.merchants:
                allowset.append([i,j])
            elif (i >= j and ((self.merchants-i) >= (self.servants-j))):
                allowset.append([i,j])
    return allowset

###创建允许决策集合

对于创建允许决策集合，它和船的容量是相关的，只要每次渡河的商人数量和随从数量小于等于船的容量即可，代码如下：

1
2
3
4
5
6
7
8
'''创建允许决策集合'''
def allowaction(self):
    allowactionset = []
    for i in range(self.capacity + 1):
        for j in range(self.capacity + 1):
            if (i+j) <= self.capacity and (i + j) != 0:
                allowactionset.append([i,j])
    return allowactionset

###如何渡河

对于如何渡河问题我采取的是一种随机的方法，对于当前安全状态，随机选择一种决策进行试探，如果采取该决策可以到达安全状态，则采用，如此循环，直到到达目的地。如果采取该策略不能到达安全状态，则再次随机选择一种策略。

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
def solve(self,allowactionset,allowstate):
    count = 1;
    current = (self.merchants,self.servants)
    while current != [0,0]:
        move = allowactionset[random.randint(0,len(allowactionset)-1)]
        temp = [current[0]+((-1)**count)*move[0],current[1]+((-1)**count)*move[1]]
        if(temp in allowstate):
            current = [current[0]+((-1)**count)*move[0],current[1]+((-1)**count)*move[1]]
            if(count % 2 == 1):
                print "[%d]个商人，[%d] 个随从从此岸划到对岸" %(move[0],move[1])
            elif(count % 2 == 0):
                print "[%d]个商人，[%d] 个随从从对岸划回此岸" %(move[0],move[1]) 
        count = count + 1

###完整代码
有了以上算法之后，我们就可以使用计算机来解决一些较大规模的问题了，完整代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
# -*- coding: utf-8 -*-
# Copyright (c) 2015 Jason Luo @ SDU

"""解决商人安全过河问题"""

import random

class Boat(object):
    def __init__(self, merchants, servants, capacity):
        self.merchants = merchants
        self.servants = servants
        self.capacity = capacity
        
        print "Initialize: [%d] merchants and [%d] servants" %(merchants, servants)
        
    '''创建允许状态集合'''    
    def allowset(self):
        allowset = []
        for i in range(self.merchants + 1):
            for j in range(self.servants + 1):
                if i == 0:
                    allowset.append([i,j])
                elif i == self.merchants:
                    allowset.append([i,j])
                elif (i >= j and ((self.merchants-i) >= (self.servants-j))):
                    allowset.append([i,j])
        return allowset

    '''创建允许决策集合'''
    def allowaction(self):
        allowactionset = []
        for i in range(self.capacity + 1):
            for j in range(self.capacity + 1):
                if (i+j) <= self.capacity and (i + j) != 0:
                    allowactionset.append([i,j])
        return allowactionset

    '''渡河'''
    def solve(self,allowactionset,allowstate):
        count = 1;
        current = (self.merchants,self.servants)
        while current != [0,0]:
            move = allowactionset[random.randint(0,len(allowactionset)-1)]
            temp = [current[0]+((-1)**count)*move[0],current[1]+((-1)**count)*move[1]]
            if(temp in allowstate):
                current = [current[0]+((-1)**count)*move[0],current[1]+((-1)**count)*move[1]]
                if(count % 2 == 1):
                    print "[%d]个商人，[%d] 个随从从此岸划到对岸" %(move[0],move[1])
                elif(count % 2 == 0):
                    print "[%d]个商人，[%d] 个随从从对岸划回此岸" %(move[0],move[1])
 
            count = count + 1


'''主方法'''            
def main():
    boat = Boat(3,3,2)
    allowstate = boat.allowset()
    print "允许状态集合为："
    print allowstate

    actionset = boat.allowaction()
    print "允许决策集合为："
    print actionset

    boat.solve(actionset,allowstate)


if __name__ == '__main__':
    main()

###运行结果

为了缩短运行结果的篇幅，我们同样采取小规模问题来验证算法的正确性，这里还是采用原问题规模，运行结果如下：

1
2
3
4
5
6
7
8
9
10
Initialize: [3] merchants and [3] servants
允许状态集合为：
[[0, 0], [0, 1], [0, 2], [0, 3], [1, 1], [2, 2], [3, 0], [3, 1], [3, 2], [3, 3]]
允许决策集合为：
[[0, 1], [0, 2], [1, 0], [1, 1], [2, 0]]
[1]个商人，[1] 个随从从此岸划到对岸
[2]个商人，[0] 个随从从此岸划到对岸
[2]个商人，[0] 个随从从对岸划回此岸
[2]个商人，[0] 个随从从此岸划到对岸
[0]个商人，[2] 个随从从此岸划到对岸

###算法评价

该算法可以解决问题，但是有很多的不足，首先，由此算法得到的结果是随机的，它只是一个可行解，并不是最优解，并且其中很可能存在重复的步骤，对于一些超大规模的问题，它会产生许多重复的计算，其中会存在许多重复与环，还有许多可以改进的方法。这里我提出一种改进方法的思路，留待思考：我们可以借助图论中的深度优先算法来改进该问题从而得到最优解。如果不一定需要最优解的话，我们还可以在该算法上应用一个队列的数据结构，记录曾经在当前状态采取的策略，从而避免采取重复决策。

#参考资料

本文的版权归作者 罗远航 所有，采用 Attribution-NonCommercial 3.0 License。任何人可以进行转载、分享，但不可在未经允许的情况下用于商业用途；转载请注明出处。感谢配合！