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

Question

给定一个由 N 个整数组成的数组（元素为正数或 -1），以及另一个整数 M。
对于每个 1 ，我们可以跳转到数组的 i + 1, i + 2, .. i + M 索引。从索引 1 开始，有一个线性 O(N) 算法，可以找出最小成本以及到达 N^th 索引的路径。其中成本是从 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 for 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(N.M) 时间，但在这里它可以减少到 O(n.M)，其中 n 是数字数组中具有 no -1 值的元素。

Assumption: 在这里，我认为 A[1] 和 A[N] 的值不是-1。而且，数组中连续的-1 值不 多于M-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 相同。 对算法有任何疑问，欢迎 cmets。而且，如果有人比我有更好的方法，请分享。 毕竟，我们是来学习的。