Question

在招聘测试平台中，我遇到了以下整数序列问题，我在没有递归函数的情况下解决了它，以避免Stack Overflow：

这是对问题的简短描述：

我们有一个标记，在每个阶段我们都会向前或向后移动。在第0阶段，我们处于位置0（没有步骤）在第1阶段，我们向前迈出一步（+1步）=＆gt;位置1 对于阶段2，我们向后退两步（-2步）=＆gt;位置-1 对于阶段n：我们在前一阶段采取的步骤数减去我们在第二阶段采取的步骤数，因此在第3阶段，我们将不得不向后退3步（-2 - 1）。 =＆GT;位置-4 等...

目标是编写函数int getPos（int stage）以返回指定阶段的位置。

用笔和纸我发现了这个公式：

位置（n）=步骤（n-1） - 步骤（n-2）+位置（n-1）

在这里加上我的解决方案

#include <iostream>

using namespace std;

int getPos(int stage)
{
    if (stage < 2)
        return stage;

    if (stage == 2)
        return -1;

    int stepNMinus1 = -2;
    int stepNMinus2 = 1;
    int stepN = 0;
    int posNMinus1 = -1;
    int Res = 0;

    while (stage-- > 2)
    {
        stepN = stepNMinus1 - stepNMinus2;
        Res = stepN + posNMinus1;
        stepNMinus2 = stepNMinus1;
        stepNMinus1 = stepN;
        posNMinus1 = Res;
    }

    return Res;
}

int main()
{
    cout << "Pos at stage -1 = " << getPos(-1) << endl; // -1
    cout << "Pos at stage 0 = " << getPos(0) << endl; // 0
    cout << "Pos at stage 1 = " << getPos(1) << endl; // 1
    cout << "Pos at stage 2 = " << getPos(2) << endl; //-1
    cout << "Pos at stage 3 = " << getPos(3) << endl; // -4
    cout << "Pos at stage 4 = " << getPos(4) << endl; // -5
    cout << "Pos at stage 5 = " << getPos(5) << endl; // -3
    cout << "Pos at stage 100000 = " << getPos(100000) << endl; // -5
    cout << "Pos at stage 2147483647 = " << getPos(2147483647) << endl; // 1
}

通过平台测试执行测试程序后，int情况的最大值超时了整个过程，测试平台说我的解决方案没有足够优化来处理某些情况。

我试过＆＃34;注册＆＃34;关键字，但它没有效果......

我非常好奇，我想知道如何编写优化函数。我应该更改算法（如何？）或使用一些编译器调整？

Answer 1

我们将编写第一阶段

Stage    | Step   | Position
0        | 0      | 0
1.       | 1      |1
2        |-2      | -1
3        |-3      |-4
4        |-1      |-5
5        |2       |-3
6        |3       |0
7        |1       |1
8        |-2      |-1

我们可以看到在步骤6中等于步骤0，步骤1 =步骤7，步骤2 =步骤7，...

因此，对于步骤x，答案是步骤（x％6）

你可以做到

cout << "Pos at stage x = " << getPos((x%6)) << endl;

优化整数序列的非递归算法

1 个答案: