Lecture 10 · 博弈 I：Minimax 与 α-β 剪枝

CS221: Artificial Intelligence — Principles and Techniques · Stanford · Autumn 2025
📅 Oct 22 · 💻 games.py

---

从 MDP 到博弈

上周（Lecture 7 · 马尔可夫决策过程 与 Lecture 8 · 强化学习）：智能体在随机环境中最大化期望效用。环境的”随机”来自自然因素——掷骰子、交通状况；环境的转移概率 $T$ 与奖励 $R$ 要么已知（可用价值迭代直接求解），要么未知但可以通过交互学习（Q-learning）。关键在于：环境没有”意图”，它的随机性不针对你。

本周（博弈，games）：智能体仍然想最大化效用，但”世界的另一半”换成了一个对手（opponent）。这带来两个本质变化：其一，对手的策略是未知的——我们手里没有它的”转移概率表”；其二，对手可能在故意跟你作对——它不是被动的随机源，而是主动的对抗者。环境从”被动的随机”变成了”主动的对抗”。

动机例子：一棵小游戏树（下文 Game1），你在根节点先手，你该选哪个动作？

维度	MDP	博弈（Games）
谁在控制”另一半”	环境（自然）	对手（另一个智能体）
那一半的行为	随机、已知/可学	对抗、未知
目标	最大化期望效用	最大化效用（对手想最小化它）
类比算法	价值迭代	expectimax / minimax

---

1. 博弈的形式化（Modeling）

本讲聚焦两人零和博弈（two-player zero-sum games）：

• 两个玩家：agent（我们）和 opp（对手 opponent）；
• 零和（zero-sum）：$\text{utility}_{\text{agent}}(s) = -\,\text{utility}_{\text{opp}}(s)$——一方赢多少，另一方就输多少，蛋糕大小固定。因此整个博弈只需要一个效用函数（站在 agent 的角度），对手的目标自动就是最小化它。

1.1 Game 的接口

一个博弈由下面五个部分定义（对比搜索/MDP：多了一个 player，因为不同状态由不同玩家控制）：

class Game:
    def start_state(self) -> Any:
        """游戏从哪里开始"""
        raise NotImplementedError

    def successors(self, state: Any) -> dict[str, Any]:
        """后继：动作 → 下一状态（注意这里是 dict，不是列表）"""
        raise NotImplementedError

    def player(self, state: Any) -> str:
        """在 state 该谁行动？('agent' 或 'opp')"""
        raise NotImplementedError

    def is_end(self, state: Any) -> bool:
        """游戏结束了吗？"""
        raise NotImplementedError

    def utility(self, state: Any) -> float:
        """游戏的效用（站在 agent 的角度）"""
        raise NotImplementedError

博弈的两个关键特征（源码原话）：

• 所有效用都在终止状态——utility(s) 只在 is_end(s) 时才有定义。这是稀疏奖励（sparse reward）：中途每一步都没有奖励信号，只有走到底才知道输赢。这一点让”学会评估中间局面”（下一讲的 TD 学习）成为必须解决的问题。
• 不同状态由不同玩家控制——player(s) 告诉你这一层轮到谁行动。这是博弈区别于 MDP 的本质：MDP 里每个状态都是 agent 在决策，博弈里控制权在玩家之间交替。

1.2 例子 1：一棵小游戏树

Game1 是一棵深度为 2 的树：根节点 agent 先选 A/B/C，然后对手在每个分支里选 1/2，叶子给出效用。

class Game1(Game):
    def start_state(self) -> Any:
        return "root"

    def successors(self, state: str) -> dict[str, str]:
        # state -> action -> next state
        mapping = {
            "root": {"A": "A", "B": "B", "C": "C"},
            "A": {"1": "A1", "2": "A2"},
            "B": {"1": "B1", "2": "B2"},
            "C": {"1": "C1", "2": "C2"},
        }
        return mapping[state]

    def player(self, state: Any) -> str:
        if state == "root":
            return "agent"          # 根节点：我们先手
        if state in ["A", "B", "C"]:
            return "opp"            # 第二层：对手行动
        raise ValueError(f"Invalid state: {state}")

    def is_end(self, state: Any) -> bool:
        return state in ["A1", "A2", "B1", "B2", "C1", "C2"]

    def utility(self, state: Any) -> float:
        utilities = {
            "A1": -50, "A2": 50,
            "B1": 1,   "B2": 3,
            "C1": -5,  "C2": 15,
        }
        return utilities[state]

游戏树长这样（🟩 agent 层、🟦 opp 层、🟧 叶子效用）：

graph TD
    R["root<br/>agent(max)"]
    R -->|A| A["A<br/>opp(min)"]
    R -->|B| B["B<br/>opp(min)"]
    R -->|C| C["C<br/>opp(min)"]
    A -->|1| A1["A1 = -50"]
    A -->|2| A2["A2 = 50"]
    B -->|1| B1["B1 = 1"]
    B -->|2| B2["B2 = 3"]
    C -->|1| C1["C1 = -5"]
    C -->|2| C2["C2 = 15"]

    style R fill:#c8e6c9,stroke:#2e7d32
    style A fill:#e1f5fe,stroke:#0277bd
    style B fill:#e1f5fe,stroke:#0277bd
    style C fill:#e1f5fe,stroke:#0277bd
    style A1 fill:#ffe0b2,stroke:#e65100
    style A2 fill:#ffe0b2,stroke:#e65100
    style B1 fill:#ffe0b2,stroke:#e65100
    style B2 fill:#ffe0b2,stroke:#e65100
    style C1 fill:#ffe0b2,stroke:#e65100
    style C2 fill:#ffe0b2,stroke:#e65100

1.3 例子 2：减半游戏（Halving Game）

一个能真正”玩到底”的博弈：两人轮流对一个数 $n$ 做减一（decrement）或减半（half，整数除以 2）。胜负规则（对照代码确认）：轮到某个玩家时 $n$ 已经是 0，该玩家获胜——换个说法，亲手把 $n$ 变成 0 的一方输，因为把 0 留给对手就是把胜利送给对手。

注意状态里必须带上 player——同一个数 $n$，轮到我还是轮到对手，输赢完全相反；只记 $n$ 不足以判断局面。

@dataclass(frozen=True)
class HalvingState:
    n: int          # 当前的数
    player: str     # 轮到谁（状态必须带上，否则无法判断输赢）

class HalvingGame(Game):
    def __init__(self, n: int):
        self.n = n

    def start_state(self) -> Any:
        return HalvingState(n=self.n, player="agent")

    def successors(self, state: HalvingState) -> dict[str, Any]:
        next_player = "opp" if state.player == "agent" else "agent"
        return {
            "decrement": HalvingState(n=state.n - 1, player=next_player),
            "half":      HalvingState(n=state.n // 2, player=next_player),
        }

    def player(self, state: HalvingState) -> str:
        return state.player

    def is_end(self, state: HalvingState) -> bool:
        return state.n == 0

    def utility(self, state: HalvingState) -> float:
        assert state.n == 0
        # 轮到谁时数已经是 0，谁就赢
        return +1 if state.player == "agent" else -1

1.4 策略：确定性 vs 随机

策略（policy） 是玩家 $p$ 在状态 $s$ 的决策规则，有两种：

类型	记号	含义
确定性（deterministic）	$\pi_p(s)$	玩家 $p$ 在状态 $s$ 确定采取的动作
随机（stochastic）	$\pi_p(a\mid s)$	玩家 $p$ 在 $s$ 按概率分布选动作 $a$

源码统一用随机策略表达（确定性策略只是把某个动作的概率设成 1.0 的特例），策略返回一个 {动作: 概率} 字典。simulate 让轮到的玩家各按自己的策略采样动作，一路走到终局：

Policy = Callable[[Any], Any]   # state -> {action: prob}

def simulate(game: Game, policies: dict[str, Policy]) -> Rollout:
    """从起始状态用各自的策略模拟一整局。"""
    state = game.start_state()
    steps = []
    while not game.is_end(state):
        player = game.player(state)         # 轮到谁
        actions = policies[player](state)   # {action: prob}
        action = sample_dict(actions)       # 按概率采样一个动作
        state = game.successors(state)[action]
        steps.append(Step(action=action, state=state))
    return Rollout(steps=steps, utility=game.utility(state))  # 走到底看谁赢

---

2. 递归定义一系列结果

本讲的核心骨架：同一个递归框架，改变”每类玩家节点如何汇聚子节点的价值”，就得到四种不同的价值。

结果	agent 节点	opp 节点	类比 MDP
game evaluation	按 $\pi_{\text{agent}}$ 加权	按 $\pi_{\text{opp}}$ 加权	策略评估
expectimax	$\max$	按 $\pi_{\text{opp}}$ 加权（期望）	价值迭代
minimax	$\max$	$\min$（对抗）	无对应
expectiminimax	$\max$	$\min$ + 机会节点求期望	无对应

2.1 Game Evaluation：给定双方策略，求价值

问题：双方策略都固定时，这局游戏的价值（value）——即所有可能对局（rollout）上的期望效用——是多少？

蒙特卡洛法可以模拟很多局取平均，但有方差且慢。用递归可以精确求出：

$$V_{\text{eval}}(s)=\begin{cases}\text{utility}(s), & \text{若 } \mathrm{isEnd}(s)\\[4pt] \displaystyle\sum_{a}\pi_{p}(a\mid s)\,V_{\text{eval}}\big(\mathrm{succ}(s,a)\big), & \text{否则，其中 } p=\mathrm{player}(s)\end{cases}$$

符号说明：$\mathrm{succ}(s,a)$ 是在 $s$ 执行动作 $a$ 后到达的（确定的）下一状态；$\pi_p(a\mid s)$ 是轮到的玩家 $p$ 选动作 $a$ 的概率。不管是 agent 还是 opp 的节点，都按该玩家自己的策略概率加权——因为两边策略都已知，没有任何”选择”要做，只是算一个期望。

def V_eval(game: Game, policies: dict[str, Policy], state: Any) -> float:
    """给定双方策略，返回博弈的价值（期望效用）。"""
    if game.is_end(state):
        return game.utility(state)

    # 轮到谁，就用谁的策略
    player = game.player(state)
    policy = policies[player]

    value = 0
    for action, prob in policy(state).items():
        next_state = game.successors(state)[action]
        value += prob * V_eval(game, policies, next_state)   # 按策略概率加权

    return value

2.2 Expectimax：对手策略已知，求 agent 最优策略

问题：不再固定 agent 的策略，而是求 agent 的最优策略；但假设对手的策略 $\pi_{\text{opp}}$ 已知且固定（比如已知对手在动作 1/2 之间各以 0.5 随机选）。

$$V_{\text{exptmax}}(s)=\begin{cases}\text{utility}(s), & \text{若 } \mathrm{isEnd}(s)\\[4pt] \displaystyle\max_{a} V_{\text{exptmax}}\big(\mathrm{succ}(s,a)\big), & \text{若 } \mathrm{player}(s)=\text{agent}\\[4pt] \displaystyle\sum_{a}\pi_{\text{opp}}(a\mid s)\,V_{\text{exptmax}}\big(\mathrm{succ}(s,a)\big), & \text{若 } \mathrm{player}(s)=\text{opp}\end{cases}$$

agent 节点取 $\max$（在自己能控制的层挑最好的动作），opp 节点取期望（对手照它已知的分布走，我们对其随机性求平均）。

def V_exptmax(game: Game, opp_policy: Policy, state: Any) -> float:
    if game.is_end(state):
        return game.utility(state)

    player = game.player(state)

    if player == "agent":
        # 选让效用最大的动作
        next_states = list(game.successors(state).values())
        values = [V_exptmax(game, opp_policy, s) for s in next_states]
        return np.max(values)

    elif player == "opp":
        # 对手照它已知的（随机）策略走 → 求期望
        successors = game.successors(state)          # action -> next state
        values = [prob * V_exptmax(game, opp_policy, successors[a])
                  for a, prob in opp_policy(state).items()]
        return np.sum(values)

    else:
        raise ValueError(f"Invalid player: {player}")

2.3 Minimax：对手对抗，取 min

问题的关键：博弈的要害恰恰是我们不知道对手策略！expectimax 假设对手策略已知，太乐观——万一对手不是随机的，而是个高手呢？

$$V_{\text{minmax}}(s)=\begin{cases}\text{utility}(s), & \text{若 } \mathrm{isEnd}(s)\\[4pt] \displaystyle\max_{a} V_{\text{minmax}}\big(\mathrm{succ}(s,a)\big), & \text{若 } \mathrm{player}(s)=\text{agent}\\[4pt] \displaystyle\min_{a} V_{\text{minmax}}\big(\mathrm{succ}(s,a)\big), & \text{若 } \mathrm{player}(s)=\text{opp}\end{cases}$$

agent 层取 $\max$，opp 层取 $\min$——不需要事先给定任何策略，双方都被假设为完美对抗，策略从递归本身”涌现”出来。

def V_minmax(game: Game, state: Any) -> tuple[float, Action]:
    """返回博弈价值 + 最优动作。"""
    if game.is_end(state):
        return game.utility(state), None

    player = game.player(state)

    # 对所有后继递归求值
    successors = game.successors(state)
    values = {action: V_minmax(game, next_state)[0]
              for action, next_state in successors.items()}

    if player == "agent":       # agent 最大化效用
        action, value = max(values.items(), key=lambda x: x[1])
    elif player == "opp":       # 对手最小化效用
        action, value = min(values.items(), key=lambda x: x[1])
    else:
        raise ValueError(f"Invalid player: {player}")

    return value, action

minimax 在 Game1 上的计算（从叶子往上，红色节点是取 $\min$ 后的值）：

graph BT
    A1["A1=-50"] --> A["A: min = -50"]
    A2["A2=50"] --> A
    B1["B1=1"] --> B["B: min = 1"]
    B2["B2=3"] --> B
    C1["C1=-5"] --> C["C: min = -5"]
    C2["C2=15"] --> C
    A --> R["root: max(-50,1,-5) = 1<br/>→ 选 B"]
    B --> R
    C --> R

    style A1 fill:#e1f5fe,stroke:#0277bd
    style A2 fill:#e1f5fe,stroke:#0277bd
    style B1 fill:#e1f5fe,stroke:#0277bd
    style B2 fill:#e1f5fe,stroke:#0277bd
    style C1 fill:#e1f5fe,stroke:#0277bd
    style C2 fill:#e1f5fe,stroke:#0277bd
    style A fill:#ffcdd2,stroke:#c62828
    style B fill:#ffcdd2,stroke:#c62828
    style C fill:#ffcdd2,stroke:#c62828
    style R fill:#ffe0b2,stroke:#e65100

减半游戏里的碾压：让 agent 用 minimax 策略（每步取 $V_{\text{minmax}}$ 给出的最优动作、确定性地下），对手用随机策略，两者对打时 minimax 把随机策略打得落花流水。再逐个初始 $n$ 求 minimax 价值：

game = HalvingGame(n=11)
results = {n: V_minmax(game, HalvingState(n=n, player="agent"))
           for n in range(1, 12)}

• 价值 $=+1$：无论对手怎么走，agent 保证赢（存在必胜路线）；
• 价值 $=-1$：只要对手下得最优，agent 必输——但对手若失误，agent 仍可能翻盘。

2.4 Expectiminimax：既有随机又有对抗

现实游戏里常常同时有对手（对抗）和骰子（随机）——比如西洋双陆棋（backgammon）。此时把掷骰子建模为第三类”玩家”——机会节点（chance node），游戏树里出现三类节点：agent（$\max$）、opp（$\min$）、chance（求期望）：

$$V(s)=\begin{cases}\text{utility}(s), & \mathrm{isEnd}(s)\\[2pt] \max_{a} V\big(\mathrm{succ}(s,a)\big), & \mathrm{player}(s)=\text{agent}\\[2pt] \min_{a} V\big(\mathrm{succ}(s,a)\big), & \mathrm{player}(s)=\text{opp}\\[2pt] \sum_{a} P(a\mid s)\,V\big(\mathrm{succ}(s,a)\big), & \mathrm{player}(s)=\text{chance}\end{cases}$$

其中 $P(a\mid s)$ 是机会节点的已知分布（如骰子各面 $1/6$）——它不是谁的”策略”，而是物理规律，所以永远取期望。

---

3. Minimax 的性质：对谁最优？

计算不同的递归会产生不同的策略。记 $V(\pi_{\text{agent}}, \pi_{\text{opp}})$ 为”agent 用 $\pi_{\text{agent}}$、对手用 $\pi_{\text{opp}}$ 对打时的博弈价值”（按 §2.1 的 $V_{\text{eval}}$ 算出）。几个角色：

• $\pi_{\max}, \pi_{\min}$：minimax 递归同时给出的 agent 策略与对手策略；
• $\pi_{7}$：某个已知的固定对手策略（讲义用编号 7 泛指”随便某一个策略”，例如均匀随机）；
• $\pi_{\text{exptmax}(7)}$：假设对手就是 $\pi_7$ 时，expectimax 算出的 agent 最优应对。

三条性质（把不同策略两两对打）：

性质	不等式	含义
性质 1	$V(\pi_{\text{exptmax}(7)}, \pi_{\min}) \le V(\pi_{\max}, \pi_{\min})$	面对 $\pi_{\min}$，$\pi_{\max}$ 是最好的 agent 策略；针对错误对手模型优化会吃亏
性质 2	$V(\pi_{\max}, \pi_{\min}) \le V(\pi_{\max}, \pi_{7})$	面对 $\pi_{\max}$，$\pi_{\min}$ 是最好的对手策略；换任何别的对手只会让 agent 拿得更多
性质 3	$V(\pi_{\max}, \pi_{7}) \le V(\pi_{\text{exptmax}(7)}, \pi_{7})$	若确实知道对手是 $\pi_7$，$\pi_{\text{exptmax}(7)}$ 比 minimax 更好

把三条串成一条链：

$$V(\pi_{\text{exptmax}(7)}, \pi_{\min}) \;\le\; V(\pi_{\max}, \pi_{\min}) \;\le\; V(\pi_{\max}, \pi_{7}) \;\le\; V(\pi_{\text{exptmax}(7)}, \pi_{7})$$

---

4. α-β 剪枝：加速 minimax（精确）

回到最基本的 minimax——它要展开整棵游戏树，时间是 $O(b^d)$（$b$ 为分支因子，即每层平均可选动作数；$d$ 为树深，即总步数），一般是指数时间。怎么加速？

4.1 分支限界（branch and bound）的直觉

一个极简例子：

• 分支 A 的值落在区间 $[3, 5]$；
• 分支 B 的值落在区间 $[5, 100]$。

你（max 节点）会选哪个？无论 A、B 最终精确值是多少，B 一定不比 A 差——所以根本不用把两者都算精确。只要区间不重叠，就能提前下结论。这个思想叫分支限界（branch and bound），在组合优化里被大量使用。

再看一棵树：根 $= \max\big(3,\ \min(2, X)\big)$。左子已算出为 3；右子是个 min 节点，已经看到一个子节点是 2，所以右子的最终值 $\le 2$。既然右子最多 2、比 3 小，根一定取左边的 3——$X$ 无论是多少都不用探索了，剪掉！

graph TD
    R["root (max)<br/>= max(3, ≤2) = 3"]
    R -->|已算| L["左: min = 3"]
    R -->|"部分"| M["右 (min)<br/>≤ 2 (已见 2)"]
    M --> V2["叶 = 2"]
    M -.✂️ 剪枝.-> X["X (无需探索)"]

    style R fill:#ffe0b2,stroke:#e65100
    style L fill:#c8e6c9,stroke:#2e7d32
    style M fill:#e1f5fe,stroke:#0277bd
    style V2 fill:#e1f5fe,stroke:#0277bd
    style X fill:#ffcdd2,stroke:#c62828

4.2 一般机制：用 α / β 界剪枝

深度优先探索的过程中，沿路径维护两个界：

• $\alpha$：max 节点的下界——沿当前路径，agent 已经能保证拿到的最好值（随着 max 节点探索更多子节点，$\alpha$ 只升不降，$\alpha \leftarrow \max(\alpha, v_{\text{child}})$）；
• $\beta$：min 节点的上界——沿当前路径，对手已经能把 agent 压到的最低值（随着 min 节点探索更多子节点，$\beta$ 只降不升，$\beta \leftarrow \min(\beta, v_{\text{child}})$）。

minimax 的最终价值来自某个叶子；从根到那个叶子、由双方最优策略走出的路径叫最优路径（optimal path）。最优路径上的值必须同时满足路径上所有祖先的界——落在 $[\alpha, \beta]$ 区间内。

graph TD
    R["根 max<br/>α 累积上升"]
    R --> N1["min 节点<br/>β 累积下降"]
    N1 --> G1["已探索子树<br/>确定 min 的 β"]
    N1 --> P["下一个子节点"]
    P -.✂️ α ≥ β 则剪.-> SUB["整片子树跳过"]

    style R fill:#c8e6c9,stroke:#2e7d32
    style N1 fill:#e1f5fe,stroke:#0277bd
    style G1 fill:#e1f5fe,stroke:#0277bd
    style P fill:#ffe0b2,stroke:#e65100
    style SUB fill:#ffcdd2,stroke:#c62828

4.3 走子顺序（move ordering）很关键

实践中用启发式（比如下一节的评估函数）给子节点排序，让界尽快收紧：

• max 节点：按估值从大到小（decreasing）排——先试最可能好的动作，早早抬高 $\alpha$；
• min 节点：按估值从小到大（increasing）排——先试对 agent 最狠的动作，早早压低 $\beta$。

在最优排序下，α-β 能把 minimax 的时间复杂度从 $O(b^{d})$ 降到约 $O(b^{d/2})$——相当于每层有效分支从 $b$ 缩到 $\sqrt{b}$，也意味着同样的计算预算能把搜索深度翻倍，这在实战棋力上是巨大的差距；最坏排序则退化回纯 minimax，几乎剪不掉任何东西。

---

5. 评估函数：深度受限的近似

即便有 α-β 剪枝，国际象棋（分支因子 $b \approx 35$）、围棋（$b \approx 250$）的完整树仍然根本算不完——指数就是指数。剪枝是精确加速，还需要一个近似手段。

深度受限的递归：搜到深度 $d$ 就停，用 $\mathrm{Eval}(s)$ 顶替真正的 $V(s)$：

$$V(s, d)=\begin{cases}\text{utility}(s), & \mathrm{isEnd}(s)\\[2pt] \mathrm{Eval}(s), & d = 0 \text{（深度耗尽）}\\[2pt] \max_{a} V\big(\mathrm{succ}(s,a),\, d-1\big), & \mathrm{player}(s)=\text{agent}\\[2pt] \min_{a} V\big(\mathrm{succ}(s,a),\, d-1\big), & \mathrm{player}(s)=\text{opp}\end{cases}$$

其中 $d$ 是剩余可搜索的层数，每递归一层减 1。

---

6. 总结

mindmap
  root((博弈 I))
    形式化
      两人零和博弈
      Game 五元组接口
      效用只在终止状态·稀疏奖励
      不同状态由不同玩家控制
    策略
      确定性策略
      随机策略
    四种递归
      V_eval 双方策略给定求期望
      V_exptmax 对手已知取期望
      V_minmax 对手对抗取 min
      expectiminimax 加机会节点
    minimax 性质
      对最坏对手最优
      对任意对手是下界
      知道对手时 expectimax 更好
    加速
      α-β 剪枝·分支限界·精确
      走子顺序 max 降序 min 升序
      评估函数·深度受限·近似

关键要点：

• 博弈 = 对手未知的对抗：MDP 的环境随机且已知/可学，博弈里对手主动跟你作对且策略未知。
• Game 五元组：start_state / successors / player / is_end / utility；所有效用在终止状态（稀疏奖励）；不同状态由不同玩家控制。
• 一套递归框架、改汇聚算子：$V_{\text{eval}}$（双方按策略加权）→ $V_{\text{exptmax}}$（agent 取 $\max$、opp 取期望）→ $V_{\text{minmax}}$（agent 取 $\max$、opp 取 $\min$）→ expectiminimax（再加机会节点求期望）。
• Minimax 原则：假设对手最小化你的效用；它对最坏对手最优，同时给出面对任意对手的价值下界；若真了解对手，expectimax 能做得更好——“最优”永远相对于对手假设而言。
• α-β 剪枝：用分支限界跳过不可能被最优路径经过的子树，精确不改结果；剪枝条件 $\alpha \ge \beta$；走子顺序决定剪枝效率，最优排序下复杂度约 $O(b^{d/2})$，等价于搜索深度翻倍。
• 评估函数：深度受限时用先验知识（如棋子物质分）近似 $V$，牺牲最优性换速度，类比 Lecture 6 · UCS 与 A* 搜索 的 FutureCost。

下一讲预告：评估函数不该靠手写——能不能从对弈中学出 $V(s;\mathbf{w})$？→ TD 学习（类比 SARSA : $Q_\pi$ :: TD : $V_\pi$，TD-Gammon 与自我对弈）；再放开”回合制”假设，进入同时博弈（Morra、纯/混合策略、minimax 定理与纳什均衡）→ Lecture 11 · 博弈 II：TD 学习与同时博弈。

---

复习自测

---

参考资料

• 💻 games.py — 本讲源码（Game / Game1 / HalvingGame / V_eval / V_exptmax / V_minmax）
• 📖 Russell & Norvig: Artificial Intelligence: A Modern Approach — 第 5 章：对抗搜索与博弈（minimax、α-β、评估函数）
• 📄 Programming a Computer for Playing Chess (Shannon, 1950) — 极小化极大 + 评估函数的开山之作
• 📄 Some Studies in Machine Learning Using Checkers (Samuel, 1959) — 自对弈学习评估函数（引出 L11）
• 🔗 α-β 剪枝可视化 (Autumn 2023 module) — 交互式游戏树演示
• 🌐 CS221 课程主页 — 全部讲义与模块