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

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

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;
}

如何遍历布尔递归数组

3 个答案: