LeetCode //C - 1306. Jump Game III

1306. Jump Game III

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 + arri or i - arri, check if you can reach any index with value 0.

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

Example 1:

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 .

Example 2:

Input: arr = 4,2,3,0,3,1,2, start = 0

Output: true

**Explanation: **

One possible way to reach at index 3 with value 0 is:

index 0 -> index 4 -> index 1 -> index 3

Example 3:

Input: arr = 3,0,2,1,2, start = 2

Output: false

Explanation: There is no way to reach at index 1 with value 0.

Constraints:

• 1 < = a r r . l e n g t h < = 5 ∗ 10 4 1 <= arr.length <= 5 * 10^4 1<=arr.length<=5∗104
• 0 <= arri < arr.length
• 0 <= start < arr.length

From: LeetCode

Link: 1306. Jump Game III

---

Solution:

Use BFS from start, visiting each reachable index once until finding a value 0.

Code:

bool canReach(int* arr, int arrSize, int start) {
    bool* visited = (bool*)calloc(arrSize, sizeof(bool));
    int* queue = (int*)malloc(arrSize * sizeof(int));

    int front = 0;
    int rear = 0;

    queue[rear++] = start;
    visited[start] = true;

    while (front < rear) {
        int index = queue[front++];

        if (arr[index] == 0) {
            free(visited);
            free(queue);
            return true;
        }

        int right = index + arr[index];
        int left = index - arr[index];

        if (right < arrSize && !visited[right]) {
            visited[right] = true;
            queue[rear++] = right;
        }

        if (left >= 0 && !visited[left]) {
            visited[left] = true;
            queue[rear++] = left;
        }
    }

    free(visited);
    free(queue);
    return false;
}