Question

为什么我们需要回溯骑士的旅游问题？我们可以通过仅使用递归来实现吗？我试图这样做，但它给出了错误的答案，我无法弄清楚代码或逻辑出错的地方。

import java.util.*;
public class Solution {

    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int[][] ans=new int[8][8];
        for(int d=0;d<8;d++){
            for(int e=0;e<8;e++){
                ans[d][e]=-1;
            }
        }
        int[] x={2,1,-2,1,-1,-2,-1,2};
        int[] y={1,2,1,-2,-2,-1,2,-1};
        func(x,y,ans,7,7,1);
    }

    public static void func(int[] x,int[] y,int[][] ans,int i,int j,int count){
        if(count==64){
            for(int d=0;d<8;d++){
                for(int e=0;e<8;e++){
                    System.out.print(ans[d][e]+" ");
                }
                System.out.println();
            }
        }
        if(ans[i][j]!=-1){
            return;
        }
        else{
            ans[i][j]=count;
            for(int u=0;u<8;u++){
                if(i+x[u]>=0 && i+x[u]< 8 && j+y[u]>=0 && j+y[u]<8){
                    func(x,y,ans,i+x[u],j+y[u],count+1);
                }
            }
        }
        return;
    }
}

Answer 1

骑士巡回赛问题需要回溯至关重要。你没有在你的代码中实现反向跟踪的事实是它无法工作的主要原因。

要修复它，您必须至少清除方法结束时的位置。 I.e当你ans[i][j] = count时，必须与ans[i][j] = -1平衡，以清除那个方块 - 你不是这样做的。

这不是您的代码唯一的问题，但它是主要问题。

存在反向追踪的替代方案。您可以在递归级别创建一个新板，它是当前板的副本，但通常被认为是浪费内存。

这是我最终得到的代码：

// The board size.
private static final int SIZE = 8;
// Contents of board squares when empty.
private static final int EMPTY = -1;
// The 8 possible x,y moves for the knight.
private static final int[] x = {2, 1, -2, 1, -1, -2, -1, 2};
private static final int[] y = {1, 2, 1, -2, -2, -1, 2, -1};

public static void printBoard(int[][] board) {
    // Print out the board.
    for (int d = 0; d < SIZE; d++) {
        for (int e = 0; e < SIZE; e++) {
            System.out.print(board[d][e] + " ");
        }
        System.out.println();
    }

}

public static boolean knightsMove(int[][] board, int i, int j, int count) {
    boolean finished = false;
    // Only step onto empty squares that are on the board.
    if (i >= 0 && i < SIZE && j >= 0 && j < SIZE && board[i][j] == EMPTY) {
        // Mark my route.
        board[i][j] = count;
        // Count up.
        count += 1;
        // Are we done?
        if (count > SIZE * SIZE) {
            System.out.println("=== Solution ===");
            // Print the solution.
            printBoard(board);
            // Finished now.
            return true;
        }
        if (count == SIZE * SIZE) {
            // Nearly there - print something to show progress.
            System.out.println("=== Try === (" + i + "," + j + ")=" + count);
            // Print the current state.
            printBoard(board);
        }
        // Look around to try all moves from here.
        for (int u = 0; u < x.length && !finished; u++) {
            // Try the next place.
            finished = knightsMove(board, i + x[u], j + y[u], count);
        }
        // Clear my trail - you missed this.
        board[i][j] = EMPTY;
    } else {
        // Cannot go there.
        return false;
    }
    return finished;
}

public static void knightsMove() {
    int[][] board = new int[SIZE][SIZE];
    // Clear to EMPTY.
    for (int d = 0; d < board.length; d++) {
        for (int e = 0; e < board[d].length; e++) {
            board[d][e] = EMPTY;
        }
    }
    // Start at (7,7) with count 1.
    knightsMove(board, 7, 7, 1);
}

要有耐心 - 需要很长时间才能完成 - 正如您所期望的那样。在我的电脑上大约需要20分钟才能到达：

=== Solution ===
29 42 51 60 27 22 17 24 
50 59 28 41 52 25 20 15 
43 30 61 26 21 16 23 18 
62 49 58 53 40 19 14 7 
57 44 31 48 33 8 3 10 
36 63 34 39 54 11 6 13 
45 56 37 32 47 2 9 4 
64 35 46 55 38 5 12 1

我做了以下更改：

添加了评论 - 您应该始终评论您的代码。
制作了x和y数组static - 它们不需要是参数。
在一个地方进行所有检查（在船上并清空）。
以近乎未命中的方式打印电路板，以保证您的娱乐。
使用static final EMPTY表示空。
完成后返回boolean结果以停止搜索。
添加了回溯。
使用了更好的名称，例如board和knightsMove。
使用常数SIZE作为电路板尺寸。
可能是一些小调整。

请不要将此代码用于您的作业 - 您将通过自己动手并了解为什么每个部分的工作原理来学习更多知识。

Answer 2

递归是函数/方法调用自身的时候。您的static方法调用自身，因此您的程序使用递归。（顺便说一句：标识符应该提供信息。调用函数func什么都不说; function会更好。）

回溯是指通过一个接一个地尝试一个分支来探索分支问题，并且只有在完成当前分支后才检查下一个分支。你的程序就是这样做的，因此它正在使用回溯。

回溯也可以用堆栈和循环实现，如下所示：

tour

这不使用递归。但是，通过递归（使用程序堆栈）来执行此操作更为常见，就像在代码中一样。

所以：你的问题需要回溯来解决它。它不需要递归，尽管你正在使用它。

额外信用：您的代码失败，因为您在完成访问后应取消标记单元格。这样，当您尝试下一个分支（不跳转）时，单元格可以自由跳转。请参阅State initialState = new State(); // empty board, no moves Stack<State> stack = new Stack<State>(); stack.add(initialState); while ( ! stack.isEmpty()) { State current = stack.pop(); for (State next : current.getSuccesorStates()) { if (next.isLegal()) { stack.add(next); } } }注释。

//MISSING

在奈特的巡演中需要回溯

2 个答案: