Java 连接四的最小最大值

我正在尝试实现一个minmax算法来为connectfour创建一个AI。我在这方面遇到了不少麻烦，因为我觉得我把事情搞得太复杂了（而且它不能正常工作），也许这里有人可以帮忙。我将首先发布我的代码，然后在下面发布我遇到的问题

这是对minmax算法的初始调用

public int getColumnForMove(ConnectFour game) 
{
    game.minimax(2, game.getCurrentPlayer(), game);
    int column = game.getBestMove();
    return column;
}

这是被调用的初始minimax方法（它在ConnectFour类中，而ConnectFour类不是调用初始方法的地方，而是在一个单独的AI类中）和一个子类，该子类保存用户移动到的每一列以及移动到该列时的最小/最大分数

class ColumnsAndScores
{
    int column;
    int score;

    ColumnsAndScores(int column, int score)
    {
        this.column = column;
        this.score = score;
    }

}

List<ColumnsAndScores> cas = new ArrayList<>();

public void minimax(int depth, int turn, ConnectFour game)
{
    cas = new ArrayList<>();
    minimaxHelper(depth, depth, turn, game);
}

class列和分数
{
int列；
智力得分；
列和分数（整数列，整数分数）
{
this.column=列；
这个分数=分数；
}
}
List cas=new ArrayList（）；
公共空间极小极大（整数深度，整数转弯，四局）
{
cas=新的ArrayList（）；
minimaxHelper（深度、深度、回合、游戏）；
}

以下是从每组可能动作中获得最小或最大分数的方法：

public int getMax(List<Integer> list)
{
    int max = Integer.MIN_VALUE;
    int index = -1;

    for (int i = 0; i < list.size(); i++)
    {
        if (list.get(i) > max)
        {
            max = list.get(i);
            index = i;
        }
    }

    return list.get(index);
}

public int getMin(List<Integer> list)
{
    int min = Integer.MAX_VALUE;
    int index = -1;

    for (int i = 0; i < list.size(); i++)
    {
        if (list.get(i) < min)
        {
            min = list.get(i);
            index = i;
        }
    }

    return list.get(index);
}

public int getMax（列表）
{
int max=整数的最小值；
int指数=-1；
对于（int i=0；i最大值）
{
max=list.get（i）；
指数=i；
}
}
返回列表。获取（索引）；
}
公共int getMin（列表）
{
int min=整数最大值；
int指数=-1；
对于（int i=0；i

这是实际的minimax方法（它有一堆注释掉的代码，显示它应该返回一系列值，这取决于董事会的好坏，如果它不是一个明确的赢家或输家，但现在我只是试图让它根据赢家或输家做出决定（如果在请求的深度中没有任何一个发生，它会随机移动））

public int minimaxHelper（int-originalDepth，int-depth，int-turn，ConnectFour游戏）
{   
//保持未来的游戏状态
连接四个未来的游戏状态；
//保持当前分数
列表分数=新的ArrayList（）；
//如果（不是在最低深度）
如果（深度！=0）
{
如果（checkForWin（回合））
{
//根据轮到谁返回Integer.MAX\u值或Integer.MIN\u值
返回（回合%2==0）？Integer.MAX\u值：Integer.MIN\u值；
}
//如果列未满，则递归调用每列的getColumnForMove（深度--，otherTurn）
对于（int i=1；i我只想解决一个问题。你应该尽量避免每个问题有太多的问题，并在这里包含与你的问题相关的代码，比如你的ConnectFour类

如果你想复制一份董事会，你可以在不改变原件的情况下进行修改，你需要复制一份，而不是一份参考资料。要复制一份你房子的浅显副本，你需要复制一份你房子的钥匙。如果你把钥匙给了别人，你回家后看到的变化不应该让你感到惊讶。要复制一份你房子的深层副本，你需要一份seco根据你房子的蓝图和照片进行批地并建造新房子。如果你把新房子的钥匙交给某人，他/她可能不会立即注意到区别，但任何更改都不会直接影响你，你所做的更改也不会影响收件人

“深度复制”实际上是不明确的，因为您的对象可能包含具有对象成员的对象成员。在创建深度副本时，您必须决定是创建任何成员对象的深度副本还是浅层副本。如果ConnectFour类包含移动对象的ArrayList，其中每个对象都是表示列的int的包装器，则您有3个c选择：


可以将引用复制到ArrayList
可以使用对同一组移动的引用创建新的ArrayList
您可以使用移动副本的引用创建新的ArrayList

无论如何，我猜您还没有嵌套的成员对象，因此您的deep copy方法可以如下所示：

public class ConnectFour{
    private int[][] board = new int[6][7];

    public setCurrentGameState(int[][] state){ 
        for(int i = 0; i<6; i++)
            for(int j=0; j<7; j++)
                board[i][j] = state[i][j];
    }
    ...

公共类{
专用int[][]板=新int[6][7]；
公共setCurrentGameState（int[][]状态）{
对于（int i=0；i问题很可能是由
ConnectFour
的实现引起的，类似

private int[][] state;
public void setCurrentGameState(int[][] newState) {
    this.state = newState;
}

这没关系，但会导致游戏状态的“副本”实际引用相同的
int[][]状态
，因此对它的任何修改都将应用于这两种状态

public class ConnectFour implements Cloneable<ConnectFour> {
    private static final int NUM_ROWS = 6;
    private static final int NUM_COLS = 7;
    private int[][] state = new int[NUM_ROWS][NUM_COLS];
    // ...
    public ConnectFour clone() {
        int[][] stateCopy = new int[NUM_ROWS][NUM_COLS];
        for (int i = 0; i < NUM_ROWS; i++)
            for (int j = 0; j < NUM_COLS; j++)
                stateCopy[i][j] = this.state[i][j];
        ConnectFour cloned = new ConnectFour();
        cloned.setCurrentGameState(stateCopy);
        // copy other fields over to cloned
        return cloned;
    }
}

public类ConnectFour实现可克隆{
私有静态final int NUM_ROWS=6；
私有静态最终整数=7；
私有int[][]状态=新int[NUM_ROWS][NUM_COLS]；
// ...
公共连接四个克隆（）{
int[][]状态副本=新int[NUM_ROWS][NUM_COLS]；
对于（int i=0；i

private int[][] state;
public void setCurrentGameState(int[][] newState) {
    this.state = newState;
}

public class ConnectFour implements Cloneable<ConnectFour> {
    private static final int NUM_ROWS = 6;
    private static final int NUM_COLS = 7;
    private int[][] state = new int[NUM_ROWS][NUM_COLS];
    // ...
    public ConnectFour clone() {
        int[][] stateCopy = new int[NUM_ROWS][NUM_COLS];
        for (int i = 0; i < NUM_ROWS; i++)
            for (int j = 0; j < NUM_COLS; j++)
                stateCopy[i][j] = this.state[i][j];
        ConnectFour cloned = new ConnectFour();
        cloned.setCurrentGameState(stateCopy);
        // copy other fields over to cloned
        return cloned;
    }
}