新方法

Question

给定一个 N 整数数组（元素为正数或-1），另一个整数 M 。
对于每个 1＆lt; = i＆lt; = N＆lt; i＆gt;，我们可以跳转到阵列的 i + 1，i + 2，... i + M 索引。从索引1开始，存在线性 O（N）算法，其可以找出最小成本以及到达N ^th索引的路径。其中cost是从1到N的路径中所有元素的总和。我有一个复杂度为 O（N * M）的动态编程解决方案。
注意：如果A [i]为-1，则意味着我们无法登陆i ^th索引。

Answer 1

如果我正确理解你的问题，A *可能会提供你最好的运行时间。对于每个 i ， i +1到 i + M 将是子节点，并且 h 是从 i 到 N 的成本，假设每个后续节点的成本为1（例如，如果 N = 11并且 M = 4然后 h = 3 i = 2，因为这将是达到最终索引所需的最小跳跃次数）。

Answer 2

新方法

Assumption：图表不加权图。

这种解释方法可以解决线性时间内的问题因此，算法如下所示。

int A[N];         // It contains the initial values
int result[N];    // Initialise all with positive infinty or INT_MAX in C
bool visited[N];  // Initially, all initialise with '0' means none of the index is visited

int current_index = 1
cost = 0
result[current_index] = cost
visited[current_index] = true

while(current_index less than N) {
    cost = cost + 1    // Increase the value of the cost by 1 in each level

    int last_index = -1 /* It plays the important role, it actually saves the last index 
                          which can be reached form the currnet index, it is initialised 
                          with -1, means it is not pointing to any valid index*/
    for(i in 1 to M) {
        temp_index = current_index + i;
        if(temp_index <= N   AND  visited[temp_index] == false   AND  A[temp_index] != -1) {
            result[temp_index] = cost
            visited[temp_index] = true
            last_index = temp_index
        }
    }

    if(last_index == -1) {
        print "Not possible to reach"
        break
    } else {
        current_index = last_index
    }
}

// Finally print the value of A[N]
print A[N]

当你完成这种方法时，请告诉我。

=============================================== ==========================

以前的方法

尽管如此，这种解释方法也不线性。但相信我，它会比你的动态方法更有效。因为在你的方法中它总是需要 O（NM）时间，但在这里它可以减少到 O（nM），其中 n 是数字否 -1值的数组中的元素。

Assumption:在这里，我正在考虑 A [1]和A [N] 的值不是-1。并且，数组中的不多于 M-1 连续-1值。否则，我们无法完成这项工作。

现在， BFS 描述如下：

int A[N];         // It contains the initial values
int result[N];    // Initialise all with positive infinty or INT_MAX in C
bool visited[N];  // Initially, all initialise with '0' means none of the index is visited
queue Q;          // create a queue 

index = 1
cost = 0
push index in rear of Q.
result[index] = cost
visited[index] = true

while(Q is not empty) {
    index = pop the value from the front of the Q.
    cost = cost + 1

    for(i in 1 to M) {
        temp_index = index + i;
        if(temp_index <= N   AND  visited[temp_index] == false   AND  A[temp_index] != -1) {
            push temp_index in rear of Q.
            result[temp_index] = cost
            visited[temp_index] = true
        }
    }
}

// Finally print the value of A[N]
print A[N]

注意：最差情况时间复杂度与DP之一相同。对算法有任何疑问，评论最受欢迎。而且，如果有人比我更好的方法，请分享。 毕竟，我们来这里学习。

这可以用线性时间复杂度来解决吗？

2 个答案:

新方法

以前的方法