Question

我正在尝试为骑士巡回问题实施解决方案。我遇到了一个有趣的问题。我想知道该行为的原因。

这是代码-可以正常工作。

public class OpenKnightTour {

    private int[][] chessTable;
    private int startRow;
    private int startCol;
    private int ChessBoardSize;


    private final int[][] moves = {
            {-1, -2},
            {-2, -1},
            {-2, 1},
            {-1, 2},
            {1, -2},
            {2, -1},
            {2, 1},
            {1, 2}
    };

    public OpenKnightTour(int ChessBoardSize, int startRow, int startCol){
        this.ChessBoardSize = ChessBoardSize;
        this.startRow = startRow;
        this.startCol = startCol;
        this.chessTable = new int[ChessBoardSize][ChessBoardSize];
    }

    void move(){
        //first move
        this.chessTable[this.startRow][this.startCol] = 1;

        //start with 2nd move recursively
        moveHelper(this.startRow, this.startCol, 2);

        //print results
        this.print();

    }

    private boolean moveHelper(int r, int c, int count){
        if((count-1) == (this.ChessBoardSize * this.ChessBoardSize))
            return true;

        for(int[] move: moves){
            int nextR = r + move[0];
            int nextC = c + move[1];
            if(isMoveValid(nextR, nextC)){
                chessTable[nextR][nextC] = count;
                if(moveHelper(nextR, nextC, count + 1)){
                    return true;
                }
                chessTable[nextR][nextC] = 0;
            }
        }
        return false;
    }

    private void print(){
        Arrays.stream(this.chessTable)
                .forEach(a -> System.out.println(Arrays.toString(a)));
    }

    private boolean isMoveValid(int r, int c){
        if(!(r >= 0 && r < this.ChessBoardSize))
            return false;
        if(!(c >= 0 && c < this.ChessBoardSize))
            return false;
        return chessTable[r][c]==0;
    }

}

现在我们可以从矩阵中(2, 2)的骑士位置开始运行此

    OpenKnightTour o = new OpenKnightTour(8, 2, 2);
    o.move();

当我尝试将起始位置设为(0, 0)时，它连续运行而未显示任何结果。所以我认为不可能有任何解决方案。但是，如果我稍微改变以下顺序，它将立即正常工作。

private final int[][] moves = {
        {-1, -2},
        {-2, -1},
        {-2, 1},
        {-1, 2},
        {1, -2},
        {1, 2}, //moved from last 
        {2, -1},
        {2, 1},
};

到底是怎么回事？这种移动位置如何对性能产生如此大的影响？那么在那种情况下，我们如何知道正确的举动顺序？

Answer 1

您正在通过很大的搜索空间进行暴力搜索。如果您不方便进行搜索，则可以花很长时间，而没有解决方案。

答案是要么您很幸运地选择了开始位置/开始方式，要么需要更聪明地识别“绝望地停留”。

例如，每回溯10,000次，就扫描整个电路板。如果您发现您可能无法回到的洞，则设置一个标志，使您回溯到您可能从中访问过的最后一步。然后继续。这样一来，您就可以跳过一大堆无用的工作，而又回到找到其中的many possible tours中来。

骑士巡回赛问题-动作顺序会影响性能

1 个答案: