C++ 寻找最小跳跃次数

下面是寻找最小跳跃次数的算法难题。发布了详细的问题声明和两个代码版本来解决此问题。我做了测试，两个版本似乎都有效，我的第二个版本是版本一代码的优化版本，它使我从

I=maxIndex

开始，而不是不断增加，这可以通过不迭代阵列的所有插槽来节省时间

我的问题是，想知道我的第二版代码是否100%正确？如果有人发现任何逻辑问题，请指出

问题陈述

给定一个非负整数数组，您最初位于数组的第一个索引处

数组中的每个元素表示该位置的最大跳跃长度

您的目标是以最少的跳跃次数达到最后一个索引

例如： 给定数组A=[2,3,1,1,4]

到达最后一个索引的最小跳转次数为2。（从索引0跳1步到1，然后跳3步到最后一个索引。）

第一版代码

class Solution {
public:
    int jump(vector<int>& nums) {
        int i = 0, n = nums.size(), step = 0, end = 0, maxend = 0;
        while (end < n - 1) {
            step++;
            for (;i <= end; i++) {
                maxend = max(maxend, i + nums[i]);
                if (maxend >= n - 1) return step;
            }
            if(end == maxend) break;
            end = maxend;
        }
        return n == 1 ? 0 : -1;
    }
};

class Solution {
public:
    int jump(vector<int>& nums) {
        int i = 0, n = nums.size(), step = 0, end = 0, maxend = 0;
        int maxIndex = 0;
        while (end < n - 1) {
            step++;
            for (i=maxIndex;i <= end; i++) {
                if ((i + nums[i]) > maxend)
                {
                  maxend = i + nums[i];
                  maxIndex = i;
                }

                if (maxend >= n - 1) return step;
            }
            if(end == maxend) break;
            end = maxend;
        }
        return n == 1 ? 0 : -1;
    }
};

类解决方案{
公众：
整数跳跃（向量和nums）{
int i=0，n=nums.size（），步长=0，结束=0，最大结束=0；
而（结束

第二版代码

class Solution {
public:
    int jump(vector<int>& nums) {
        int i = 0, n = nums.size(), step = 0, end = 0, maxend = 0;
        while (end < n - 1) {
            step++;
            for (;i <= end; i++) {
                maxend = max(maxend, i + nums[i]);
                if (maxend >= n - 1) return step;
            }
            if(end == maxend) break;
            end = maxend;
        }
        return n == 1 ? 0 : -1;
    }
};

class Solution {
public:
    int jump(vector<int>& nums) {
        int i = 0, n = nums.size(), step = 0, end = 0, maxend = 0;
        int maxIndex = 0;
        while (end < n - 1) {
            step++;
            for (i=maxIndex;i <= end; i++) {
                if ((i + nums[i]) > maxend)
                {
                  maxend = i + nums[i];
                  maxIndex = i;
                }

                if (maxend >= n - 1) return step;
            }
            if(end == maxend) break;
            end = maxend;
        }
        return n == 1 ? 0 : -1;
    }
};

类解决方案{
公众：
整数跳跃（向量和nums）{
int i=0，n=nums.size（），步长=0，结束=0，最大结束=0；
int maxIndex=0；
而（结束=n-1）返回步骤；
}
如果（end==maxend）中断；
end=maxend；
}
返回n==1？0:-1；
}
};

提前感谢,，

---

林

最好的方法总是测试它。人类不能总是考虑特殊情况，但自动化测试可以覆盖大多数特殊情况。如果您认为第一个版本运行良好，可以将第一个版本的结果与第二个版本的结果进行比较。这里有一个例子：

/*
 * arraySize    : array size to use for the test
 * min          : min jump in the array
 * max          : max jump in the array
 */
void testJumps(int arraySize, int min, int max){

    static int counter = 0;
    std::cout << "-----------Test " << counter << "------------" << std::endl;
    std::cout << "Array size : " << arraySize << "   Minimum Jump : " << min << "   Max Jump" << max << std::endl; 
    //Create vector with random numbers
    std::vector<int> vecNumbers(arraySize, 0);
    for(unsigned int i = 0; i < vecNumbers.size(); i++)
        vecNumbers[i] = rand() % max + min;

    //Value of first function
    int iVersion1 = jump1(vecNumbers);

    //Second fucntion
    int iVersion2 = jump2(vecNumbers);

    assert(iVersion1 == iVersion2);

    std::cout << "Test " << counter << " succeeded" << std::endl;
    std::cout << "-----------------------" << std::endl;

    counter++;

}

int main()
{
    //Two test
    testJumps(10, 1, 100);
    testJumps(20, 10, 200);

    //You can even make a loop of test
    //...
}

/*
*arraySize：用于测试的数组大小
*最小：数组中的最小跳跃
*最大：数组中的最大跳跃
*/
void testJumps（int arraySize、int min、int max）{
静态整数计数器=0；
std：：cout这里有一个技巧，告诉我们如何使这个问题更容易处理，从而使其他人更有可能帮助：向我们展示构成您的解决方案的递归关系，然后是应该执行此操作的代码。这样，我们可以对此进行推理，而不是在过程代码上找出差异。最后，您可以跳到nums[i]在右边，或者仅仅是nums[i]是吗？每次运行时，它们都给出相同的答案，所以我认为它是有效的。@JamesRoot，有了您的确认，我更自信。如果您能给出答案，我会将其标记为一个答案，以便对其他人也有利。：@TomaszKaminski，我们肯定可以跳过右侧，这是一个有效的跳跃。但我认为这不会影响result，对吗？谢谢。@linma我认为答案应该在逻辑上证明它有效，或者提供改进。我刚刚编写了一个循环并在其中调用了一个函数。谢谢船长，我已经测试过了，没有发现任何问题。但我不是100%有信心，所以我来这里寻求帮助。不知您是否有什么好的想法或发现了任何问题？