百囚问题解析

1. 问题引入

假如有100名囚犯，编号从1到100。

你是这个监狱的监狱长，你给了他们最后一次机会；只要通过一个游戏，他们就能活下去，否则就全都枪毙。

游戏规则如下：

在一个房间里，放置了100个盒子，每个盒子里放

置的是一名囚犯的号码牌，不重不漏。

每轮囚犯轮流进入房间，只能打开其中50个

（一半）盒子；所有囚犯找到自己的号码，他们就

不用被枪毙。

每轮囚犯出来后，所有盒子又会重新关上。

盒子中号码位置不能改变，且在上一个囚犯出房间

后不能与下一个囚犯交流，但是在游戏开始前，所

有囚犯可以在一起讨论采用什么策略。问这些囚犯

可以采取什么样的策略来提高生存率呢？

2. 解决

2.1 随机

如果每名囚犯都随机打开50个盒子，那么对于一名

囚犯没有选到自己号码牌的概率为

$$P(\bar{A})=\frac{C_{99}^{50}}{C_{100}^{50}}=\frac{1}{2}$$

因此囚犯选到自己号码的概率：
$$P(A)=1-P(\bar{A})=\frac{1}{2}$$
100名囚犯都需要选到自己的号码：
$$P(success)=(\frac{1}{2}{)}^{100}$$

由此可以看出如果随机的选，这些囚犯几乎必死。

2.2 解决策略

• 每个囚犯选择自己的号码牌开始
• 下一个选择的盒子为这次盒子中的号码对应的盒子

按照这个策略，我们必然可以断定，经过有限次打开

盒子的操作，肯定能找到自己的号码牌。

实际上可以将盒子抽象为顶点，而盒子中的数抽象为边。

证明变为了所有节点出入度均为1的有向图必然各自成环。

放到后面去证明。

一个囚徒能在50次之内找到处自己的号码，说明它号码所在的环中节点数少于50。

由于盒子中纸条的位置并没有改变，所以图也没有改变。

让所有囚徒在50次以内找到自己的号码，就需要让最大的有向环中节点数少于

51。

环最大节点数小于51的可能并不好算，因此我们算大于等于51的。

$(k-1)!$为k个数成一个大环的所有可能：第一个数不与自己的位置相同，就有$k-1$种可能 ，第二个数位置与自己位置和前一个数占据位置数不同，有$k-2$种可能，之后的数都与前面占据的数加自身位置不同。因此总的可能数为$(k-1)!$

假设此时的最大环节点数为$k$，可能出现的情况数：$C_{100}^k(k-1)!(100-k)!$

$$P(k)=\frac{C_{100}^k(k-1)!(100-k)!}{100!}=\frac{1}{k}$$
最大环节点大于50的可能
$$P(failure)=\sum _{k=51}^{100}\frac{1}{k}$$
因此使用该策略能活下去的概率为
$$P(success)=1-P(failure)=0.311828$$

2.3 证明

所有节点出入度均为1的有向图必然各自成环。

必要性：单个独立有向环中每个节点必然出入度为1

充分性：

首先证明每个节点必然在一个有向环中；

如若不然，取该节点的所有前驱节点，所有后继节点；这两个节点集合必然不相交，因而存在一个前驱节点入度为0，后继出度为0，矛盾。

再证明环独立，若存在节点$a\in$环$A$, $b\in$环$B$,则必然存在一个节点入度>2，矛盾。

3. 编程模拟

3.1 Python

import random;


def getMaxCircle(pNum):
    
    ans = 1
    vis = [0]*100
    for i in  range(100):
        if 0 == vis[i]:
            cnt = 0
            j = i
            while(0 == vis[j]):
                vis[j] = 1
                cnt += 1
                j = pNum[j]
        
            ans = max(ans, cnt) 
    
    return ans
    

def HunPrisoners(n):
    
    
    failure_cnt = 0
    for i in range(n):
        pNum = list(range(100))
        
        j = 99
        while j > 0:
            kth = random.randint(0, j)
            pNum[kth], pNum[j] = pNum[j],pNum[kth]
            j -= 1

        if getMaxCircle(pNum) > 50:
            failure_cnt += 1
    
    return 1 - (failure_cnt / n)
            

if __name__ == "__main__":
   
   n = 100
   while n < 1e8:
       print("repeate %d's possibility: %lf"%(n, HunPrisoners(n)))
       n *= 10

结果 ：

repeate 1000's possibility: 0.300000
repeate 10000's possibility: 0.313200
repeate 100000's possibility: 0.313650
repeate 1000000's possibility: 0.311525

3.2 C++

#include <cstdio>
#include <random>
#include <numeric>
#include <algorithm>
double solve_prisoners()
{
    double ans = 0;
    for (int i = 51;i < 101;i++) {
        ans += (double) 1.0 / i;
    }

    return 1 - ans;
}


int getMaxCircle(const std::vector<int> &p)
{
    std::vector<int> vis(p.size(), 0);
    int ans = 1;

    for (int i = 0; i < 100;i++) {
        if (!vis[i]) {
            int node_cnt = 0;
            for (int j = i;!vis[j];j = p[j]) {
                vis[j] = 1;
                node_cnt++;
            }
            ans = std::max(ans, node_cnt);
        }
    }
    return ans;
}
void gen_perm(std::vector<int> &pNum)
{
    std::random_device rd;  // a seed source for the random number engine
    std::mt19937 gen(rd()); // mersenne_twister_engine seeded with rd()
    int cnt = 99;
    for (int cnt = 99; cnt ; --cnt) {   
        std::uniform_int_distribution<> distrib(0, cnt);
        int xth = distrib(gen);
        std::swap(pNum[xth], pNum[cnt]);

    }
}
double prisoners_success(int n)
{

    std::vector<int> pNum(100, 0);
    int failure_cnt = 0;
    for (int i = 0;i < n;++i) {            
        std::iota(pNum.begin(), pNum.end(), 0);
        gen_perm(pNum);
        if (getMaxCircle(pNum) > 50)
            failure_cnt++;
    }
    return (double) 1.0 - (double) failure_cnt / n;
}
int main()
{
    printf("probablity: %.6lf\n", solve_prisoners());
    printf("simi probablility: %.6lf", prisoners_success(1e7));
    return 0;
}

结果：

probablity: 0.311828
simi probablility: 0.311562