Jump Game III - Practice Coding Problems

Jump Game III - Problem

🎯 Jump Game III: Finding the Zero

Imagine you're playing a unique board game where you can only move in specific patterns! You start at a given position on an array of non-negative integers, and your goal is to reach any cell containing zero.

The Rules:

When you're at index i, you have exactly two movement options:
Jump forward to i + arr[i]
Jump backward to i - arr[i]
You cannot jump outside the array bounds
You win if you can reach any index where the value is 0

Example: If you're at index 2 in array [4,2,3,0,3,1,2] and the value is 3, you can jump to index 5 (2+3) or index -1 (invalid, so not allowed).

Return true if you can reach a zero, false otherwise.

Input & Output

example_1.py — Basic reachable zero

$ Input: arr = [4,2,3,0,3,1,2], start = 2

› Output: true

💡 Note: Start at index 2 (value=3). Jump forward: 2+3=5 (value=1). From index 5: jump backward 5-1=4 (value=3), or forward 5+1=6 (value=2). From index 4: jump to 4+3=7 (out of bounds) or 4-3=1 (value=2). From index 1: jump to 1+2=3 (value=0) - found zero!

example_2.py — Unreachable zero

$ Input: arr = [4,2,3,0,3,1,2], start = 0

› Output: false

💡 Note: Start at index 0 (value=4). Jump forward: 0+4=4 (value=3). From index 4: jump to 4+3=7 (out of bounds) or 4-3=1 (value=2). From index 1: jump to 1+2=3 (value=0) or 1-2=-1 (out of bounds). Wait, we can reach the zero! This would actually be true.

example_3.py — Start at zero

$ Input: arr = [3,0,2,1,2], start = 1

› Output: true

💡 Note: Start at index 1 which has value 0. Since we're already at a position with value 0, return true immediately.

Constraints

1 ≤ arr.length ≤ 5 × 10⁴
0 ≤ arr[i] < arr.length
0 ≤ start < arr.length
Each array value is non-negative

Visualization

Tap to expand

Understanding the Visualization

Model as Graph

Each array index is a node, with directed edges to positions i+arr[i] and i-arr[i]

Choose Traversal

Use BFS for shortest path or DFS for memory efficiency, both with visited tracking

Explore Systematically

Visit each reachable position exactly once, checking for zero values

Avoid Cycles

Use visited set to prevent infinite loops in the graph

Return Result

Return true if any reachable position contains zero

Key Takeaway

🎯 Key Insight: Transform the jumping problem into graph traversal. Each position is a node with at most 2 outgoing edges. Use BFS or DFS with visited tracking to systematically explore all reachable positions in O(n) time.

Asked in

a Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses BFS or DFS with visited tracking to explore all reachable positions. The key insight is recognizing this as a graph traversal problem where each array index is a node with edges to at most two other nodes (i+arr[i] and i-arr[i]). Both BFS and DFS achieve O(n) time complexity by visiting each position at most once.

Common Approaches

Approach	Time	Space	Notes
✓ Breadth-First Search (BFS) - Optimal	O(n)	O(n)	Use BFS with queue to explore all positions level by level, guaranteeing shortest path
Depth-First Search (DFS)	O(n)	O(n)	Use DFS with visited tracking to explore all reachable positions systematically

Breadth-First Search (BFS) - Optimal — Algorithm Steps

Initialize a queue with the starting position
Mark starting position as visited
While queue is not empty, process current position
If current position has value 0, return true
Add valid unvisited forward/backward positions to queue
Mark newly added positions as visited
Return false if queue becomes empty without finding zero

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Add starting position to queue and mark as visited

Process Current

Remove position from queue front, check if value is 0

Add Neighbors

Add valid unvisited forward/backward positions to queue rear

Mark Visited

Mark newly added positions as visited to avoid cycles

Continue BFS

Repeat until queue is empty or zero is found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool canReach(int* arr, int size, int start) {
    if (arr[start] == 0) {
        return true;
    }
    
    int* queue = (int*)malloc(size * sizeof(int));
    bool* visited = (bool*)calloc(size, sizeof(bool));
    int front = 0, rear = 0;
    
    queue[rear++] = start;
    visited[start] = true;
    
    while (front < rear) {
        int pos = queue[front++];
        
        // Try both directions
        int nextPositions[2] = {pos + arr[pos], pos - arr[pos]};
        for (int i = 0; i < 2; i++) {
            int nextPos = nextPositions[i];
            if (nextPos >= 0 && nextPos < size && !visited[nextPos]) {
                if (arr[nextPos] == 0) {
                    free(queue);
                    free(visited);
                    return true;
                }
                visited[nextPos] = true;
                queue[rear++] = nextPos;
            }
        }
    }
    
    free(queue);
    free(visited);
    return false;
}

int main() {
    int arr[1000], size = 0, start;
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, " ");
    while (token != NULL) {
        arr[size++] = atoi(token);
        token = strtok(NULL, " ");
    }
    scanf("%d", &start);
    printf("%s\n", canReach(arr, size, start) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each position is visited at most once and added to queue once

✓ Linear Growth

Space Complexity

O(n)

Space for queue and visited set, both can be up to O(n) in size

⚡ Linearithmic Space

89.5K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

🎯 Jump Game III: Finding the Zero

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Breadth-First Search (BFS) - Optimal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler