非合作博弈

纳什均衡点：纳什均衡点指的是在一个策略游戏中，所有参与者都选择了对自己最有利的策略，并且在已知其他参与者策略不变的情况下，没有人有动机单方面改变自己的策略。确定纳什均衡点有两种方法——（1）画线法（2）二人零和博弈可以用minmax-maxmin定理。
谢林点：判断多重纳什均衡问题中哪个均衡最有可能出现的一种规则——从各方的文化和经验中找到线索，进而判断出某个均衡出现的概率更大，这个均衡点就叫谢林点。
纯策略和混合策略：画线法找不出来纳什均衡就说明没有纯策略纳什均衡，只有混合策略纳什均衡，混合策略纳什均衡是一个分布，表示选择各个策略的概率。可以用定理——玩家选任意一种纯策略的期望收益是相同的来计算出混合策略。

合作博弈的shapley值

设表示整个合作博弈中所有参与者构成的集合，是某种合作形式，表示合作形式对应的收益值，存在唯一一个满足所有夏普利公理的函数，参与者的shapley值计算公式如下：

话不多说，看一个案例，计算A,B,C三人合作时的利益分配：

以A的利益分配值为例，B、C的利益分配值计算思路同理。首先，列举出所有可能合作形式及其对应的收益值：

S	A	B	C	AB	AC	BC	ABC
	10	10	10	70	50	40	100

然后在每种包含的合作形式下计算：

在合作形式A中：
在合作形式A,B中：
在合作形式A,C中：
在合作形式A,B,C中：

得到A,B,C三人合作时A的利益分配值：。

shapley值计算
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Date    : 2025-10-22 15:54:36
# @Author  : syuansheng (Dalian Maritime University)

"""
实现了合作博弈理论中shapley值的计算
"""

from typing import List,Set
from itertools import combinations
from math import factorial

class CollaborationGroup(set):
  """
  某个特定的合作组，要实现以下功能：
  1. 能够方便的访问修改合作组的总利益值
  2. 能够进行差运算，要支持两个CollaborationGroup对象之间的比较，即只要包含的元素相同就认为是同一个CollaborationGroup
  """
  def __init__(self,players=set()):
    super(CollaborationGroup,self).__init__(players) # 调用父类set完成初始化
    self.value = 0 # 合作组的总利益值
    self.num = len(players) # 合作组的玩家人数

class CollaborationGroupList(list):
  """
  包含所有可能的合作形式的列表，要实现如下功能：
  1. 输入players数，自动生成所有可能的合作组CollaborationGroup对象
  2. 任意数量的位置参数能够访问到对应的CollaborationGroup对象，类似与tupledict的select方法
  3. 输入指定player，得到包含这个player的所有合作组对象CollaborationGroup的列表
  """
  def __init__(self,player_num):
    super(CollaborationGroupList,self).__init__([])
    self._initiate(player_num)

  def _initiate(self,player_num):
    """
    生成所有可能的合作组对应的CollaborationGroup对象
    """
    player_groups = [subset for el_num in range(player_num+1) for subset in combinations(range(player_num),el_num)]
    for player_group in player_groups:
      self.append(CollaborationGroup(player_group))

  def select(self,*args):
    """
    查找包含指定player的CollaborationGroup
    """
    cg_ = CollaborationGroup(args)
    for cg in self:
      if cg == cg_:
        return cg 

  def selectByCollaborationGroup(self,cg_):
    for cg in self:
      if cg == cg_:
        return cg

  def getAllCollaborationGroupContains(self,player):
    cglst = [cg for cg in self if player in cg]
    return cglst


def shapley(playermap,cglst):
  """
  计算各个玩家的shapley值
  """
  player_num = len(playermap) # 玩家人数
  share_value_lst = []
  for i in range(player_num):
    # 计算玩家i的shapley值
    all_cg_groups_contains_i = cglst.getAllCollaborationGroupContains(i) # 所有包含玩家i的合作组的列表
    share_value = 0 # 玩家i的shapley值
    for cg_groups_contain_i in all_cg_groups_contains_i:
      share_value += \
      factorial(player_num-cg_groups_contain_i.num)*factorial(cg_groups_contain_i.num-1)\
      /(factorial(player_num))*(cg_groups_contain_i.value-cglst.selectByCollaborationGroup(cg_groups_contain_i-set([i])).value)
    share_value_lst.append(share_value)
  for i,share_value in enumerate(share_value_lst):
    print('{}的shapley值是{}'.format(playermap[i],share_value))
  return share_value_lst


if __name__ == '__main__':
  # 初始化：生成所有合作组，并设置其利益值
  cglst = CollaborationGroupList(3)
  cglst.select(0).value = 10
  cglst.select(1).value = 10
  cglst.select(2).value = 10
  cglst.select(0,1).value = 70
  cglst.select(0,2).value = 50
  cglst.select(1,2).value = 40
  cglst.select(0,1,2).value = 100 
  # print(cglst.select(1,2)-cglst.select(1)) # {2}
  # print(cglst.selectByCollaborationGroup(cglst.select(1,2)-cglst.select(1)).value) # 10
  # 计算shapley值
  playermap = {0:"玩家A",1:"玩家B",2:"玩家C"}
  share_value_lst = shapley(playermap,cglst)