
### Problem Statement

###### Given an array of non-negative integers arr, you are initially positioned at start index of the array. When you are at index i, you can jump to i + arr[i] or i - arr[i], check if you can reach to any index with value 0.

###### Notice that you can not jump outside of the array at any time.

**INPUT**

- **arr = [4,2,3,0,3,1,2], start = 5**

**OUTPUT**

- **true**

**EXPLANATION**

All possible ways to reach at index 3 with value 0 are:

- index 5 -- index 4 -- index 1 -- index 3
- index 5 -- index 6 -- index 4 -- index 1 -- index 3

**Steps To Solve**

- Think of solution without code

  - Let us consider the example [4,2,3,0,3,1,2].
  - So we start at index 5.
  - From index 5 we can move towards two directions index (5 - 1 = 4) or index (5 + 1 = 6) as arr[5] is 1.
  - Similarly from index 4 we can move to index (4 - 3 = 1) and (4 + 3 = 7) and from index 6 we can move to index (6 - 2 = 4) and (6 + 2 = 8).
  - As index 7 and 8 is outside the array we cannot jump on it .
  - Next comes index 4 , we will neglect this too as index 4 was encountered earlier as well in the first level , so our calculation for index 4 will be taken care from that call.
  - Finally we are left with index 1 .
  - From index 1 we can reach to index (1 - 2 = -1) and (1 + 2 = 3).
  - We will neglect index -1 as it is out of bounds.
  - When we look at index 3 we see that it contains 0.
  - So finally we found our answer and return true.
  - One thing we can notice here that we check for indices level by level so this will be a perfect case to apply BFS.
  - Lets quickly jump to the code.

  ![FTL Jump](https://i.gifer.com/FFg5.gif)

```js
/**
 * @param {number[]} arr
 * @param {number} start
 * @return {boolean}
 */
var canReach = function (arr, start) {
  let jumpq = [];
  jumpq.push(start);

  while (jumpq.length) {
    let qlen = jumpq.length;

    while (qlen--) {
      let point = jumpq.pop();
      let nextlessindex = point - arr[point];
      let nextgreaterindex = point + arr[point];
      if (nextlessindex >= 0) {
        if (arr[nextlessindex] === 0) return true;
        else if (arr[nextlessindex] > 0) jumpq.push(nextlessindex);
      }

      if (nextgreaterindex < arr.length) {
        if (arr[nextgreaterindex] === 0) return true;
        else if (arr[nextgreaterindex] > 0) jumpq.push(nextgreaterindex);
      }
      arr[point] = -1;
    }
  }

  return false;
};
```

###### Time and Space Complexity

Time Complexity is **O(N)**.
Space complexity in this case is **O(N)**.
