python的蒙特卡罗算法代码

以下是一个使用蒙特卡罗算法计算π的 Python 代码示例：

import random

def monte_carlo_pi(num_samples):
    inside_circle = 0

    for _ in range(num_samples):
        x = random.uniform(0, 1)
        y = random.uniform(0, 1)
        distance = x**2 + y**2

        if distance <= 1:
            inside_circle += 1

    pi_approximation = (inside_circle / num_samples) * 4
    return pi_approximation

num_samples = 1000000
approx_pi = monte_carlo_pi(num_samples)
print(f"Approximation of pi using {num_samples} samples: {approx_pi}")

这段代码使用随机数生成器生成在单位正方形内随机分布的点，并计算它们到原点的距离。如果距离小于等于1，则认为该点落在以原点为圆心、半径为1的圆内。通过统计落在圆内的点数，可以估算出π的近似值。

相关问题

蒙特卡罗算法python

蒙特卡罗算法是一种基于随机采样的数值计算方法，它可以用于求解各种概率问题、优化问题、积分问题等。在 Python 中实现蒙特卡罗算法，可以按照以下步骤：

1. 确定待求解的问题，例如求解圆周率 π 的值。
2. 采用随机数生成器生成大量的随机点，这些随机点应该均匀分布在问题的定义域内。对于求解圆周率，可以在一个正方形内随机生成大量的点，然后统计落在圆内的点的个数。
3. 根据采样点的分布统计出问题的解，例如根据采样点落在圆内的比例计算圆的面积，从而计算出圆周率的值。

以下是一个简单的求解圆周率的蒙特卡罗算法的 Python 代码示例：

import random

n = 1000000  # 采样点数
count = 0    # 落在圆内的点数

for i in range(n):
    x, y = random.random(), random.random()  # 在 [0,1) 区间内生成随机点
    if x**2 + y**2 <= 1:  # 判断随机点是否落在圆内
        count += 1

pi = 4 * count / n  # 计算圆周率的值
print(pi)

该代码会在 [0,1) 区间内随机生成 1000000 个点，然后统计落在圆内的点的个数，最后根据落在圆内的比例计算出圆周率的值。

蒙特卡罗数搜索算法代码

以下是一个简单的蒙特卡罗树搜索算法的示例代码，用于解决一个二人博弈问题。

class Node:
    def __init__(self, state, player):
        self.state = state # 当前节点的状态
        self.player = player # 当前玩家
        self.visit_count = 0 # 访问次数
        self.win_score = 0 # 获胜次数
        self.children = [] # 子节点列表

    def select(self):
        # 选择子节点
        node = self
        while node.children:
            node = max(node.children, key=lambda n: n.win_score / n.visit_count + sqrt(log(node.visit_count) / n.visit_count))
        return node

    def expand(self):
        # 扩展子节点
        for action in self.state.get_actions():
            state = self.state.apply_action(action)
            player = self.state.get_next_player(self.player)
            self.children.append(Node(state, player))

    def simulate(self):
        # 模拟
        state = self.state
        player = self.player
        while not state.is_terminal():
            action = random.choice(state.get_actions())
            state = state.apply_action(action)
            player = state.get_next_player(player)
        return state.get_winner() == self.player

    def backpropagate(self, result):
        # 回溯更新
        self.visit_count += 1
        self.win_score += result
        if self.parent:
            self.parent.backpropagate(result)

    def get_best_child(self):
        # 获取最佳子节点
        return max(self.children, key=lambda n: n.win_score / n.visit_count)

class MonteCarloTreeSearch:
    def __init__(self, state, player):
        self.root = Node(state, player)

    def search(self, iterations):
        # 迭代搜索
        for i in range(iterations):
            node = self.root.select()
            if not node.state.is_terminal():
                if not node.children:
                    node.expand()
                child = random.choice(node.children)
                result = child.simulate()
                child.backpropagate(result)
            else:
                result = node.state.get_winner() == node.player
                node.backpropagate(result)

        return self.root.get_best_child().state.get_last_action()

其中，`Node`类表示一个节点，包含当前状态、当前玩家、访问次数、获胜次数和子节点列表等信息。`MonteCarloTreeSearch`类实现了蒙特卡罗树搜索算法，包含迭代搜索、选择、扩展、模拟和回溯等步骤。在迭代搜索中，算法通过选择当前最优的子节点，扩展子节点，模拟并回溯更新节点信息，最终得到最佳的决策。