如何从一个位置查找所有可能的可到达数字？

Question

Given 2 elements n, s and an array A of size m , where s is initial position which lies between 1 <= s <= n , our task is to perform m operations to s and in each operation we either make s = s + A[i] or s = s - A[i], and we have to print all the values which are possible after the m operation and all those value should lie between 1 - n (inclusive).

Important Note: If during an operation we get a value s < 1 or s > n, we don't go further with that value of s.

I solved the problem using BFS, but the problem is BFS approach is not optimal here, can someone suggest any other more optimal approach to me or an algorithm will greatly help.

For example:-

If n = 3, s = 3, and A = {1, 1, 1}

                            3
                         /     \
operation 1:           2         4  (we don’t proceed with 4 as it is > n)
                   /   \         /  \
operation 2:     1       3      3    5
                / \     / \    / \   / \
operation 3:   0   2   2   4  2   4  4  6

So final values reachable by following above rules are 2 and 2 (that is two times 2). we don't consider the third two as it has an intermediate state which is > n ( same case applicable if < 1).

Answer 1

There is this dynamic programming solution, which runs in O(nm) time and requires O(n) space.

First establish a boolean array called reachable , initialize it to false everywhere except for reachable[s] , which is true .

This array now represents whether a number is reachable in 0 steps. Now for every i from 1 to m , we update the array so that reachable[x] represents whether the number x is reachable in i steps. This is easy: x is reachable in i steps if and only if either x - A[i] or x + A[i] is reachable in i - 1 steps.

In the end, the array becomes the final result you want.

---

EDIT: pseudo-code here.

// initialization:
for x = 1 to n:
    r[x] = false
r[s] = true

// main loop:
for k = 1 to m:
    for x = 1 to n:
        last_r[x] = r[x]
    for x = 1 to n:
        r[x] = (last_r[x + A[k]] or last_r[x - A[k]])

Here last_r[x] is by convention false if x is not in the range [1 .. n] .

If you want to maintain the number of ways that each number can be reached, then you do the following changes:

1. Change the array r to an integer array;
2. In the initialization, initialize all r[x] to 0 , except r[s] to 1 ;

3. In the main loop, change the key line to:

   r[x] = last_r[x + A[k]] + last_r[x - A[k]]