不同博弈情景下策略选择的最优化探索

一：鹰鸽博弈

鹰鸽博弈是博弈论中的一个经典模型，以下是对鹰鸽博弈的具体介绍：

基本策略和行为模式：

鹰策略：代表着激进、好斗、具有攻击性的行为方式。在博弈中，选择鹰策略的个体在面对竞争或冲突时会全力以赴、坚决斗争，不轻易退缩，直到取得胜利或者给对手造成重大伤害。这种策略往往需要付出较高的成本，比如在战斗中可能会受伤，但如果获胜，就能获得较高的收益。

鸽策略：象征着温和、妥协、非攻击性的行为方式。选择鸽策略的个体在遇到竞争或冲突时，通常会选择避免正面冲突，以和平的方式解决问题，或者选择退让、分享资源。鸽策略的成本相对较低，因为可以避免激烈的战斗和受伤的风险，但获得的收益也相对较少。

收益情况：

当两只鹰相遇时，它们会进行激烈的战斗，由于战斗会带来两败俱伤的结果，所以双方的收益都是负的（比如假定为 - 2）。

当两只鸽子相遇时，它们会共同分享资源，各自获得一定的收益（比如假定为 1）。

当鹰和鸽子相遇时，鸽子会逃走，鹰将独自获得全部资源，鹰的收益较高（比如假定为 2）。

在这个博弈中，玩家可以选择扮演鹰（攻击型）或鸽（和平型）。鹰会争夺资源，但可能受伤；鸽则避免战斗，但可能无法获得资源。

import numpy as np# 博弈矩阵
payoff_matrix = np.array([[-2, 2], [1, 1]])# 策略选择函数
def choose_strategy(payoff_matrix, strategy):if strategy == "hawk":return np.argmax(payoff_matrix[0])elif strategy == "dove":return np.argmax(payoff_matrix[1])# 模拟博弈
strategy1 = "hawk"
strategy2 = "dove"
result1 = choose_strategy(payoff_matrix, strategy1)
result2 = choose_strategy(payoff_matrix, strategy2)print(f"玩家1选择：{strategy1}, 玩家2选择：{strategy2}")
print(f"玩家1的收益：{payoff_matrix[0][result2]}, 玩家2的收益：{payoff_matrix[1][result1]}")

以下是对代码的详细解释：

1：定义博弈矩阵

import numpy as np
payoff_matrix = np.array([[-2, 2], [1, 1]])

这里创建了一个新的二维 numpy 数组作为博弈矩阵。

矩阵的第一行 [-2, 2] 代表当玩家 1 选择鹰策略（hawk）时，分别对应玩家 2 选择鹰策略和鸽策略（dove）时玩家 1 的收益。即两只鹰相遇时玩家 1 收益为 -2，鹰和鸽子相遇时玩家 1 收益为 2。
矩阵的第二行 [1, 1] 代表当玩家 1 选择鸽策略时，分别对应玩家 2 选择鹰策略和鸽策略时玩家 1 的收益。即鸽子和鹰相遇时玩家 1 收益为 1，两只鸽子相遇时玩家 1 收益也为 1。

2：定义策略选择函数

def choose_strategy(payoff_matrix, strategy):if strategy == "hawk":return np.argmax(payoff_matrix[0])elif strategy == "dove":return np.argmax(payoff_matrix[1])

这个函数用于根据给定的策略和博弈矩阵，确定该策略下的最优行动（即对应收益最大的列）。

如果传入的策略是 "hawk"，则在博弈矩阵的第一行中找到收益最大的列索引并返回。这是因为第一行代表玩家选择鹰策略时在不同对手策略下的收益。
如果传入的策略是 "dove"，则在博弈矩阵的第二行中找到收益最大的列索引并返回。第二行代表玩家选择鸽策略时在不同对手策略下的收益。

3：模拟博弈

strategy1 = "hawk"
strategy2 = "dove"
result1 = choose_strategy(payoff_matrix, strategy1)
result2 = choose_strategy(payoff_matrix, strategy2)

这里模拟了一次博弈过程。

首先定义两个策略变量 strategy1 和 strategy2，分别表示玩家 1 和玩家 2 的策略，这里玩家 1 选择鹰策略，玩家 2 选择鸽策略。
然后调用 choose_strategy 函数，根据玩家 1 的策略和博弈矩阵确定玩家 1 在该策略下的最优行动，并将结果存储在 result1 中。同样，对玩家 2 进行相同操作，结果存储在 result2 中。

print(f"玩家1选择：{strategy1}, 玩家2选择：{strategy2}")
print(f"玩家1的收益：{payoff_matrix[0][result2]}, 玩家2的收益：{payoff_matrix[1][result1]}")

最后，打印出玩家 1 和玩家 2 的选择以及各自的收益。

payoff_matrix[0][result2] 表示玩家 1（鹰策略）在玩家 2 的行动（由 result2 确定）下的收益。
payoff_matrix[1][result1] 表示玩家 2（鸽策略）在玩家 1 的行动（由 result1 确定）下的收益。

结果如下：

可以看出在玩家均理性的假设的情况下，鸽策略收益较鹰策略收益更高。

也可以依照这个过程重复博弈过程进行模拟。

二：骑士博弈

在这个博弈中，玩家分为骑士和盗贼两个阵营。骑士的目标是抓住盗贼，而盗贼的目标是避开骑士。接下来的这段代码模拟了一个骑士抓盗贼的博弈场景。骑士和盗贼在一个二维的坐标空间中活动：

import random# 骑士和盗贼的位置
knight_position = [0, 0]
robber_position = [random.randint(0, 10), random.randint(0, 10)]# 骑士移动函数
def move_knight(knight_position, robber_position):dx = robber_position[0] - knight_position[0]dy = robber_position[1] - knight_position[1]if abs(dx) > abs(dy):knight_position[0] += 1 if dx > 0 else -1else:knight_position[1] += 1 if dy > 0 else -1return knight_position# 盗贼移动函数
def move_robber(robber_position):robber_position[0] += random.choice([-1, 0, 1])robber_position[1] += random.choice([-1, 0, 1])return robber_position# 模拟博弈
for _ in range(10):knight_position = move_knight(knight_position, robber_position)robber_position = move_robber(robber_position)if knight_position == robber_position:print("骑士抓住了盗贼！")breakprint(f"骑士位置：{knight_position}, 盗贼位置：{robber_position}")

结果如下：

具体元素和行为解释：

1：骑士和盗贼的位置初始化

knight_position = [0, 0]：骑士初始位置在坐标原点。

robber_position = [random.randint(0, 10), random.randint(0, 10)]：盗贼的初始位置在一个 10x10 的二维空间中随机生成。

2：骑士的移动策略

骑士总是朝着盗贼的方向移动。

在 move_knight 函数中，通过计算骑士与盗贼在 x 和 y 方向上的距离差（dx 和 dy）来决定移动方向。

如果 x 方向上的距离差绝对值大于 y 方向上的距离差绝对值，骑士会在 x 方向上移动一步（如果盗贼在骑士右边，即 dx > 0，则向右移动一步，即 knight_position[0] += 1，否则向左移动一步）。

如果 y 方向上的距离差绝对值更大，骑士会在 y 方向上移动一步，同样根据盗贼的相对位置决定向上（dy > 0时）还是向下移动。

3：盗贼的移动策略

在 move_robber 函数中，盗贼随机地在 x 和 y 方向上移动一步、原地不动或向反方向移动一步。具体通过随机选择 -1、0、1 来分别对应向负方向移动、原地不动和向正方向移动，并更新盗贼的位置。

4：模拟博弈过程

通过一个循环进行模拟，循环次数为 10 次。在每次循环中，骑士和盗贼分别移动。检查骑士和盗贼的位置是否相同，如果相同，则表示骑士抓住了盗贼，打印相应信息并退出循环。如果在 10 次循环内骑士没有抓住盗贼，则循环结束后程序也会停止，没有其他输出结果。

三：石头剪刀布

石头剪刀布博弈介绍：

这是一个简单的双人博弈游戏，双方各自从石头、剪刀、布三种选项中选择一种。石头胜剪刀，剪刀胜布，布胜石头。接下来将实现一个简单的“石头、剪刀、布”游戏模拟，并通过多次模拟来统计玩家1、玩家2的胜利次数以及平局的次数，最终探究玩家1胜，玩家2胜和平局各自的概率分布。

import random
import matplotlib.pyplot as plt
import numpy as np# 定义可能的选择
choices = ['石头', '剪刀', '布']# 判断胜负的函数
def determine_winner(player1_choice, player2_choice):if player1_choice == player2_choice:return "平局"elif (player1_choice == '石头' and player2_choice == '剪刀') or (player1_choice == '剪刀' and player2_choice == '布') or (player1_choice == '布' and player2_choice == '石头'):return "玩家1胜"else:return "玩家2胜"# 模拟一次游戏
def play_game():player1_choice = random.choice(choices)player2_choice = random.choice(choices)result = determine_winner(player1_choice, player2_choice)return player1_choice, player2_choice, result# 进行多次游戏并统计结果
num_games = 10000  # 增加游戏次数以提高统计的准确性
player1_wins = 0
player2_wins = 0
draws = 0
results = []for _ in range(num_games):choice1, choice2, outcome = play_game()results.append(outcome)if outcome == "玩家1胜":player1_wins += 1elif outcome == "玩家2胜":player2_wins += 1else:draws += 1# 可视化结果
labels = '玩家1胜', '玩家2胜', '平局'
sizes = [player1_wins, player2_wins, draws]
colors = ['gold', 'lightcoral', 'lightskyblue']plt.figure(figsize=(8, 8))
plt.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%', startangle=140)
plt.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.plt.show()

可视化图表如下：