AlphaBeta_SameFun

/*

*文件名: 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;
}