理解此java递归回溯示例的问题

问题如下：

public static boolean solveH(int index){
    if(index == data.size()-1){
        printSol(stages);
        return true;
    }
    boolean success = false;
    if(!success && (index + Integer.parseInt(data.get(index)) < data.size())){
        String temp = data.get(index);
        data.set(index, temp + "R");
        stages.add(copy(data));
        data.set(index, temp);
        success = solveH(index + Integer.parseInt(data.get(index)));
        stages.remove(stages.size()-1);
    }
    if(!success && (index - Integer.parseInt(data.get(index)) > 0)){
        String temp = data.get(index);
        data.set(index, temp + "L");
        stages.add(copy(data));
        data.set(index, temp);
        success = solveH(index - Integer.parseInt(data.get(index)));
        stages.remove(stages.size()-1);
    }
    return false;
}

您有一个整数数组，例如[2,3,1,4,0]。您希望找到最后一个索引的路径。您可以从索引0开始向左或向右移动。可以沿数组移动的步数取决于索引位置的值。最后，您希望打印所有路径

在我的示例中，从索引0开始，它包含2。你不能向左移动，因此你向右移动。现在是索引2，它包含1。然后可以向左移动1以到达包含3的索引1，然后向右移动3以到达最后一个索引

我对实施和如何打印出所有可能的解决方案都有疑问

我的代码如下：

public static boolean solveH(int index){
    if(index == data.size()-1){
        printSol(stages);
        return true;
    }
    boolean success = false;
    if(!success && (index + Integer.parseInt(data.get(index)) < data.size())){
        String temp = data.get(index);
        data.set(index, temp + "R");
        stages.add(copy(data));
        data.set(index, temp);
        success = solveH(index + Integer.parseInt(data.get(index)));
        stages.remove(stages.size()-1);
    }
    if(!success && (index - Integer.parseInt(data.get(index)) > 0)){
        String temp = data.get(index);
        data.set(index, temp + "L");
        stages.add(copy(data));
        data.set(index, temp);
        success = solveH(index - Integer.parseInt(data.get(index)));
        stages.remove(stages.size()-1);
    }
    return false;
}

publicstaticbooleansolveh（int索引）{
if（index==data.size（）-1）{
printSol（阶段）；
返回true；
}
布尔成功=假；
if（！success&&（index+Integer.parseInt（data.get（index））0））{
字符串temp=data.get（索引）；
数据集（索引，温度+“L”）；
阶段。添加（复制（数据））；
数据集（索引、温度）；
success=solveH（index-Integer.parseInt（data.get（index））；
stages.remove（stages.size（）-1）；
}
返回false；
}

我的方法是：在每次实地考察时向左，向右（事实上，每一步都要进行分支）

好的-首先，像你一样：看看我们是否达到了目标

然后，将该索引处的值保存为向左和向右移动，然后将该值设置为0作为“已访问”的标记。无论如何，您被冻结在一个零字段上，并且到达目标的检查基于索引=最后一个索引

不需要字符串和解析，只需将普通数字存储在数组中即可

代码：

公共类StepArray{
//使用静态字段/方法有点难看。也许可以改进main，
//允许传递数组以动态访问。
静态int[]数据=新int[]{2,3,1,4,0}；
静态int len=data.length；
公共静态布尔解算器（int索引）{
如果（索引==len-1）{
System.out.println（“在索引“+索引+”！”处找到）；
返回true；
}
//在覆盖之前保存值：
int step=数据[索引]；
//已经参观了吗？
如果（步骤==0）返回false；
//通过设置为0，为以后的访问者标记为已访问：
数据[索引]=0；
如果（索引+步长0）{
System.out.print（“L:+步进”）；
solveH（指数阶跃）；
}
返回false；
}
公共静态void main（字符串参数[]）{
solveH（0）；
}
}

以下是改进版，更有趣、更灵活（核心算法仅作了表面上的更改）：

import java.util.Random；
公共类数组步骤{
int[]数据；
内伦；
公共ArraySteps（int[]值）{
数据=数值；
len=数据长度；
solveH（0）；
System.out.println（）；
}
布尔解算（整数索引）{
如果（索引==len-1）{
System.out.println（“在索引“+索引+”！”处找到）；
返回true；
}
int step=数据[索引]；
//已经访问
如果（步骤==0）返回false；
//通过设置为0，为以后的访问者标记为已访问：
数据[索引]=0；
布尔r=false，l=false；
如果（索引+步长0）{
System.out.print（“L:+步进”）；
l=溶解H（指数-阶跃）；
}
如果（r | | l）返回true；
System.out.println（“死胡同”）；
返回false；
}
公共静态void main（字符串参数[]）{
//默认情况下，无参数：
int[]参数；
System.out.println（“args.length:+args.length”）；
如果（args.length==0）
{
System.out.println（“默认值：”）；
param=newint[]{2,3,1,4,0}；
}
//一个参数：生成计数N个随机值
else if（args.length==1）
{
System.out.println（“随机：”）；
int anz=Integer.parseInt（args[0]）；
Random r=新的Random（）；
参数=新整数[anz]；
对于（int i=0；i

所以我们没有上下文类，没有数据，没有main。printSol看起来不像是标准库Java方法。或者阶段——它是什么，它来自哪里？不是来自方法参数，所以它是一个静态变量-对吗？我为什么要弄明白这一点？请创建一个。在第6行中，您将success设置为false。在第7行中，您测试了成功-其间可能发生了什么？在下一个块的开始处，再次进行测试。但你不想

import java.util.Random;

public class ArraySteps  {

    int[] data;
    int len;

    public ArraySteps (int [] values) {
        data = values;
        len = data.length;
        solveH (0);
        System.out.println ();
    }

    boolean solveH (int index) {
        if (index == len - 1) {
            System.out.println (" found at index " + index + "!");
            return true;
        }
        int step = data[index];
        // already visited
        if (step == 0) return false;
        // mark for later visitors as visited by setting to 0:
        data[index] = 0;

        boolean r = false, l = false;

        if (index + step < len) {
            System.out.print (" R:" + step);
            r = solveH (index + step);
        }
        if (index - step > 0) {
            System.out.print (" L:" + step);
            l = solveH (index - step);
        }
        if (r || l) return true;
        System.out.println (" dead end.");
        return false;
    }

    public static void main (String args[]) {
        // default, no args:
        int [] param;
        System.out.println ("args.length: " + args.length);
        if (args.length == 0)
        {
             System.out.println ("default: ");
             param = new int [] {2, 3, 1, 4, 0};
        }
        // one arg: Generate count N random values
        else if (args.length == 1)
        {
            System.out.println ("Random: ");
            int anz = Integer.parseInt (args[0]);
            Random r = new Random ();
            param = new int [anz];
            for (int i = 0; i < anz - 1; ++i) {
                param [i] = r.nextInt (Math.min (anz/2, 9)) + 1;
            }
            param[anz-1] = 0;
        }
        else {
            System.out.println ("User defined: ");
            param = new int [args.length + 1];
            for (int i = 0; i < args.length; ++i)
            {
                param[i] = Integer.parseInt (args[i]);
            }
            param [args.length] = 0;
        }
        show (param);
        new ArraySteps (param);
    }

    private static void show (int[] ls)
    {
            for (int i: ls)
                    System.out.print (i + " ");
            System.out.println ();
    }
}