Jump Game VII

Jump Game VII - Problem

You are given a 0-indexed binary string s and two integers minJump and maxJump.

In the beginning, you are standing at index 0, which is equal to '0'. You can move from index i to index j if the following conditions are fulfilled:

i + minJump <= j <= min(i + maxJump, s.length - 1), and
s[j] == '0'

Return true if you can reach index s.length - 1 in s, or false otherwise.

Input & Output

Example 1 — Basic Jump Sequence

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

› Output: true

💡 Note: Start at index 0, jump to index 3 (jump of size 3), then jump to index 5 (jump of size 2). Both positions contain '0' and are within jump constraints.

Example 2 — Blocked Path

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

› Output: false

💡 Note: From index 0, we can reach index 2 or 3. From index 3, we can reach indices 5 or 6, but both contain '1'. No valid path to the last index.

Example 3 — Minimum Jump Only

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

› Output: false

💡 Note: From index 0, jump to index 1 ('1' - invalid). Cannot proceed further, so cannot reach index 3.

Constraints

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

Visualization

Tap to expand

Asked in

f Meta 25 G Google 20 a Amazon 18 M Microsoft 15

The key insight is to use dynamic programming to track reachable positions, optimized with a sliding window technique. The sliding window approach achieves optimal O(n) time by maintaining a count of reachable positions in the current jump range. Time: O(n), Space: O(n)

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Brute Force DFS

⏱️ Time: O(2^n) Space: O(n)

Use recursive DFS to explore all possible jump paths from position 0 to the last position. For each position, try all valid jumps within the minJump to maxJump range.

Dynamic Programming (Bottom-Up)

⏱️ Time: O(n × (maxJump - minJump)) Space: O(n)

Use bottom-up DP where dp[i] represents whether position i is reachable. Process positions from left to right, updating reachability based on previous positions.

Memoization (Top-Down DP)

⏱️ Time: O(n × (maxJump - minJump)) Space: O(n)

Use memoization to store the results of subproblems. Once we know whether a position is reachable or not, we don't need to recompute it again.

Sliding Window + Prefix Sum

⏱️ Time: O(n) Space: O(n)

Optimize the DP approach using a sliding window technique with prefix sum. Instead of checking each previous position individually, maintain a running count of reachable positions in the valid jump range.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char* solution(char* num, int* change) {
    int n = strlen(num);
    char* result = malloc((n + 1) * sizeof(char));
    strcpy(result, num);
    
    // Find the first position where we can improve
    int start = -1;
    for (int i = 0; i < n; i++) {
        int digit = result[i] - '0';
        if (change[digit] > digit) {
            start = i;
            break;
        }
    }
    
    // If no improvement possible, return original
    if (start == -1) {
        return result;
    }
    
    // Transform from start position while beneficial or neutral
    for (int i = start; i < n; i++) {
        int digit = result[i] - '0';
        if (change[digit] >= digit) {
            result[i] = change[digit] + '0';
        } else {
            break;
        }
    }
    
    return result;
}

int main() {
    char num[100001];
    fgets(num, sizeof(num), stdin);
    num[strcspn(num, "\n")] = 0;
    
    char changeLine[100];
    fgets(changeLine, sizeof(changeLine), stdin);
    
    // Parse array manually
    int change[10];
    char* token = strtok(changeLine + 1, ",]");
    int i = 0;
    while (token && i < 10) {
        change[i++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    char* result = solution(num, change);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

890 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