AlphaBeta_SameFun

最新推荐文章于 2025-12-31 21:25:26 发布

原创最新推荐文章于 2025-12-31 21:25:26 发布 · 662 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #class #c #im

棋类算法整理专栏收录该内容

8 篇文章

订阅专栏

本文介绍了一种基于博弈论的AB剪枝算法实现，该算法主要用于寻找最优棋步。通过定义不同玩家的价值观转换关系，文章详细阐述了如何在有限的搜索深度内找到最佳突围点或最佳防守位置。

*文件名: AB剪枝

*创建人: 陈泽丹

#pragma once
#include "SearchEngine.h"

class AlphaBeta_SameFun: public SearchEngine
{
public:
AlphaBeta_SameFun(void);
virtual ~AlphaBeta_SameFun(void);
void SearchAGoodMove();

private:
//算法功能: 寻找突围点（突围点：突破对方包围圈的可行值，若不能突围则取包围圈里的最佳值(包围圈和返回的可行值是以其结点所属的价值观为标准的))
//解题角度: 博弈双方的思路统一,而价值观不统一
//故可以某价值观(C价值观)为标准,考察AB两方与C价值观的转换关系,计算AB两方之间转换价值观转换关系
//本算法以客观世界的价值观为标准并且认为A方的价值观与标准价值观相同。
//一般默认调用方式为TransformFum_AlphaBeta(-200000,200000,3,true,0);
double TransformStruct_AlphaBeta(const int in_iAlpha, const int in_iBeta, const int in_iLeftPly,
const bool in_bCurIsAlpha, const int in_CurChessBoardID);

//把客观世界的价值观转为A方的价值观
inline int Custom_To_A(const int iCustomValue){return iCustomValue;}
//把客观世界的价值观转为B方的价值观
inline int Custom_To_B(const int iCustomValue){return -iCustomValue;}
//把A方的价值观转为客观世界的价值观
inline int A_To_Custom(const int iCustomValue){return iCustomValue;}
//把B方的价值观转为客观世界的价值观
inline int B_To_Custom(const int iCustomValue){return -iCustomValue;}
//把某方(非客观世界)的价值观转为另一方(非客观世界)的价值观
inline int ValueTransformOther(const int iValue){return -iValue;}
//把某方(非客观世界)的价值观集合转为另一方(非客观世界)的价值观集合
inline void SetTransformOther(const int in_iStart, const int in_iEnd,
  int& out_iStart, int& out_iEnd)
{
  out_iStart = -in_iEnd;
  out_iEnd = -in_iStart;
}
};

/////////////////////////////////////

#include "AlphaBeta_SameFun.h"

AlphaBeta_SameFun::AlphaBeta_SameFun(void)
{
}

AlphaBeta_SameFun::~AlphaBeta_SameFun(void)
{
}

void AlphaBeta_SameFun::SearchAGoodMove()
{
m_iNodeNum = 0;
TransformStruct_AlphaBeta(-200000,200000,m_iMaxDepth,true,0);
}

//算法功能: 寻找突围点（突围点：突破对方包围圈的可行值，若不能突围则取包围圈里的最佳值(包围圈和返回的可行值是以其结点所属的价值观为标准的))
//解题角度: 博弈双方的思路统一,而价值观不统一
//故可以某价值观(C价值观)为标准,考察AB两方与C价值观的转换关系,计算AB两方之间转换价值观转换关系
//本算法以客观世界的价值观为标准并且认为A方的价值观与标准价值观相同。
//一般默认调用方式为TransformFum_AlphaBeta(-200000,200000,3,true,0);
double AlphaBeta_SameFun::TransformStruct_AlphaBeta(const int in_iAlpha, const int in_iBeta, const int in_iLeftPly,
  const bool in_bCurIsAlpha, const int in_CurChessBoardID)
{
m_iNodeNum++;
if( 0 == in_iLeftPly)
{
  int iCustomValue = 0;
  m_pcmtMove->GetItemData(in_CurChessBoardID, iCustomValue);
  if( in_bCurIsAlpha)
   return Custom_To_A(iCustomValue);
  else
   return Custom_To_B(iCustomValue);
}

int iAlpha = in_iAlpha;
int iNextAlpha, iNextBeta;
for(int i=0; i<m_pcmtMove->Path(); i++)
{//搜索最好的走法
  int iChildID = 0;
  if( m_pcmtMove->GetChildID(in_CurChessBoardID, i, iChildID))
  {
   SetTransformOther(iAlpha, in_iBeta, iNextAlpha, iNextBeta);
   int iScore = ValueTransformOther(
    TransformStruct_AlphaBeta(iNextAlpha, iNextBeta, in_iLeftPly-1, !in_bCurIsAlpha,iChildID));
   if( iScore > iAlpha)
   {
    if( in_iLeftPly == m_iMaxDepth)
    {
     m_iBestID = iChildID;
     if( in_bCurIsAlpha)
      m_dBestValue = A_To_Custom(iScore);
     else
      m_dBestValue = B_To_Custom(iScore);
    }
    iAlpha = iScore; //更新当前方包围圈
    if( iAlpha >= in_iBeta)
    {//已知Beta方的包围圈(-00,iBeta],现在Alpha方的将获得的解空间[iAlpha,+00)与Beta方的解空间(-00,iBeta]无交集。
     //即是说Alpha方的当前选择必将突破Beta方的包围圈！所以不必再细搜索后面的情况了,可直接返回。
     return iAlpha;
    }
   }
  }
}
return iAlpha;
}