蒙提霍尔问题

╰半橙微兮° 2021-10-19 00:26 191阅读 0赞

### 文章目录 ###

*  问题起源
 *  源码实现
 *   *  源码
     *  结算结果
 *  分析

# 问题起源 #

三门问题（Monty Hall problem）亦称为蒙提霍尔问题、蒙特霍问题或蒙提霍尔悖论，大致出自美国的电视游戏节目Let’s Make a Deal。问题名字来自该节目的主持人蒙提·霍尔（Monty Hall）。参赛者会看见三扇关闭了的门，其中一扇的后面有一辆汽车，选中后面有车的那扇门可赢得该汽车，另外两扇门后面则各藏有一只山羊。当参赛者选定了一扇门，但未去开启它的时候，节目主持人开启剩下两扇门的其中一扇，露出其中一只山羊。主持人其后会问参赛者要不要换另一扇仍然关上的门。问题是：换另一扇门会否增加参赛者赢得汽车的机率？如果严格按照上述的条件，即主持人清楚地知道，自己打开的那扇门后是羊，那么答案是会。不换门的话，赢得汽车的几率是 1 3 \\frac\{1\}\{3\} 31。换门的话，赢得汽车的几率是 2 3 \\frac\{2\}\{3\} 32。

# 源码实现 #

## 源码 ##

package com.lyc;
    
    import lombok.*;
    import lombok.extern.slf4j.Slf4j;
    import org.assertj.core.util.Lists;
    import org.junit.Before;
    import org.junit.Test;
    
    import java.util.*;
    
    /** * @author: zhangzhenyi * @date: 2019/8/11 23:38 * @description: **/
    @Slf4j
    public class MontyHallTest { 
    
        // 汽车、山羊集合
        List<String> targetList = Lists.newArrayList();
        // 容器集合
        List<Container> containerList = Lists.newArrayList();
    
        /** * 被选择对象 */
        @Getter
        @AllArgsConstructor
        public enum Names { 
    
            CAR("汽车"),
            GOAT("山羊");
    
            private String name;
    
        }
    
        /** * 容器枚举对象 */
        public enum ContainerEnum{ 
            A,
            B,
            C;
        }
    
        /** * 构造容器 */
        @Data
        @AllArgsConstructor
        public class Container{ 
            // 容器名称
            private String index;
            // 容器中的物品
            private String name;
        }
    
        /** * 数据初始化 */
        @Before
        public void init(){ 
            // 准备汽车与山羊
            targetList.add(Names.CAR.getName());
            targetList.add(Names.GOAT.getName());
            targetList.add(Names.GOAT.getName());
            // 准备容器
            containerList.add(new Container(ContainerEnum.A.name(),""));
            containerList.add(new Container(ContainerEnum.B.name(),""));
            containerList.add(new Container(ContainerEnum.C.name(),""));
        }
    
        /** * 蒙提霍尔问题 */
        @Test
        public void testMontyHall(){ 
            // 循环次数
            int cycleTime = 90000;
            // 选对次数
            double correct = 0;
            // 选错次数
            double error = 0;
            // 选对与选错之比
            double result = 0;
            // 循环遍历多次执行
            for(int i = 0; i < cycleTime; i ++){ 
                // 如果选对，则对的+1，否则错的+1
                if(choiceEle()){ 
                    correct ++;
                } else { 
                    error ++;
                }
            }
            // 计算选择结果
            result = correct / error;
            // 在控制台中打印最终的结果
            log.info("选对的次数为：{}，选错的次数为：{},选对与选错之比：{}",correct,error,result);
        }
    
        /** * 每次选择 * @return boolean */
        private boolean choiceEle() { 
            // 随机产生山羊与汽车，并将其放入到容器中
            List<Container> loadedContainer = putContainer();
            // 随机选择一个容器
            String choiceContainer = choice(loadedContainer);
            // 主持人将剩余选项中的山羊剔除一只
            removeGoat(loadedContainer,choiceContainer);
            // 交换
            choiceContainer = exchange(loadedContainer,choiceContainer);
            // 展示选择结果
            return showResult(loadedContainer,choiceContainer);
        }
    
        /** * 展示选择结果 * @param loadedContainer 已放入物品的集合 * @param choiceContainer 备选则容器 * @return boolean */
        private boolean showResult(List<Container> loadedContainer, String choiceContainer) { 
            // 默认选择结果
            boolean flag = false;
            // 循环遍历，判断当前选择是否正确
            for(int i = 0, listSize = loadedContainer.size(); i < listSize; i ++){ 
                // 获取当前容器
                Container current = loadedContainer.get(i);
                // 如果当前容器已经被客户随机选择
                if(current.getIndex().equals(choiceContainer)){ 
                    // log.info("当前选择对象为：{}",current.getName());
                    // 如果当前选项为汽车，则选择结果为true
                    if(current.getName().equals(Names.CAR.getName())){ 
                        flag = true;
                    }
                }
            }
            // 返回最终判定的选择结果
            return flag;
        }
    
        /** * 容器交换 * @param loadedContainer 已放入物品的集合 * @param choiceContainer 被选择容器 * @return String 交换后的容器编号 */
        private String exchange(List<Container> loadedContainer, String choiceContainer) { 
            // 创建loadedContainerTemp
            List<Container> loadedContainerTemp = Lists.newArrayList();
            // 拷贝容器
            loadedContainerTemp.addAll(loadedContainer);
            for(int i = 0, listSize = loadedContainerTemp.size(); i < listSize; i ++){ 
                // 如果当前选项已经被客户随机选择，则移除当前元素
                if(loadedContainerTemp.get(i).getIndex().equals(choiceContainer)){ 
                    loadedContainerTemp.remove(i);
                    break;
                }
            }
            // 最后集合中只剩下一个容器，获取该容器编号并返回
            return loadedContainerTemp.get(0).getIndex();
        }
    
        /** * 主持人将选项中的山羊剔除一只 * @param loadedContainer 已放入物品的集合 * @param choiceContainer 被选择容器编号 */
        private void removeGoat(List<Container> loadedContainer, String choiceContainer) { 
            // 创建容器temp
            List<Container> loadedContainerTemp = Lists.newArrayList();
            // 拷贝容器
            loadedContainerTemp.addAll(loadedContainer);
            // 从中移除被选中的选项
            for(int i = 0, listSize = loadedContainerTemp.size(); i < listSize; i ++){ 
                // 如果当前选项已经被客户随机选择，则移除当前元素
                if(loadedContainerTemp.get(i).getIndex().equals(choiceContainer)){ 
                    loadedContainerTemp.remove(i);
                    break;
                }
            }
            // 被移除容器编号
            String removeContainer = null;
            // 从剩下的选项中选出一只山羊
            for(int i = 0, listSize = loadedContainerTemp.size(); i < listSize; i ++){ 
                // 如果当前元素为山羊
                if(loadedContainerTemp.get(i).getName().equals(Names.GOAT.getName())){ 
                    // 将剩余容器中的山羊所在编号取出
                    removeContainer = loadedContainerTemp.get(i).getIndex();
                }
            }
            // 从loadedContainer中移除山羊所在的容器
            for(int i = 0, list2Size = loadedContainer.size(); i < list2Size; i ++){ 
                // 如果当前选项已经被客户随机选择，则移除当前元素
                if(loadedContainer.get(i).getIndex().equals(removeContainer)){ 
                    loadedContainer.remove(i);
                    break;
                }
            }
        }
    
        /** * 随机选择 * @param loadedContainer 已放入物品的集合 * @return String 容器编号 */
        private String choice(List<Container> loadedContainer) { 
            // 创建随机函数
            Random random = new Random();
            // 获取被选择容器坐标
            int location = random.nextInt(loadedContainer.size());
            // 将被选择容器编号返回
            return loadedContainer.get(location).getIndex();
        }
    
        /** * 随机排布山羊与汽车，并将其放入到容器中 * @return List<Container> */
        private List<Container> putContainer() { 
            // 创建容器temp
            List<Container> containerListTemp = Lists.newArrayList();
            // 创建物品temp
            List<String> targetListTemp = Lists.newArrayList();
            // 拷贝容器
            containerListTemp.addAll(containerList);
            // 拷贝对象
            targetListTemp.addAll(targetList);
            // 创建随机函数
            Random random = new Random();
            // 依次在容器中随机放入物品
            for(int i = 0, listSize = containerListTemp.size(); i < listSize; i ++){ 
                // 随机获取被选择对象坐标
                int location = random.nextInt(targetListTemp.size());
                // 将被选择对象放入到容器中
                containerListTemp.get(i).setName(targetListTemp.get(location));
                // 将物品集合中的该物品移除
                targetListTemp.remove(location);
            }
            //log.info(temp.toString());
            // 返回随机放入物品后的集合
            return containerListTemp;
        }
    
    }

## 结算结果 ##

19:59:35.482 [main] INFO com.lyc.MontyHallTest - 选对的次数为：60104.0，选错的次数为：29896.0,选对与选错之比：2.0104361787530105

上述程序共将`蒙提霍尔问题`计算了`90000`遍，其中交换后选对的次数为`60104`，选错的次数为`29896`，选对与选错之比为`2.0104361787530105`，其近似值为`2`。

# 分析 #

在选择前，我们由题目可以，选中汽车的概率是 1 3 \\frac\{1\}\{3\} 31，选中山羊的概率是 2 3 \\frac\{2\}\{3\} 32，而题目中让我们选择的是汽车，毫无疑问，这个选中的概率应该是 1 3 \\frac\{1\}\{3\} 31。

计算过程是这样的：

假设第一个门A后面是汽车，概率是 1 3 \\frac\{1\}\{3\} 31，则后面两扇门B、C后面必是山羊，概率均是1，则选中汽车的期望为：

1 3 × 1 × 1 = 1 3 \\frac\{1\}\{3\} \\times 1 \\times 1= \\frac\{1\}\{3\} 31×1×1=31

假设第一个门A后面是山羊，则会出现下面两种可能组合：

*  山羊、山羊、汽车：

2 3 × 1 2 × 1 = 1 3 \\frac\{2\}\{3\} \\times \\frac\{1\}\{2\} \\times 1= \\frac\{1\}\{3\} 32×21×1=31

*  山羊、汽车、山羊：