我怎样才能为此制定确切的复发？

Question

N 个建筑物排成一排，从左到右编号为 1 到 N。 蜘蛛侠在 1 号楼，想到达 N 号楼。 如果 i

输入：

第一行包含 N，建筑物的数量。 下一行包含 N 个空格分隔的整数，表示数组高度。

输出：

打印一个整数，上面问题的答案。

所以，我想到了这样的事情：

int calc(int arr[], int beg, int end, )
{
    //int ans = INT_MIN;
    if (beg == end)
        return 0;
    else if (beg > end)
        return 0;
    else
    {
        for (int i = beg+1; i <= end; i++ ) // Iterate over all possible combinations
        {
            int foo = arr[i] - arr[beg]; // Check if power of two or not
            int k = log2(foo);
            int z = pow(2,k);
            if (z == foo) // Calculate the minimum value over multiple values
            {
                int temp = calc(arr,i,end);
                if (temp < ans)
                    temp = ans;
            }
        }
    }
}

以上是我要解决的问题，链接如下：https://www.codechef.com/TCFS15P/problems/SPIDY2 但是，上面的递归并不完全正确。我是否也必须在其中传递answer 的值？

Answer 1

我们可以从任何(n-2^0),(n-2^1),(n-2^2)... 建筑物到达第n 栋建筑物。所以我们需要从 1 开始处理建筑物。对于每个建筑物 i，我们计算从任何早期建筑物 j 到达那里的成本，其中 i-j 是 2 的幂并取最小成本。

int calc(int arr[],int dp[],int n) {
    // n is the target building
    for(int i=1; i<=n; i++) dp[i]=LLONG_MAX;  //initialize to infinity
    dp[1]=0;  // no cost for starting building
    for(int i=2; i<=n; i++) {
        for(int j=1; i-j>=1; j*=2) {   
            dp[i]=min(dp[i], dp[i-j]+abs(arr[i]-arr[i-j]));
        }
    }
    return dp[n];
}

时间复杂度为 O(n*log(n))。

Answer 2

首先，您正在检查错误数量的 2 次方。跳跃必须在以 2 的幂 在索引中分隔的建筑物之间，而不是高度不同（这是您正在检查的）。

其次，应该根据第一次跳转的成本和剩余跳转的成本（通过递归调用获得）来制定递归。您正在寻找所有合法第一次跳跃的最低成本。如果第一次跳转到的建筑物的索引小于 N 并且距离当前起点的索引为 2 的幂，则第一次跳转是合法的。

这样的事情应该可以工作：

int calc(int arr[], int beg, int end)
{
    if (beg == end)
        return 0;
    else if (beg > end)
        throw an exception

    int minEnergy = INFINITY;
    for (int i = 1;        // start with a step of 1
         beg + i <= end;   // test if we'd go too far
         i <<= 1)          // increase step to next power of 2
    {
        int energy = abs(arr[beg + i] - arr[beg])  // energy of first jump
                   + calc(arr, beg + i, end);      // remaining jumps
        if (energy < minEnergy) {
            minEnergy = energy;
        }
    }
    return minEnergy;
}

通过目前得到的最小能量可以大大提高这个搜索的效率。那么如果abs(arr[beg + i] - arr[beg]) 不小于那个数量，就没有必要进行递归调用，因为找到的东西永远不会更小。 （事实上​​，如果abs(arr[beg + i] - arr[beg]) + abs(arr[end] - arr[beg + i]) 不小于目前最好的解决方案，你可以切断递归，因为蜘蛛侠在构建beg + i 之后至少必须花费abs(arr[end] - arr[beg + i])。）添加这个改进保留为练习。 :)