使用Alpha-Beta修剪的迭代深化Negamax

我的程序中有一个有效的negamax算法。然而，我需要程序在kMaxTimePerMove时间内找到最佳移动。我做了一些研究，似乎在negamax算法中使用迭代深化是最好的方法

// this is a global in the same scope as the alpha-beta functions, so they can check the elapsed time
clock_t tStart;
int IterativeDeepening(Board current_state)
{
bool overtime = false;
int depth = 0;
tStart = clock();
MoveHolder best_move(-1, kWorstEvaluation);
while ((static_cast<double> (clock() - tStart)/CLOCKS_PER_SEC) < kMaxTimePerMove)
{
MoveHolder temp_move = AlphaBetaRoot(kWorstEvaluation, -best_move.evaluation_,++depth, current_state, overtime);          
if (!overtime)
best_move = temp_move;
}
return best_move.column_;
}

我认为我也应该将之前的最佳移动重新排序到儿童列表的前面，然而，我正在等待实现它，直到我的基本版本开始工作。实际的Alpha Beta功能如下所示：

MoveHolder AlphaBetaRoot(int alpha, int beta, int remaining_depth, Board current_state, bool &overtime)
{
MoveHolder best(-1, -1);
if (overtime)
return MoveHolder(0,0);
std::vector<Board> current_children;
current_state.GetBoardChildren(current_children);
for (auto i : current_children)
{
best.evaluation_ = -AlphaBeta(-beta, -alpha, remaining_depth - 1, i, overtime);
if ((static_cast<double> (clock() - tStart)/CLOCKS_PER_SEC) > kMaxTimePerMove)
{
overtime = true;
return MoveHolder(0,0);
}
if (best.evaluation_ >= beta)
return best;
if (best.evaluation_ > alpha)
{
alpha = best.evaluation_;
best.column_ = i.GetLastMoveColumn();
}
}
return best;
}
int AlphaBeta(int alpha, int beta, int remaining_depth, Board2 current_state, bool &overtime)
{
if (overtime)
return 0;
if ((static_cast<double> (clock() - tStart)/CLOCKS_PER_SEC) > kMaxTimePerMove)
{
overtime = true;
return 0;
}
if (remaining_depth == 0 || current_state.GetCurrentResult() != kNoResult)
{
return current_state.GetToMove() * current_state.GetCurrentEvaluation();
}

std::vector<Board> current_children;
current_state.GetBoardChildren(current_children);
for (auto i : current_children)
{
int score = -AlphaBeta(-beta, -alpha, remaining_depth - 1, i, overtime);
if (score >= beta)
{
return beta;
}
if (score > alpha)
{
alpha = score;
}
}
return alpha;
}

当我尝试调试时，一切似乎都如预期的那样工作。然而，当我让迭代深化版本与常规的alpha-beta实现对抗时，它总是失败。有时，它似乎被"卡住"了，然后做出了可怕的举动。

例如，如果该程序在下一个回合"被迫"移动，否则对手将获胜，则不会阻止获胜。据报道，在这一行动中，它正在搜索到38深处。我发现算法极难调试，因为如果我中断执行，就会破坏时间。

我不确定我是错误地实现了算法，还是这里有一个棘手的错误。如果有人能为我指明正确的方向，我将不胜感激