Java 极大极小算法的一个非常有趣的问题。什么会导致这种行为？

我用alpha-beta剪枝实现了MiniMax算法，但是它的行为方式很有趣。我的球员将创造一个巨大的领先优势，但当它是时间作出最后的，获胜的举动，它不采取这一举动，只是不断拖延比赛

这是我的minimax函数：

// Game states are represented by Node objects (holds the move and the board in that state)
//ValueStep is just a pair holding the minimax value and a game move (step) 

private ValueStep minimax(Node gameState,int depth,int alpha,int beta) {

  //Node.MAXDEPTH is a constant
  if(depth == Node.MAXDEPTH || gameOver(gameState.board)) {
      return new ValueStep(gameState.heuristicValue(),gameState.step);
  }

  //this method definately works. child nodes are created with a move and an 
  //updated board and MAX value
  //which determines if they are the maximizing or minimizing players game states.
  gameState.children = gameState.findPossibleStates();

  if(state.MAX) { //maximizing player
      ValueStep best = null;

      for(Node child: gameState.children) {

          ValueStep vs = new ValueStep(minimax(child,depth+1,alpha,beta).value,child.move);

          //values updated here if needed
          if(best==null || vs.value > best.value) best = vs;

          if(vs.value > alpha) alpha = vs.value;

          if(alpha >= beta) break;
      }

      return best;

  } else { //minimizing player
      ValueStep best = null;

      for(Node child: gameState.children) {

          ValueStep vs = new ValueStep(minimax(child,depth+1,alfa,beta).value,child.move);

          if(best==null || vs.value < best.value) best = vs;

          if(vs.value < beta) beta = vs.value;

          if(alpha >= beta) break;
      }

      return best;
  }

我已经把代码翻译成了英语，所以可能会有拼写错误。我相当肯定问题在这里的某个地方，但如果你需要一些其他代码，那么我会更新问题。同样，我的球员可以创造优势，但由于某种原因，他不会做出最后的胜利举动。

---

我感谢你的帮助

假设你的Minimax玩家处于一个可以证明它可以保证胜利的位置。通常会有许多不同的方式来保证最终的胜利。有些招式可能是即时胜利，有些招式可能会不必要地拖累游戏。。。只要这不是一个真正愚蠢的举动，突然允许对手获胜或平局，他们都是赢家，他们都有相同的游戏理论值Integer.MAX_值在您的代码中

你的Minimax算法不区分这些移动，只是简单地播放你的gameState.children列表中第一个移动。这可能是一场快速、肤浅的胜利，也可能是一场缓慢、非常深刻的胜利

有两种简单的方法可以让你的Minimax算法优先考虑快赢而不是慢赢：

最好的选择是使用迭代深化，因为它还有许多其他优点。你可以查看详细信息，但基本思想是，你首先进行深度限制为1的Minimax搜索，然后进行深度限制为2的Minimax搜索，然后进行深度限制为3的Minimax搜索，以此类推。一旦你的一次搜索证明成功，你就可以终止搜索并开始获胜的一步。这将使您的算法始终倾向于最短的胜利，因为这些胜利是最先找到的。 或者，您可以修改heuristicValue函数以合并搜索深度。例如，您可以返回Integer.MAX_VALUE-获胜位置的深度。这将使更快的胜利实际上有一个稍大的评价。

---

假设你的Minimax玩家处于一个可以证明它可以保证胜利的位置。通常会有许多不同的方式来保证最终的胜利。有些招式可能是即时胜利，有些招式可能会不必要地拖累游戏。。。只要这不是一个真正愚蠢的举动，突然允许对手获胜或平局，他们都是赢家，他们都有相同的游戏理论值Integer.MAX_值在您的代码中

你的Minimax算法不区分这些移动，只是简单地播放你的gameState.children列表中第一个移动。这可能是一场快速、肤浅的胜利，也可能是一场缓慢、非常深刻的胜利

有两种简单的方法可以让你的Minimax算法优先考虑快赢而不是慢赢：

最好的选择是使用迭代深化，因为它还有许多其他优点。你可以查看详细信息，但基本思想是，你首先进行深度限制为1的Minimax搜索，然后进行深度限制为2的Minimax搜索，然后进行深度限制为3的Minimax搜索，以此类推。一旦你的一次搜索证明成功，你就可以终止搜索并开始获胜的一步。这将使您的算法始终倾向于最短的胜利，因为这些胜利是最先找到的。 或者，您可以修改heuristicValue函数以合并搜索深度。例如，您可以返回Integer.MAX_VALUE-获胜位置的深度。这将使更快的胜利实际上有一个稍大的评价。

---

我的ai在没有迭代深化的情况下是愚蠢的，因为在未来的州里，两个玩家都赢了，而且它没有线索知道谁先赢。现在是智商200。很惊讶我没早点听说！我的ai在没有迭代深化的情况下是愚蠢的，因为在未来的州里，两个玩家都赢了，而且它没有线索知道谁先赢。现在是智商200。很惊讶我没早点听说！

public int heuristicValue() {

       //I calculate the score difference here in this state and save it in 
       //the variable scoreDiff. scoreDiff will be positive if I am winning 
       //here, negative if im loosing.

        //"this" is a Node object here. If the game is over here, special
        //heuristic values are returned, depending on who wins (or if its a 
        //draw) 
        if(gameOver(this.board)) {
            if(scoreDiff>0) {
                return Integer.MAX_VALUE;  
            } else if(scoreDiff==0) {
                return 0;
            } else {
                return Integer.MIN_VALUE;
            }
        }

        int value = 0;
        value += 100*scoreDiff; //caluclate the heuristic value using the score differerence. If its high, the value will be high as well 

      return value;
  }