Question

我得到一个值大于或等于0的整数数组，例如： [5,6,0,4,2,4,1,0,0,4]

我被要求实现一个算法，以从索引0开始的最短数量的“跳”遍历数组，其中遍历定义如下：

- ＆gt;从数组的第一个（第0个）索引处开始，查看那里的数组值，然后您可以跳转到任何不比该值更远的数组索引。因此，在此示例中，您从包含值5的索引0开始，现在可以考虑跳转到索引1到5中的任何一个。

如果我选择跳到索引3，它包含值4，然后我可以从当前索引跳出多达4个点（3） - 所以我现在将索引4到7视为序列中的后续步骤。

我的算法必须识别最小跳数解决方案，但可以在具有相同跳数的解决方案中任意选择。

对于此示例，以下内容将是有效输出：

0,5,9，out

这是我的实施：

public class ArrayJumper {

    /**
     * @param args the command line arguments
     */
    int[] minJumps(int arr[], int n) {
        int jumps[] = new int[n];
        int tab[] = new int[n];// jumps[n-1] will hold the result
        int i, j;
        jumps[0] = 0;
        tab[0] = 0;

        if (n == 0 || arr[0] == 0) {
            return jumps;
        }

        // Find the minimum number of jumps to reach arr[i]
        // from arr[0], and assign this value to jumps[i]

        for (i = 1; i < n; i++) {
            jumps[i] = Integer.MAX_VALUE;
            for (j = 0; j < i; j++) {
                if (i <= j + arr[j] && jumps[j] != Integer.MAX_VALUE) {
                    if (jumps[i] >= jumps[j] + 1) {
                        jumps[i] = jumps[j] + 1;
                        tab[i] = j;
                        //break;
                    }
                }
            }
        }
        System.out.println(Arrays.toString(jumps));

        return tab;
    }

    public static void main(String[] args) {
        // TODO code application logic here
        int arr[] = {5, 6, 0, 4, 2, 4, 1, 0, 0, 4};
        //int arr[] = {2,3,1,1,2,4,2,0,1,1};
        int n = arr.length;
        int res[] = new int[n];
        int inn[] = new int[n];
        ArrayJumper a = new ArrayJumper();
        inn = a.minJumps(arr, n);
        System.out.println(Arrays.toString(inn));

        inn[0] = 0;
        String ans = " 0 ,";

        for (int i = 0; i < n - 1; i++) {
            if (inn[i] != inn[i + 1]) {
                ans = ans.concat(inn[i + 1] + ",");
            }
        }
        if (arr[inn[n - 1]] + inn[n - 1] == n - 1) {
            ans = ans.concat(n - 1 + ",");
        }

        ans = ans.concat("out");
        System.out.println(ans);
    }
}

然而，该解决方案适用于给定的输入，它对以下输出失败： {2,3,1,1,2,4,2,0,1,1}; 我不确定我错过了哪里。注释输入都正常工作如果我分别更改break语句。那么如何修改此progroam才能获得

0,1,4,5,9，输入{2,3,1,1,2,4,2,0,1,1}。

和 0,5,9，输出为{5,6,0,4,2,4,1,0,0,4}

Answer 1

我相信您的minJumps()工作正常。问题在于答案的构造，ans字符串。

我不明白你尝试这样做的逻辑。我相信你需要从“out”向后构建字符串。当inn[3]等于2时，表示如果你的解决方案通过输入的索引3，它应该在3之前通过索引2.但是你还不知道解决方案是否会跳过索引3。

所以要向后构建它，你从“out”开始，在“out”之前出现什么？要告诉你，你需要让结果数组的元素更长一些，以便新的最后一个元素告诉你在“out”之前访问的最后一个索引。然后你可以这样做：

    String ans = "out";
    int index = n;
    while (index > 0) {
        index = inn[index];
        ans = "" + index + ", " + ans;
    }
    System.out.println(ans);

要构建数组，一个元素更长，只需要对方法进行一些简单的更改：

    int jumps[] = new int[n + 1];
    int tab[] = new int[n + 1];// jumps[n-1] will hold the result

和

    for (i = 1; i <= n; i++) {

通过这些更改，输入{5,6,0,4,2,4,1,0,0,4}产生

0, 5, 9, out

输入{2,3,1,1,2,4,2,0,1,1}给出

0, 1, 4, 5, 9, out

打印到达阵列末尾所需的最小跳转次数序列

1 个答案: