如何在Java中加速minimax算法？

我想知道如何提高这个算法的速度。它适用于两个游戏（两人游戏，CPU vs Human），但问题是当我分配了三堆以上的石头（其中包含许多石头，因此每个玩家可以拾取多个石头）时，计算机玩家永远需要计算移动：

public Object[] minimax(int depth, int player) {

        if(hasPlayer1Won(player)){
            return new Object[]{get_default_input(1),1};
        }else if(hasPlayer2Won(player)){
            return new Object[]{get_default_input(1),-1};
        }
        List<T> movesAvailable = getNextStates();

        if(movesAvailable.isEmpty()){
            return new Object[]{get_default_input(0), 0};
        }
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        T computersMove = getNextStates().get(0);
        int i = 0;
        for (T move: movesAvailable) {
            makeAMove(move, player);
            Object[] result = minimax(depth + 1, player == G.PLAYER1 ? G.PLAYER2 : G.PLAYER1);
            int currentScore = (int)result[1];

            if(player == G.PLAYER1){
                max = Math.max(currentScore, max);

                if(currentScore >= 0 && depth == 0) {
                    computersMove = move;
                }
                if(currentScore == 1){
                    resetMove(move);
                    break;
                }
                if(i==movesAvailable.size() - 1  && max < 0){
                    if (depth == 0){
                        computersMove = move;
                    }
                }
            }else{
                min = Math.min(currentScore, min);
                if(min == -1) {
                    resetMove(move);
                    break;
                }
            }
            i++;
            resetMove(move);
        }

        return new Object[]{computersMove, player == G.PLAYER1 ? max: min};
    }

public Object[]minimax（int-depth，int-player）{
如果（hasPlayer1Won（玩家））{
返回新对象[]{get_default_input（1），1}；
}否则如果（hasPlayer2Won（玩家））{
返回新对象[]{get_default_input（1），-1}；
}
List movesavaailable=getNextStates（）；
if（movesavaailable.isEmpty（））{
返回新对象[]{get_default_input（0），0}；
}
int min=整数最大值；
int max=整数的最小值；
T computersMove=getNextStates（）.get（0）；
int i=0；
对于（T移动：移动可用）{
makeAMove（移动，玩家）；
Object[]result=minimax（深度+1，玩家==G.PLAYER1？G.PLAYER2:G.PLAYER1）；
int currentScore=（int）结果[1]；
如果（玩家==G.PLAYER1）{
max=数学max（当前分数，max）；
如果（currentScore>=0&&depth==0）{
计算机移动=移动；
}
如果（currentScore==1）{
重置移动（移动）；
打破
}
如果（i==movesavaailable.size（）-1&&max<0）{
如果（深度==0）{
计算机移动=移动；
}
}
}否则{
最小值=数学最小值（当前分数，最小值）；
如果（最小==-1）{
重置移动（移动）；
打破
}
}
i++；
重置移动（移动）；
}
返回新对象[]{computersMove，player==G.PLAYER1？max:min}；
}

我成功地测试了以下改进minimax的方法（用它来玩Tic-Tac-Toe和霸道游戏）：

-使用了这种修剪类型的特殊变体，与-基本上没有生成整个树，我只是在每一层上生成了一个最佳移动，并为其他状态-动作对保留了惰性持有者（应用惰性评估方法，通过使用供应商并在做出与我持有的不同的举动时调用它）

-参见那本书中关于启发式的章节。我基本上只生成了树的前d个分支，没有确定结果，而是将那本书中描述的启发式函数应用于当前状态以确定启发式结果。每当移动（d+1）在创建时，我使用相同的方法生成了另一个分支。 这里，d是您选择的级别（最安全的方法是通过测试）

也看看这个，你可能会发现它很难实现，但它是值得的

---

前两个选项为我节省了大量计算时间，因此我可以在5x5板上玩霸道游戏，在10x10板上玩启发式游戏（这可能更好，取决于你希望它玩得多好）.

你知道吗？改进极大极小算法的经典方法是使用alpha-beta修剪OK问题，但“永远”有多长？