多人博弈AI设计

在双人零和博弈中（如国际象棋、围棋），胜负是清晰的：我赢你输。但当博弈者增加到三人或更多时，游戏的复杂度发生了质变：联盟、背叛、动态平衡 成为关键要素。
多人博弈（Multiplayer Games）不再是简单的”最大化自己的收益”，而是需要考虑：

何时与他人合作？

如何防止被针对？

何时背叛盟友？

如何平衡风险与收益？

本文将深入探讨多人博弈 AI 的核心算法（Paranoid、MaxN、Best Reply）、联盟形成策略，以及在经典多人游戏（三国杀、狼人杀、德州扑克）中的应用。

一、多人博弈的独特挑战#

1.1 与双人博弈的根本区别#

双人零和博弈：

你的收益 = 对手的损失（零和）
目标：最大化自己的收益 = 最小化对手的收益
算法：Minimax、Alpha-Beta 剪枝

多人非零和博弈：

总收益可能不为零
存在共同利益（合作）和冲突利益（竞争）
需要考虑 社会因素（信任、威胁、承诺）

示例：三人扑克

1
初始筹码：A=100, B=100, C=100
2

3
场景1（针对最强者）:
4
- A 当前领先（150筹码）
5
- B 和 C 可能联手攻击 A
6
- A 需要"示弱"避免成为众矢之的
7

8
场景2（搭便车）:
9
- A 发起进攻 B
10
- C 可以"坐山观虎斗"
11
- 等 A、B 两败俱伤后收割

1.2 核心概念#

纳什均衡（Nash Equilibrium）：

定义：每个玩家的策略都是对其他玩家策略的最佳响应
多人博弈中可能存在 多个纳什均衡

帕累托最优（Pareto Optimality）：

定义：无法在不损害任何人利益的情况下改善某人的状况
多人博弈中，纳什均衡不一定是帕累托最优

联盟价值（Coalition Value）：

v(S) = \text{联盟 } S \text{ 能获得的最大总收益}

二、搜索算法#

2.1 Paranoid 算法#

假设：所有其他玩家联合起来对抗你。

适用场景：当你领先时，保守策略。

1
def paranoid_search(state, depth, max_player):
2
    """
3
    Paranoid 算法：假设所有对手联盟
4

5
    Args:
6
        state: 当前游戏状态
7
        depth: 搜索深度
8
        max_player: 当前最大化收益的玩家
9
    """
10
    if depth == 0 or state.is_terminal():
11
        return state.evaluate(max_player), None
12

13
    if state.current_player == max_player:
14
        # 最大化自己的收益
15
        max_value = float('-inf')
16
        best_move = None
17

18
        for move in state.legal_moves():
19
            next_state = state.apply_move(move)
20
            value, _ = paranoid_search(next_state, depth - 1, max_player)
21

22
            if value > max_value:
23
                max_value = value
24
                best_move = move
25

26
        return max_value, best_move
27
    else:
28
        # 假设其他玩家联合起来最小化你的收益
29
        min_value = float('inf')
30
        best_move = None
31

32
        for move in state.legal_moves():
33
            next_state = state.apply_move(move)
34
            value, _ = paranoid_search(next_state, depth - 1, max_player)
35

36
            if value < min_value:
37
                min_value = value
38
                best_move = move
39

40
        return min_value, best_move
41

42
# 使用示例
43
class ThreePlayerGame:
44
    def __init__(self):
45
        self.current_player = 0
46
        self.scores = [0, 0, 0]
47

48
    def evaluate(self, player):
49
        """评估函数：返回该玩家的得分"""
50
        return self.scores[player]
51

52
    def legal_moves(self):
53
        return ["move1", "move2", "move3"]
54

55
    def is_terminal(self):
56
        return max(self.scores) >= 100
57

58
# AI 决策
59
game = ThreePlayerGame()
60
best_score, best_move = paranoid_search(game, depth=4, max_player=0)
61
print(f"最佳移动: {best_move}, 预期得分: {best_score}")

优点：

✅ 保守策略，适合领先时防守
✅ 计算复杂度与双人博弈相同 $O(b^d)$

缺点：

❌ 过于悲观，假设所有人都针对你
❌ 不适合落后时的进攻策略

2.2 MaxN 算法#

假设：每个玩家都独立最大化自己的收益。

适用场景：更符合现实的多人博弈。

1
def maxn_search(state, depth):
2
    """
3
    MaxN 算法：每个玩家最大化自己的收益
4

5
    Returns:
6
        tuple: (评估向量, 最佳移动)
7
        评估向量: [player0_value, player1_value, player2_value, ...]
8
    """
9
    if depth == 0 or state.is_terminal():
10
        return state.evaluate_all(), None
11

12
    current_player = state.current_player
13
    best_value = None
14
    best_move = None
15

16
    for move in state.legal_moves():
17
        next_state = state.apply_move(move)
18
        value_tuple, _ = maxn_search(next_state, depth - 1)
19

20
        # 当前玩家选择使自己收益最大的移动
21
        if best_value is None or value_tuple[current_player] > best_value[current_player]:
22
            best_value = value_tuple
23
            best_move = move
24

25
    return best_value, best_move
26

27
class ThreePlayerGame:
28
    def evaluate_all(self):
29
        """返回所有玩家的评估值"""
30
        return tuple(self.scores)  # (score0, score1, score2)
31

32
    def apply_move(self, move):
33
        """应用移动并返回新状态"""
34
        new_state = copy.deepcopy(self)
35
        # 执行移动逻辑
36
        new_state.current_player = (new_state.current_player + 1) % 3
37
        return new_state
38

39
# 使用
40
game = ThreePlayerGame()
41
value_tuple, best_move = maxn_search(game, depth=4)
42
print(f"最佳移动: {best_move}")
43
print(f"预期结果: Player0={value_tuple[0]}, Player1={value_tuple[1]}, Player2={value_tuple[2]}")

优点：

✅ 更符合实际情况
✅ 能发现合作与竞争的平衡点

缺点：

❌ 复杂度高 $O(b^{d \cdot n})$ ， $n$ 为玩家数
❌ 需要准确的评估函数

2.3 Shallow Pruning（浅层剪枝）#

原理：在 MaxN 中进行剪枝优化。

1
def maxn_with_pruning(state, depth, bounds=None):
2
    """
3
    MaxN + Shallow Pruning
4

5
    Args:
6
        bounds: [lower_bound, upper_bound] 对于当前玩家
7
    """
8
    if depth == 0 or state.is_terminal():
9
        return state.evaluate_all(), None
10

11
    current_player = state.current_player
12

13
    if bounds is None:
14
        bounds = [float('-inf'), float('inf')]
15

16
    best_value = None
17
    best_move = None
18

19
    for move in state.legal_moves():
20
        next_state = state.apply_move(move)
21
        value_tuple, _ = maxn_with_pruning(next_state, depth - 1, bounds)
22

23
        if best_value is None or value_tuple[current_player] > best_value[current_player]:
24
            best_value = value_tuple
25
            best_move = move
26

27
            # 更新下界
28
            bounds[0] = max(bounds[0], value_tuple[current_player])
29

30
            # 剪枝：如果当前玩家的收益已经超过上界
31
            if bounds[0] >= bounds[1]:
32
                break
33

34
    return best_value, best_move

2.4 Best Reply Search#

思想：计算对其他玩家策略的最佳响应。

1
class BestReplySearch:
2
    def __init__(self, num_players):
3
        self.num_players = num_players
4

5
    def find_nash_equilibrium(self, game, max_iterations=100):
6
        """寻找纳什均衡"""
7
        # 初始化：随机策略
8
        strategies = [self.random_strategy(game) for _ in range(self.num_players)]
9

10
        for iteration in range(max_iterations):
11
            improved = False
12

13
            for player in range(self.num_players):
14
                # 固定其他玩家的策略
15
                opponent_strategies = strategies[:player] + strategies[player+1:]
16

17
                # 计算最佳响应
18
                best_response = self.best_response(game, player, opponent_strategies)
19

20
                # 如果找到更好的策略，更新
21
                if self.is_better(best_response, strategies[player], player, game):
22
                    strategies[player] = best_response
23
                    improved = True
24

25
            # 如果没有改进，达到纳什均衡
26
            if not improved:
27
                break
28

29
        return strategies
30

31
    def best_response(self, game, player, opponent_strategies):
32
        """计算玩家对对手策略的最佳响应"""
33
        best_payoff = float('-inf')
34
        best_strategy = None
35

36
        # 枚举所有可能的策略
37
        for strategy in self.all_strategies(game, player):
38
            # 计算该策略的期望收益
39
            payoff = game.evaluate_strategy(player, strategy, opponent_strategies)
40

41
            if payoff > best_payoff:
42
                best_payoff = payoff
43
                best_strategy = strategy
44

45
        return best_strategy

三、联盟与谈判#

3.1 Shapley 值（联盟贡献分配）#

原理：根据每个玩家对联盟的贡献分配收益。

\phi_i(v) = \sum_{S \subseteq N \setminus \{i\}} \frac{|S|! (n - |S| - 1)!}{n!} [v(S \cup \{i\}) - v(S)]

1
from itertools import combinations, permutations
2

3
def shapley_value(player, coalition_values, all_players):
4
    """
5
    计算 Shapley 值
6

7
    Args:
8
        player: 目标玩家
9
        coalition_values: 字典 {frozenset: value}
10
        all_players: 所有玩家的集合
11
    """
12
    n = len(all_players)
13
    shapley = 0
14

15
    # 枚举所有不包含该玩家的联盟
16
    other_players = all_players - {player}
17

18
    for r in range(len(other_players) + 1):
19
        for subset in combinations(other_players, r):
20
            S = frozenset(subset)
21
            S_with_player = S | {player}
22

23
            # 计算边际贡献
24
            marginal_contribution = coalition_values[S_with_player] - coalition_values[S]
25

26
            # 计算权重
27
            weight = (
28
                math.factorial(len(S)) *
29
                math.factorial(n - len(S) - 1) /
30
                math.factorial(n)
31
            )
32

33
            shapley += weight * marginal_contribution
34

35
    return shapley
36

37
# 示例：三人游戏
38
coalition_values = {
39
    frozenset(): 0,
40
    frozenset(['A']): 10,
41
    frozenset(['B']): 10,
42
    frozenset(['C']): 10,
43
    frozenset(['A', 'B']): 30,  # A+B 合作价值高
44
    frozenset(['A', 'C']): 25,
45
    frozenset(['B', 'C']): 25,
46
    frozenset(['A', 'B', 'C']): 60
47
}
48

49
all_players = frozenset(['A', 'B', 'C'])
50

51
for player in ['A', 'B', 'C']:
52
    value = shapley_value(player, coalition_values, all_players)
53
    print(f"{player} 的 Shapley 值: {value:.2f}")

3.2 核心解（Core Solution）#

定义：一种收益分配方案，使得任何子联盟都没有动机脱离大联盟。

\text{Core} = \left\{ x \in \mathbb{R}^n : \sum_{i \in N} x_i = v(N), \sum_{i \in S} x_i \geq v(S), \forall S \subseteq N \right\}

1
from scipy.optimize import linprog
2

3
def find_core_allocation(coalition_values, all_players):
4
    """
5
    寻找核心解（使用线性规划）
6
    """
7
    n = len(all_players)
8
    players = list(all_players)
9

10
    # 目标：随机找一个核心解（这里用最小化差异）
11
    c = [1] * n  # 最小化总分配
12

13
    # 约束1：总和 = v(N)
14
    A_eq = [[1] * n]
15
    b_eq = [coalition_values[all_players]]
16

17
    # 约束2：每个子联盟的分配 >= v(S)
18
    A_ub = []
19
    b_ub = []
20

21
    for r in range(1, n):
22
        for subset in combinations(players, r):
23
            S = frozenset(subset)
24
            constraint = [-1 if p in subset else 0 for p in players]
25
            A_ub.append(constraint)
26
            b_ub.append(-coalition_values[S])
27

28
    # 求解
29
    result = linprog(c, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq)
30

31
    if result.success:
32
        return dict(zip(players, result.x))
33
    else:
34
        return None  # 核心解不存在
35

36
# 使用
37
allocation = find_core_allocation(coalition_values, all_players)
38
if allocation:
39
    print("核心解分配：")
40
    for player, value in allocation.items():
41
        print(f"{player}: {value:.2f}")
42
else:
43
    print("核心解不存在（可能导致联盟不稳定）")

3.3 动态联盟形成#

1
class DynamicCoalitionGame:
2
    def __init__(self, players, coalition_values):
3
        self.players = players
4
        self.coalition_values = coalition_values
5
        self.current_coalitions = {frozenset([p]) for p in players}  # 初始各自独立
6

7
    def should_merge(self, coalition1, coalition2):
8
        """判断两个联盟是否应该合并"""
9
        merged = coalition1 | coalition2
10

11
        # 计算合并的收益
12
        merged_value = self.coalition_values[merged]
13
        separate_value = self.coalition_values[coalition1] + self.coalition_values[coalition2]
14

15
        # 如果合并收益更高，且能公平分配
16
        if merged_value > separate_value:
17
            # 检查是否存在核心解
18
            return self.has_fair_allocation(merged)
19

20
        return False
21

22
    def has_fair_allocation(self, coalition):
23
        """检查联盟是否有公平的收益分配"""
24
        # 简化版：使用 Shapley 值判断
25
        shapley_sum = sum([
26
            shapley_value(p, self.coalition_values, coalition)
27
            for p in coalition
28
        ])
29

30
        return abs(shapley_sum - self.coalition_values[coalition]) < 1e-6
31

32
    def evolve_coalitions(self, rounds=10):
33
        """联盟动态演化"""
34
        for round_num in range(rounds):
35
            print(f"\n=== Round {round_num + 1} ===")
36
            print(f"当前联盟: {self.current_coalitions}")
37

38
            # 尝试所有可能的合并
39
            best_merge = None
40
            best_gain = 0
41

42
            coalitions_list = list(self.current_coalitions)
43
            for i in range(len(coalitions_list)):
44
                for j in range(i + 1, len(coalitions_list)):
45
                    c1, c2 = coalitions_list[i], coalitions_list[j]
46

47
                    if self.should_merge(c1, c2):
48
                        gain = (
49
                            self.coalition_values[c1 | c2] -
50
                            self.coalition_values[c1] -
51
                            self.coalition_values[c2]
52
                        )
53
                        if gain > best_gain:
54
                            best_gain = gain
55
                            best_merge = (c1, c2)
56

57
            # 执行最佳合并
58
            if best_merge:
59
                c1, c2 = best_merge
60
                self.current_coalitions.remove(c1)
61
                self.current_coalitions.remove(c2)
62
                self.current_coalitions.add(c1 | c2)
63
                print(f"合并: {c1} + {c2} = {c1 | c2}, 增益: {best_gain:.2f}")
64
            else:
65
                print("没有有益的合并，联盟稳定")
66
                break
67

68
        return self.current_coalitions
69

70
# 使用
71
game = DynamicCoalitionGame(
72
    players=['A', 'B', 'C', 'D'],
73
    coalition_values={
74
        frozenset(): 0,
75
        frozenset(['A']): 10,
76
        frozenset(['B']): 10,
77
        frozenset(['C']): 10,
78
        frozenset(['D']): 10,
79
        frozenset(['A', 'B']): 30,
80
        frozenset(['C', 'D']): 25,
81
        frozenset(['A', 'B', 'C']): 50,
82
        frozenset(['A', 'B', 'D']): 48,
83
        frozenset(['A', 'B', 'C', 'D']): 70
84
    }
85
)
86

87
final_coalitions = game.evolve_coalitions()
88
print(f"\n最终联盟: {final_coalitions}")

四、实战案例#

4.1 三国杀 AI#

游戏特点：

3-8 人，身份隐藏（主公、忠臣、反贼、内奸）
联盟动态变化（反贼联合对抗主公）
信息不完全（不知道其他人身份）

1
class SanguoshaAI:
2
    def __init__(self, my_identity, visible_identities):
3
        self.my_identity = my_identity  # '主公', '忠臣', '反贼', '内奸'
4
        self.visible_identities = visible_identities
5

6
    def evaluate_threat(self, player):
7
        """评估威胁等级"""
8
        if self.my_identity == '主公':
9
            # 主公视角：反贼 > 内奸 > 忠臣
10
            if player.suspected_identity == '反贼':
11
                return 10
12
            elif player.suspected_identity == '内奸':
13
                return 5
14
            else:
15
                return 0
16

17
        elif self.my_identity == '反贼':
18
            # 反贼视角：主公 > 忠臣 > 内奸
19
            if player.is_lord:
20
                return 10
21
            elif player.suspected_identity == '忠臣':
22
                return 7
23
            else:
24
                return 3
25

26
        elif self.my_identity == '内奸':
27
            # 内奸视角：保持平衡，清除威胁最大的
28
            # 前期帮反贼削弱主公，后期收割
29
            if self.game_phase == 'early':
30
                if player.is_lord:
31
                    return 5
32
            else:
33
                return player.current_hp  # 血量高的威胁大
34

35
    def choose_target(self, possible_targets):
36
        """选择攻击目标"""
37
        # 综合考虑：威胁等级、血量、手牌数、距离
38
        scores = []
39

40
        for target in possible_targets:
41
            score = 0
42

43
            # 威胁等级
44
            score += self.evaluate_threat(target) * 10
45

46
            # 血量（优先击杀残血）
47
            if target.hp <= 2:
48
                score += 20
49

50
            # 防御能力
51
            score -= len(target.armor) * 5
52

53
            # 合作关系（避免误伤盟友）
54
            if self.is_ally(target):
55
                score -= 100
56

57
            scores.append((score, target))
58

59
        return max(scores, key=lambda x: x[0])[1]
60

61
    def is_ally(self, player):
62
        """判断是否是盟友"""
63
        if self.my_identity == '主公':
64
            return player.suspected_identity == '忠臣'
65
        elif self.my_identity == '忠臣':
66
            return player.is_lord
67
        elif self.my_identity == '反贼':
68
            return player.suspected_identity == '反贼'
69
        else:  # 内奸
70
            return False  # 内奸无盟友

4.2 狼人杀 AI#

游戏特点：

信息极度不对称
需要推理、欺骗、说服
投票机制

1
class WerewolfAI:
2
    def __init__(self, role):
3
        self.role = role  # '狼人', '村民', '预言家', '女巫'
4
        self.beliefs = {}  # 对每个玩家身份的信念
5

6
    def update_beliefs(self, observations):
7
        """根据观察更新信念"""
8
        for player, action in observations:
9
            if action == '跳预言家':
10
                # 贝叶斯更新
11
                if player not in self.beliefs:
12
                    self.beliefs[player] = {'预言家': 0.5, '狼人': 0.3, '村民': 0.2}
13
                else:
14
                    # 如果已经有人跳预言家，这个人可能是狼人
15
                    if any(b.get('预言家', 0) > 0.5 for b in self.beliefs.values()):
16
                        self.beliefs[player]['狼人'] += 0.3
17
                    else:
18
                        self.beliefs[player]['预言家'] += 0.3
19

20
    def vote(self, candidates):
21
        """投票决策"""
22
        if self.role == '狼人':
23
            # 狼人：投票给威胁最大的神职
24
            threat_scores = []
25
            for player in candidates:
26
                threat = 0
27
                if self.beliefs.get(player, {}).get('预言家', 0) > 0.5:
28
                    threat = 10
29
                elif self.beliefs.get(player, {}).get('女巫', 0) > 0.5:
30
                    threat = 8
31
                threat_scores.append((threat, player))
32

33
            return max(threat_scores, key=lambda x: x[0])[1]
34

35
        else:  # 好人
36
            # 投票给最可能是狼人的
37
            wolf_probs = []
38
            for player in candidates:
39
                prob = self.beliefs.get(player, {}).get('狼人', 0)
40
                wolf_probs.append((prob, player))
41

42
            return max(wolf_probs, key=lambda x: x[0])[1]
43

44
    def speak(self, phase):
45
        """发言策略"""
46
        if self.role == '狼人':
47
            return self.wolf_speak_strategy(phase)
48
        elif self.role == '预言家':
49
            return self.seer_speak_strategy(phase)
50
        else:
51
            return self.villager_speak_strategy(phase)
52

53
    def wolf_speak_strategy(self, phase):
54
        """狼人发言策略"""
55
        if phase == 'early':
56
            # 前期低调，不暴露身份
57
            return "我是村民，没有特殊信息"
58
        elif phase == 'mid':
59
            # 中期带节奏，质疑真预言家
60
            return "我怀疑 X 号玩家是假预言家"
61
        else:
62
            # 后期反击
63
            return "根据逻辑推理，Y 号玩家一定是狼"

4.3 德州扑克多人策略#

1
class TexasHoldemMultiplayer:
2
    def __init__(self, num_players):
3
        self.num_players = num_players
4

5
    def compute_nash_equilibrium(self, game_state):
6
        """计算纳什均衡策略"""
7
        # 使用 Counterfactual Regret Minimization (CFR)
8
        # 简化版：只考虑当前轮
9
        pass
10

11
    def adjust_for_position(self, strategy, position, num_active):
12
        """根据位置调整策略"""
13
        # 按钮位置（最后行动）：更激进
14
        # 盲注位置（先行动）：更保守
15

16
        if position == num_active - 1:  # 按钮位置
17
            strategy['raise_prob'] *= 1.5
18
            strategy['bluff_prob'] *= 1.3
19
        elif position < 2:  # 盲注位置
20
            strategy['fold_prob'] *= 1.2
21
            strategy['raise_prob'] *= 0.8
22

23
        return strategy
24

25
    def exploit_weaknesses(self, opponent_models):
26
        """利用对手弱点"""
27
        exploits = []
28

29
        for opponent in opponent_models:
30
            if opponent['fold_freq'] > 0.7:
31
                # 对手容易弃牌 → 多诈唬
32
                exploits.append(('bluff_more', opponent['id']))
33
            elif opponent['call_freq'] > 0.6:
34
                # 对手爱跟注 → 少诈唬，有牌就下重注
35
                exploits.append(('value_bet', opponent['id']))
36

37
        return exploits

五、高级技巧#

5.1 对手建模（Opponent Modeling）#

1
class OpponentModel:
2
    def __init__(self, player_id):
3
        self.player_id = player_id
4
        self.action_history = []
5
        self.strategy_distribution = None
6

7
    def update(self, state, action):
8
        """更新对手模型"""
9
        self.action_history.append((state, action))
10

11
        # 使用贝叶斯推理更新策略分布
12
        self.strategy_distribution = self.infer_strategy()
13

14
    def infer_strategy(self):
15
        """推断对手的策略"""
16
        # 统计对手在不同情况下的行为
17
        strategy = {
18
            'aggressive': 0,
19
            'conservative': 0,
20
            'balanced': 0
21
        }
22

23
        for state, action in self.action_history:
24
            if action.is_aggressive:
25
                strategy['aggressive'] += 1
26
            elif action.is_conservative:
27
                strategy['conservative'] += 1
28
            else:
29
                strategy['balanced'] += 1
30

31
        # 归一化
32
        total = sum(strategy.values())
33
        return {k: v / total for k, v in strategy.items()}
34

35
    def predict_action(self, state):
36
        """预测对手的行为"""
37
        if self.strategy_distribution['aggressive'] > 0.5:
38
            return self.simulate_aggressive_action(state)
39
        elif self.strategy_distribution['conservative'] > 0.5:
40
            return self.simulate_conservative_action(state)
41
        else:
42
            return self.simulate_balanced_action(state)

5.2 元博弈（Meta-Game）#

1
class MetaGameAI:
2
    """考虑对手也在建模你的 AI"""
3

4
    def __init__(self):
5
        self.level = 2  # 思考层级：我知道你知道我知道...
6

7
    def level_k_reasoning(self, state, k):
8
        """k 层推理"""
9
        if k == 0:
10
            # Level-0: 随机或简单策略
11
            return random.choice(state.legal_moves())
12

13
        # Level-k: 假设对手是 Level-(k-1)
14
        opponent_action = self.level_k_reasoning(state, k - 1)
15

16
        # 找到对 Level-(k-1) 对手的最佳响应
17
        best_response = self.best_response_to(state, opponent_action)
18

19
        return best_response
20

21
    def mixed_strategy(self, pure_strategies, weights):
22
        """混合策略（防止被预测）"""
23
        return random.choices(pure_strategies, weights=weights)[0]

六、总结#

多人博弈 AI 设计要点：

算法选择：
- 领先时：Paranoid（防守）
- 均势时：MaxN（平衡）
- 落后时：进攻策略 + 联盟
联盟策略：
- 使用 Shapley 值评估贡献
- 寻找核心解保证稳定
- 动态调整联盟
信息处理：
- 对手建模（贝叶斯更新）
- 信息隐藏（混合策略）
- 欺骗与识破
实战技巧：
- 位置优势利用
- 利用对手弱点
- 元博弈思维

推荐学习路径：

实现 Paranoid 和 MaxN
学习博弈论基础（纳什均衡、Shapley 值）
实践简单的多人游戏（如三人井字棋）
进阶到不完全信息游戏（狼人杀、德州扑克）

参考资源#

论文：

书籍：

《Game Theory: Analysis of Conflict》- Roger Myerson
《Multiagent Systems》- Yoav Shoham & Kevin Leyton-Brown

代码：

OpenSpiel - 多人博弈研究框架
Pluribus - 六人德州扑克 AI

游戏：

三国杀 - 隐藏身份 + 联盟
狼人杀 - 推理 + 欺骗
卡坦岛 - 资源谈判 + 联盟
Diplomacy - 纯外交博弈