Question

假设这个随机代码看起来类似于我在这个问题中关注的工作技术：

int randomNumber(int n) {
    if (n <= 0)
        return 3;
    int c1 = 1+randomNumber(n-2);
    int c2 = 2 + randomNumber(n-1);
    return c1 + c2;
}

我想将它转换为迭代形式，每次调用都等同于将某些内容推送到显式堆栈，但是每个return语句都将返回给调用者，它等同于什么？我想在每次调用后保存堆栈中的位置，并在return语句后再次返回它，但这似乎是不可能的。

编辑：为了让自己更清楚，请考虑这个更复杂的随机例子：

int pal(string s, int i) {
    if (i > s.length()/2) {
        return 0;
    }
    string s1 = s, s2 = s;
    int c1, c2;
    if (s1[i] == s1[i + 1]) {
        s1.insert(i + 1, "a");
        c1 = 1 + pal(s1, i + 1);
    }
    else {
        c1 = pal(s1, i + 1);
    }
    if (s2[i] == s2[i + 2]) {
        s2.insert(i + 2, "b");
        c2 = 1 + pal(s2, i + 1);
    }
    else {
        c2 = pal(s2, i + 1);
    }
    return c1 > c2 ? c1 : c2;
}

我认为它不会被简单地转换为迭代形式

EDIT2：我的问题最初是因为我想最小化这些函数的时间，例如前一个例子我想最大限度地减少大字符串的时间（计算程序的大字符串的结果几乎是永远的像前一个一样）

Answer 1

这几乎是斐波那契：

n = -1, r = 3
n = 0, r = 3
n = 1, r = 9 (1+3 + 2+3)
n = 2, r = 15 (1+3 + 2+9)
n = 3, r = 27 (1+9 + 2+15)
n = 4, r = 45 (1+15 + 2+27)
n = 5, r = 75 (1+27 + 2+45)
. . .

因此，您可以使用简单的迭代算法来计算系列：

int randomNumer(int n)
{
    if (n <= 0)
        return 3;

    a = 3;
    b = 3;

    for (int i = 0; i < n; i++)
    {
        int t = a;
        a = b;
        b = (1 + t) + (2 + a);
    }

    return b;
}

Answer 2

如果您的函数是pure函数（即没有副作用），则可以使用memoization或缓存。也就是说，将输入映射到输出，并在计算函数时首先使用它。

int randomNumber_with_memo(int n, std::map<int, int>& memo)
{
    int& result = memo[n]; // find precalculated result; if not found, use 0
    if (result == 0) // not found
    {
        int c1 = 1+randomNumber_with_memo(n-2, memo);
        int c2 = 2 + randomNumber_with_memo(n-1, memo);
        result = c1 + c2; // this also updates the memo
    }
    return result;
}

int randomNumber(int n) {
    std::map<int, int> memo;
    memo[-2] = 3;
    memo[-1] = 3;
    memo[0] = 3;
    return randomNumber_with_memo(n, memo);
}

这主要是一个黑客攻击：

它不会尝试在randomNumber
它使用map而不是更高效的vector（或数组）
它依赖0作为哨兵值 - 它永远不应该是有效的结果

但它有一个优点 - 您无需分析代码。只需用memoization函数包装它，它可能会更快。

注意：这不会尝试将递归转换为迭代。

Answer 3

对于最小化的时间，由于许多插入，您可以使用链表而不是字符串：

#include <iostream>
#include <list>
#include <string>
#include <utility>

#include <iterator>

using namespace std;
int pal2(std::list<char>& s, decltype(declval<std::list<char>>().begin())  it , int i)
{
    if (i > s.size()/2) {
    return 0;
    }
    int c1, c2;
    auto next = std::next (it ,1);
    if(*it == *next)
    {
    s.insert(next, 'a');
    c1 = 1 + pal2(s,std::next (it ,1), i + 1);
    s.erase(std::next (it ,1));
    }
    else{
    c1 = pal2(s, std::next (it ,1), i + 1);
    }
    next = std::next (it ,2);
    if (*it == *next) {
    s.insert(next, 'b');
    c2 = 1 + pal2(s,std::next (it ,1), i + 1);
    s.erase(std::next (it ,2));
    }
    else {
    c2 = pal2(s,std::next (it ,1), i + 1);
    }
    return c1 > c2 ? c1 : c2;
}
int main()
{
    auto test = std::string("sssaaaasbbbabaaaaam");
    std::list<char> s(test.begin(),test.end());
    int i = 4;
    std::cout << pal2(s, std::next(std::begin(s),i),i);
}

递归到迭代返回等价？

3 个答案: