Java 如何选择该方法

我一直在解决hackerrank的一个问题。我确信我的解决方案是正确的，但当输入矩阵变大时，程序会因超时而终止

我有一个方法，可以找到下面给出的系列。此方法获取数组索引数，并根据该方法计算一个数。根据这个数字，我用一些东西填充我的数组。但程序每次都会终止。它仅适用于最大n=2的情况。我认为这个方法应该得到优化，因为它对大n使用了巨大的递归。有什么建议我该怎么办

static int hacko(int n)
{
    if(n==1)
        return 1;
    else if(n==2)
        return 2;
    else if(n==3)
        return 3;
    else
     return hacko(n-1)+(2*hacko(n-2))+(3*hacko(n-3));

}

---

您可以避免不必要的分支，这可能会很昂贵，例如：

static int hacko(int n) {

    if(n < 4)
        return n;
    else
        return hacko(n-1)+(2*hacko(n-2))+(3*hacko(n-3));

}

---

这里的问题是，对于n的大值，它递归地计算hacko（n-1）+（2*hacko（n-2））+（3*hacko（n-3））。这可能很耗时，而且不必要

您可以通过将hackos（i）的值保存在数组中，并从数组中获取hacko（n-1）+（2*hacko（n-2））+（3*hacko（n-3））的值，而不是每次递归地计算来优化它。你需要从i=1到i=N开始循环

例：

int savedData[]=new int[N]；
静态int hacko（int n）
{
如果（n==1）
返回1；
else如果（n==2）
返回2；
else如果（n==3）
返回3；
其他的
返回savedData[n-1]+（2*savedData[n-2]）+（3*savedData[n-3]）；
}
对于（inti=1；我感谢您的建议：）。是的，我当然可以做这件事：）谢谢。这应该会减少一些复杂性添加了一个迭代解决方案，因为您声明递归不是必需的。天哪！太好了。非常感谢。您将一个难看的递归转化为一个简单的迭代：）对于大型
n
来说，递归可能很重。您的任务是否需要递归？不，不是必需的。我想用任何有用的东西。
static int hacko(int n) {

    // Shortcut for n=1, n=2 and n=3
    if (n < 4)
        return n;

    // Array to store the previous results
    int[] temp = new int[n];
    temp[0] = 1;
    temp[1] = 2;
    temp[2] = 3;

    // Iterative approach, more scalable, counts up
    for (int i = 3; i < n; i++) {
        temp[i] = 3 * temp[i - 3] + 2 * temp[i - 2] + temp[i - 1];
    }

    return temp[n - 1];

}

int savedData[] = new int[N];
static int hacko(int n)
{
    if(n==1)
        return 1;
    else if(n==2)
        return 2;
    else if(n==3)
        return 3;
    else
     return savedData[n-1]+(2*savedData[n-2])+(3*savedData[n-3]);

}

for(int i=1;i<N;i++) {
savedData[i] = hacko(i);
}