Question

我一直在解决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));

}

Answer 1

你可以避免不必要的分支，这可能是昂贵的，如下：

static int hacko(int n) {

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

}

我假设为n > 0，否则请使用if(n > 0 && n < 4)。但是，你说：

仅适用于最大n = 2。

因此，您发布的方法很可能不是瓶颈，因为与n=3或n=1相比，n=2不会给代码增加任何重要的复杂性。或者你的意思是什么？

由于递归不是您的要求，您可以执行以下迭代方法：

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];

}

Answer 2

这里的问题是，对于大的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];
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);
}

希望它有所帮助。

如何优化方法

2 个答案: