在这个示例代码中，回溯发生在哪里？

Posted 2023-02-22

【中文标题】在这个示例代码中，回溯发生在哪里？

【英文标题】：Where in this sample code is the backtracking happening?

【发布时间】：2018-03-09 22:13:06

【问题描述】：

package maze;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class Maze 


    public static void main(String[] args) 
        int board[][] = new int[31][121];
        Random rand = new Random();
        for (int i = 0; i < board.length; i++) 
            for (int j = 0; j < board[0].length; j++) 
                board[i][j]=1;
            
        
        int r = rand.nextInt(board.length);
        while(r%2==0)
            r=rand.nextInt(board.length);
        

        int c = rand.nextInt(board[0].length);
        while(c%2==0)
            c=rand.nextInt(21);
        
        System.out.format("r is %d and c is %d\n",r,c);
        board[r][c]=0;
        recursion(r,c,board);
        for (int i = 0; i < board.length; i++) 
            for (int j = 0; j < board[0].length; j++) 
                if (board[i][j]==1) 
                    System.out.print("#");
                 else if (board[i][j]==0) 
                    System.out.print(" ");
                

            
            System.out.println("");
        

    
    public static void recursion(int r, int c,int[][] board)
        ArrayList<Integer> randDirections = generateDirections();
        int[] randDir=new int[randDirections.size()];

        for (int i = 0; i < randDir.length; i++) 
            randDir[i]=randDirections.get(i);
            System.out.println(randDir[i]);
        

        for (int i = 0; i < randDir.length; i++) 

            switch(randDir[i])
                case 1:
                    //checks up position
                    if (r-2>=0) 
                        if (board[r-2][c]!=0) 
                            board[r-2][c] = 0;
                            board[r-1][c] = 0;
                            recursion(r - 2, c,board);
                        
                    
                    break;
                case 2:
                    //checks right position
                    if (c + 2 <= board[0].length - 1)
                        if (board[r][c + 2] != 0) 
                            board[r][c + 2] = 0;
                            board[r][c + 1] = 0;
                            recursion(r, c + 2,board);
                        
                    
                    break;
                case 3:
                    //checks down position
                    if (r + 2 <= board.length - 1)
                        if (board[r + 2][c] != 0) 
                            board[r+2][c] = 0;
                            board[r+1][c] = 0;
                            recursion(r + 2, c,board);
                        
                    
                    break;
                case 4:
                    //checks left position
                    if (c - 2 >= 0)
                        if (board[r][c - 2] != 0) 
                            board[r][c - 2] = 0;
                            board[r][c - 1] = 0;
                            recursion(r, c - 2,board);
                        
                    
                    break;
              
        
    
    public static ArrayList<Integer> generateDirections()
        ArrayList<Integer> randoms = new ArrayList();
        for (int i = 0; i < 4; i++) 
            randoms.add(i+1);
        
        Collections.shuffle(randoms);
        return randoms;
    

我可以看到，当我的程序无法为我的迷宫开辟另一条路径时，我的程序正在回溯，并且我的递归方法只有在它一直回溯到第一个路径方格时才会停止。但是，我不知道到底是在做什么。在我看来，当四个随机方向的 for 循环用尽时，该方法应该停止。有人可以向我解释哪部分代码导致它回溯以及它是如何工作的吗？

【问题讨论】：

youtube.com/watch?v=elMXlO28Q1U

感谢您向我展示该视频。但是，我仍然不明白他展示的堆栈和条件部分是如何存在于我的程序中的。你能告诉我我的程序是如何做同样的事情的吗？

您还想要答案吗？

是的，任何你能帮助解释回溯发生的地方都会很棒。我想我误解了递归的工作方式。

【参考方案1】：

答案在于调用堆栈并了解堆栈的每一级发生了什么。当一个递归调用耗尽它的 for 循环时，就会发生“回溯”，在此之后，该方法返回，从堆栈中弹出一个级别，并继续进行调用的堆栈级别上下文的 for 循环。

仅列出 2 个级别的调用有助于澄清。您会发现在第一个“级别”（递归的根调用）中，for 循环只是按照您的预期进行迭代，但是它会穿插在它进行的递归调用的处理中（每个都创建一个“下一级”递归）。

调用栈底层的for循环遍历所有迭代，而上一层的for循环可能只在第一次迭代。

【讨论】：

你说方法返回但我不明白，因为我只调用了一次方法并且我没有返回语句。此外，我不知道哪个部分应该从堆栈中弹出一层。我观看了一个视频，其中更清楚地显示了堆栈，并且我了解该方法应该如何工作，但我不知道我的方法在哪里做这些事情。你能帮我指出这些地方吗？对不起，如果这是一个愚蠢的问题。

方法调用自身——这就是递归。此外，即使没有明确的return 语句，每个函数/方法都会在控制结束时返回。听起来像是复习指令处理和函数的基础知识可能会有所帮助。

这里是递归调用之一recursion(r - 2, c,board); 如果你写一个方法public void endless() endless(); 并调用它，你会很快得到堆栈溢出。