Jump Game VII - Practice Coding Problems

Jump Game VII - Problem

Jump Game VII is an exciting path-finding challenge! You're given a binary string s where '0' represents safe ground and '1' represents dangerous terrain. Starting at index 0 (which is always '0'), you need to reach the last index of the string.

However, there are jump constraints: from any position i, you can only jump to position j if:
• The jump distance is between minJump and maxJump (inclusive)
• The destination s[j] is '0' (safe ground)

Goal: Return true if you can reach the final index, false otherwise.

Example: s = "011010", minJump = 2, maxJump = 3
From index 0 → can jump to indices 2,3 → from index 3 → can jump to index 5 ✅

Input & Output

example_1.py — Basic Jump

$ Input: s = "011010", minJump = 2, maxJump = 3

› Output: true

💡 Note: Starting at index 0, we can jump to index 2 or 3 (both are '0'). From index 3, we can jump to index 5 (which is '0' and the last index). Path: 0 → 3 → 5.

example_2.py — Impossible Jump

$ Input: s = "01101110", minJump = 2, maxJump = 3

› Output: false

💡 Note: From index 0, we can reach indices 2 and 3. From index 2, we can reach indices 4 and 5, but both are '1'. From index 3, we can reach indices 5 and 6, but both are '1'. No path exists to reach index 7.

example_3.py — Edge Case

$ Input: s = "0", minJump = 1, maxJump = 1

› Output: true

💡 Note: The string has only one character, and we start at index 0, which is already the last index. Therefore, we can reach the end.

Visualization

Tap to expand

Understanding the Visualization

Survey the River

Identify safe stones ('0') and dangerous stones ('1')

Track Jump Range

Maintain awareness of positions we can reach with current jump limits

Make Optimal Jumps

Use sliding window to efficiently determine next reachable positions

Reach the Goal

Successfully cross if we can reach the final stone

Key Takeaway

🎯 Key Insight: The sliding window technique transforms an O(n²) problem into O(n) by efficiently maintaining a count of reachable positions within the valid jumping range, avoiding redundant position checks.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string with O(1) operations per position

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track the sliding window

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'
s[0] == '0'
1 ≤ minJump ≤ maxJump < s.length

Asked in

G Google 32 a Amazon 28 f Meta 24 ⊞ Microsoft 18

The optimal approach uses a sliding window technique with prefix sum to efficiently track reachable positions within the valid jumping range. Instead of checking each previous position individually (O(n²)), we maintain a count of reachable positions in our current window, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming	O(n²)	O(n)	Use DP to track reachable positions and build solution bottom-up
Sliding Window with Prefix Sum (Optimal)	O(n)	O(1)	Use sliding window to efficiently track reachable positions within jumping range

Dynamic Programming — Algorithm Steps

Initialize DP array with dp[0] = true
For each position i, check if it's reachable from previous positions
A position j can reach position i if: j + minJump ≤ i ≤ j + maxJump and dp[j] is true
Return dp[n-1]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Set dp[0] = true, all others false

Process each position

For each position i, check if reachable from valid previous positions

Update reachability

Mark position as reachable if any valid predecessor is reachable

Return final state

Check if the last position is reachable

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int min(int a, int b) {
    return a < b ? a : b;
}

bool canReach(char* s, int minJump, int maxJump) {
    int n = strlen(s);
    if (s[n-1] == '1') return false;
    
    bool* dp = (bool*)calloc(n, sizeof(bool));
    dp[0] = true;
    
    for (int i = 1; i < n; i++) {
        if (s[i] == '0') {
            for (int j = max(0, i - maxJump); j <= min(i - minJump, i - 1); j++) {
                if (dp[j]) {
                    dp[i] = true;
                    break;
                }
            }
        }
    }
    
    bool result = dp[n-1];
    free(dp);
    return result;
}

int main() {
    char s[100001];
    int minJump, maxJump;
    scanf("%s %d %d", s, &minJump, &maxJump);
    
    printf("%s\n", canReach(s, minJump, maxJump) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each position, we check up to (maxJump-minJump+1) previous positions

⚠ Quadratic Growth

Space Complexity

O(n)

Space for the DP array

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'
s[0] == '0'
1 ≤ minJump ≤ maxJump < s.length

67.2K Views

Medium Frequency

~25 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler