迭代囚徒困境：Python中固定深度策略的生成与模拟

def generate_single_player_strategies(depth):
    """
    生成一个玩家在给定深度下所有可能的行动序列。
    每个行动序列代表一个固定策略。

    参数:
        depth (int): 游戏的深度，即玩家将进行的行动次数。

    返回:
        list: 包含所有行动序列的列表，每个序列是一个由 +1 和 -1 组成的列表。
    """
    strategies = []

    def build_sequences(current_sequence, current_depth):
        # 当达到目标深度时，将当前序列添加为一种策略
        if current_depth == depth:
            strategies.append(current_sequence)
            return

        # 递归生成两种可能的行动分支
        # 选择行动 +1
        build_sequences(current_sequence + [1], current_depth + 1)
        # 选择行动 -1
        build_sequences(current_sequence + [-1], current_depth + 1)

    # 从空序列和深度0开始构建
    build_sequences([], 0)
    return strategies

# 示例：生成深度为3的所有单玩家策略
max_game_depth = 3
all_fixed_strategies = generate_single_player_strategies(max_game_depth)
print(f"深度为 {max_game_depth} 时，一个玩家的所有固定策略（行动序列）有 {len(all_fixed_strategies)} 种:")
for i, strategy in enumerate(all_fixed_strategies):
    print(f"策略 {i+1}: {strategy}")

# 预期输出 (顺序可能略有不同):
# 深度为 3 时，一个玩家的所有固定策略（行动序列）有 8 种:
# 策略 1: [1, 1, 1]
# 策略 2: [1, 1, -1]
# 策略 3: [1, -1, 1]
# 策略 4: [1, -1, -1]
# 策略 5: [-1, 1, 1]
# 策略 6: [-1, 1, -1]
# 策略 7: [-1, -1, 1]
# 策略 8: [-1, -1, -1]

leaves = [] # 全局列表，用于存储树的所有叶子节点

class Node:
    """
    表示游戏树中的一个节点。
    每个节点存储当前回合的行动值，并链接到其父节点和子节点。
    """
    def __init__(self, parent, remaining_depth, current_move_value, initial_moves_sequence):
        self.value = current_move_value  # 当前节点的行动值（+1 或 -1）
        self.left = None  # 左子节点（通常代表 -1 行动）
        self.right = None # 右子节点（通常代表 +1 行动）
        self.parent = parent # 父节点

        # 如果还有预设的初始行动序列，则根据序列构建子节点
        if len(initial_moves_sequence) > 0:
            next_move = initial_moves_sequence[0]
            if next_move == -1:
                self.left = Node(self, remaining_depth - 1, next_move, initial_moves_sequence[1:])
            elif next_move == 1:
                self.right = Node(self, remaining_depth - 1, next_move, initial_moves_sequence[1:])
        else:
            # 如果没有预设行动，且深度未达0，则递归生成所有可能的子节点
            if remaining_depth == 0:
                leaves.append(self) # 达到叶子节点，将其添加到全局列表
                return
            else:
                # 生成左子节点（行动 -1）
                self.left = Node(self, remaining_depth - 1, -1, [])
                # 生成右子节点（行动 +1）
                self.right = Node(self, remaining_depth - 1, 1, [])

def print_tree(node, level=0, prefix="Root: ", connector="    "):
    """
    辅助函数：打印树的结构以便可视化。
    """
    if node is not None:
        print(" " * (level * 4) + prefix + str(node.value))
        if node.right is not None:
            print_tree(node.right, level + 1, "├──R: ", "│   ")
        if node.left is not None:
            print_tree(node.left, level + 1, "└──L: ", "    ")

def traverse_to_parent