蒙特卡洛学习笔记

一、三门问题

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

虽然该问题的答案在逻辑上并不自相矛盾，但十分违反直觉。这问题曾引起一阵热烈的讨论。

这里要注意审题，重要条件是“当参赛者选定了一扇门，但未去开启它的时候，节目主持人开启剩下两扇门的其中一扇，露出其中一只山羊”，在程序代码中一定要把这个模拟出来。当时我就没有用上这个条件，导致求出变和不变都是三分之一的概率得奖。

import random as r
wins_unchange,wins_change,loses = 0,0,0
sims = 10_000_000

for i in range(sims):
    doors = ['A', 'B', 'B']
    initial_choice = r.choice(doors)#最开始选择一扇门
    doors.remove(initial_choice)
    doors.remove('B')#主持人展示一扇有山羊的门 
    alter_choice = r.choice(doors)#选择换门
    if initial_choice == 'A':
        wins_unchange += 1
    elif alter_choice == 'A':
        wins_change += 1      
print("The prob of unchange is {:.1%}".format(wins_unchange/sims))
print("The prob of change is {:.1%}".format(wins_change/sims))
        

二、模拟排队问题

        某银⾏⼯作时间只有⼀个服务窗⼝，⼯作⼈员只能逐个的接待顾客。当来的顾客较多时，⼀部分顾客就需要排队等待。

        假设：1) 顾客到来的间隔时间服从参数为 0.1 的指数分布 ；2) 每个顾客的服务时间服从均值为 10 ，⽅差为 4 的正态分布 ( 单位为分钟，若服务时间⼩于 1 分钟，则按 1 分钟计算 ； 3) 排队按先到先服务的规则，且不限制队伍的⻓度，每天⼯作时⻓为 8 ⼩时。

        试回答下⾯的问题：

        1) 模拟⼀个⼯作⽇，在这个⼯作⽇共接待了多少客户，客户平均等待的时间为多少 ?

        2) 模拟 100 个⼯作⽇，计算出平均每⽇接待客户的个数以及每⽇客户的平均等待时⻓。

这道题其实就是数据结构算法中的队列结构。当时上数据结构算法时也有一道类似的题，是打印机的，一会儿我也会把那道题放出来。

import numpy as np

class bank:
    
    def __init__(self,gap_time,work_time):
        self.gap_time = gap_time#接受产生的间隔时间列表
        self.work_time = work_time#接收产生的对每个顾客的工作时间
        self.ctdwn = 0
        self.tasks = []#加入工作任务
        self.to_next_task = self.gap_time.pop(0)#下一个任务多少分钟后加入
        self.wait_times = []#用于统计每个人的等待时间
        self.add_mark = []#暂时保存每个任务加入时的时刻
        
    def add_task(self,current_time):
        '''
    方法功能：
    在产生新任务的间隔结束时，加入新任务到新任务列表；
    同时记录加入新任务的时间戳
    '''
        if self.to_next_task == 0:
            self.to_next_task = self.gap_time.pop(0)
            self.tasks.append(self.work_time.pop(0))
            self.add_mark.append(current_time)
        elif self.to_next_task > 0:
            self.to_next_task -= 1
    
    
    def execute_task(self,current_time):
        '''
    方法功能：
    倒计时为零时执行新任务，把新任务从新任务列表中去掉;
    同时统计等待时间
    '''
        if self.ctdwn > 0:
            self.ctdwn -= 1
        elif self.ctdwn == 0 and len(self.tasks) > 0:
            self.ctdwn = self.tasks.pop(0)
            self.ctdwn -= 1
            wait_time = current_time - self.add_mark.pop(0)
            self.wait_times.append(wait_time)
def main():
    sim = 100_000      
    sp,awt = [],[]   
    for s in range(sim):
        tau = 10
        ppl = np.random.exponential(tau, size=199)
        # 产生199个满足指数分布的随机数，作为等待间隔时间
        ppl = np.ceil(ppl).tolist()
        # 指数分布的概率密度函数
        # lam = 1 / tau
        # x = np.arange(0,80,0.1)
        # y = lam * np.exp(- lam * x)
        service_time = np.random.normal(10, 4, 200)
        service_time = np.ceil(service_time).tolist()
        # 200名顾客的服务时间服从均值为10，⽅差为4的正态分布
        # print(np.mean(result), " ", np.var(result))
        bk = bank(ppl,service_time)
        for t in range(480):
            bk.add_task(t)
            bk.execute_task(t)
        sp.append(len(bk.wait_times))
        awt.append(sum(bk.wait_times)/len(bk.wait_times))
    print('Simulaton Times: ',sim)
    print("Service People: ",sum(sp)/sim)
    print("Average Waiting Time(minutes): ",sum(awt)/sim)
main()
#之所以用c风格是因为好调试

模拟打印问题，也是类似的排队问题。打印机的打印速度有限，每个人都有不同的打印需求。模拟在一定时间内打印机工作，每个人的平均等待时间。

import random
from pythonds import *


class Printer:
    def __init__(self,ppm):
        self.pagerate = ppm
        self.currentTask = None
        self.timeRemaining = 0

    def tick(self):
        if self.currentTask != None:
            self.timeRemaining -= 1
            if self.timeRemaining <= 0:
                self.currentTask = None

    def busy(self):
        return (self.currentTask != None)
    
    def startNext(self,newtask):
        self.currentTask = newtask
        self.timeRemaining = newtask.getPages() * 60 /self.pagerate


class Task:
    
    def __init__(self,time):
        self.timestamp = time
        self.pages = random.randrange(1,21)

    def getStamp(self):
        return self.timestamp

    def getPages(self):
        return self.pages

    def waitTime(self,currenttime):
        return currenttime - self.timestamp


def simulation(numSeconds,pagePerMinute):
    labprinter = Printer(pagePerMinute)
    printQueue  = Queue()
    waitingtimes = []
    for currentSecond in range(numSeconds):
        if newPrintTask():
            task = Task(currentSecond)
            printQueue.enqueue(task)
        if (not labprinter.busy()) and (not printQueue.isEmpty()):
            nexttask = printQueue.dequeue()
            waitingtimes.append(nexttask.waitTime(currentSecond))
            labprinter.startNext(nexttask)
        labprinter.tick()
    averageWait = sum(waitingtimes)/len(waitingtimes)
    print("Average Wait {:.2f} seconds,{} tasks remaing.".format(averageWait,printQueue.size()))
    
def newPrintTask():
    num = random.randrange(1,181)
    return (num == 180)

def main():
    for i in range(100):
        simulation(3_600,5)

if __name__ == main():main()