如何遍历布尔递归数组

Question

练习： 建立一个递归（没有循环），你进入的每个单元格都是你可以走的步数，它可以是右/左，直到你到达最后一个单元格。如果您无法到达最后一个单元格，则返回 false，否则返回 true。 您必须从索引 0 开始。

我的问题：我构建了程序，但它不工作，我能够到达最后一个单元格但在输出中我得到错误，我明白为什么我弄错了，但我不知道如何解决。

测试：

public static void main(String[] args)
{
// Q - isWay
        System.out.println("\nTesting Question 3\n==================");
        int[] a1 = {2,4,1,6,4,2,4,3,5};
        System.out.println("a = {2,4,1,6,4,2,4,3,5}");
        System.out.println("Ex14.isWay(a) is: " + Ex14.isWay(a1)); //need to return true
        int[] a2 = {1,4,3,1,2,4,3};
        System.out.println("a2 = {1,4,3,1,2,4,3}");
        System.out.println("Ex14.isWay(a2) is: " + Ex14.isWay(a2));//need to return false
}


public class Ex14
{
    public static boolean isWay(int[] a)
        {
            int i = 0;
            if(a.length <= 1)
                return false;
            return isWay(a , 0);
        }

        public static boolean isWay(int[] a,int i)
        {     
            int temp1 , temp2;
            if(i == a.length-1)
                return true;
            if(!((a[i]+i < a.length) && (i-a[i] >= 0))) // can't go right and left
                return false;
            else if(a[i] > 0)
            {
                if(a[i]+i < a.length) // go right
                {
                    temp1 = a[i] + i;
                    a[i] = -1;
                    return isWay(a, temp1);
                }
                else if (i-a[i] >= 0) // go left
                {
                    temp2 = i - a[i];
                    a[i] = -1;
                    return isWay(a, temp2);   
                }    
            }
            return false;
        }
}

Answer 1

您返回false的条件错误。

if(!((a[i]+i < a.length) && (i-a[i] >= 0)))

应该是

if(!((a[i]+i < a.length) || (i-a[i] >= 0)))

如果您无法向左或向右继续，您想返回false。您的条件测试您是否不能同时向左和向右进行。

编辑：

我最初建议的修复方法还不够，因为如果您遇到死胡同，您的方法必须能够回溯。

这是另一种方法：

public static boolean isWay(int[] a,int i) {
    int temp1 , temp2;
    if(i == a.length-1) {
        return true;
    }
    boolean found = false;
    if(a[i]+i < a.length && a[a[i]+i] > 0) { // go right
        temp1 = a[i] + i;
        a[i] = -1;
        found = isWay(a, temp1);
        if (!found) {
            a[i] = temp1 - i; // must restore a[i] to its original value, in order 
                              // to be able to go left
        }
    }
    if (!found && i-a[i] >= 0 && a[i - a[i]] > 0) { // go left
        temp2 = i - a[i];
        a[i] = -1;
        found = isWay(a, temp2);   
    }
    return found;
}

想法是，如果你可以左右走，并且向右走会导致死胡同，你必须在向右的递归调用返回时尝试向左走。

这对于 {1,4,3,6,1,2,4,3} 和 {2,4,1,6,4,2,4,3,5} 都返回 true。

Answer 2

我没有得到你想要做的，但这里是一个递归函数的例子，它有效 && 数组中的所有布尔值

public static boolean recurse(boolean[] ary)
{
    if (ary.length == 1) {
        return ary[0];
    }

    return ary[0] && recurse(Arrays.copyOfRange(ary, 1, ary.length));
}

测试：

public static void main(String[] args)
{
    boolean[] ary = { true, true, true, true, true};

    System.out.println(recurse(ary));

    boolean[] ary2 = { true, true, false, true, true};

    System.out.println(recurse(ary2)); 
}

• 是的
• 错误

我希望能帮助你解决你的问题，否则你可以解释更多你想用这个功能做什么

Answer 3

我就是这样解决的：

public static void main(String[] args)
{
    int[] a = { 2, 4, 1, 6, 4, 2, 4, 3, 5 };
    System.out.println(isWay(a)); // true

    int[] a1 = { 1, 4, 3, 1, 2, 4, 3 };
    System.out.println(isWay(a1)); // false
}

public static boolean isWay(int[] a)
{
    return isWay(a, 0);
}

private static boolean isWay(int[] a, int i)
{
    if (i == a.length - 1) // if we are in the last index
        return true;

    if (i >= a.length || i < 0) // boundaries
        return false;
    
    if (a[i] == -1) // if marked return false to prevent infinite recursion..
        return false;

    int temp = a[i]; // mark where we already have been...
    a[i] = -1;

    boolean r1 = isWay(a, i + temp); // we are trying to move right
    boolean r2 = isWay(a, i - temp); // we are trying to move left

    a[i] = temp; // revert changes

    return r1 || r2;
}