Frog Jump

Frog Jump - Problem

A frog is crossing a river. The river is divided into some number of units, and at each unit, there may or may not exist a stone. The frog can jump on a stone, but it must not jump into the water.

Given a list of stones positions (in units) in sorted ascending order, determine if the frog can cross the river by landing on the last stone. Initially, the frog is on the first stone and assumes the first jump must be 1 unit.

If the frog's last jump was k units, its next jump must be either k - 1, k, or k + 1 units. The frog can only jump in the forward direction.

Input & Output

Example 1 — Basic Case

$ Input: stones = [0,1,3,5,6,8,12,17]

› Output: true

💡 Note: Frog can jump: 0→1 (jump 1), 1→3 (jump 2), 3→5 (jump 2), 5→6 (jump 1), 6→8 (jump 2), 8→12 (jump 4), 12→17 (jump 5)

Example 2 — Impossible Case

$ Input: stones = [0,1,2,3,4,8,9,11]

› Output: false

💡 Note: Gap from stone 4 to stone 8 is too large - frog cannot jump 4 units as maximum jump from position 4 would be 3 units

Example 3 — Edge Case

$ Input: stones = [0,1,3,6,10,15]

› Output: true

💡 Note: Path exists: 0→1 (jump 1), 1→3 (jump 2), 3→6 (jump 3), 6→10 (jump 4), 10→15 (jump 5)

Constraints

2 ≤ stones.length ≤ 2000
0 ≤ stones[i] ≤ 2³¹ - 1
stones[0] == 0
stones is sorted in strictly increasing order

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 32 f Facebook 28 M Microsoft 25

The key insight is to track what jump sizes can reach each stone position. The frog's jump constraint (k-1, k, or k+1) creates a dynamic programming structure. Best approach uses bottom-up DP with a 2D table. Time: O(n²), Space: O(n²)

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Create a DP table where dp[i][k] represents whether we can reach stone i with jump size k. Build the solution from the first stone to the last stone iteratively.

Brute Force DFS

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

Use depth-first search to explore every possible path. From each stone, try all three jump options (k-1, k, k+1) and recursively check if we can reach the end.

Memoization (Top-Down DP)

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

Use the same DFS approach but cache results for each (position, jump_size) pair. This eliminates redundant calculations when the same state is reached through different paths.

Bottom-Up Dynamic Programming — Algorithm Steps

Create DP table for each stone and jump size
Mark dp[1][1] = true (first jump must be 1)
For each stone, check possible next jumps and update DP

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[1][1] = true for first mandatory jump

Fill Table

For each stone, propagate possible jumps forward

Check End

See if last stone has any reachable jump sizes

Code -

solution.c — C

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

#define MAX_STONES 2000
#define MAX_JUMP 2000

bool dp[MAX_STONES][MAX_JUMP];

bool solution(int* stones, int stonesSize) {
    if (stonesSize < 2) {
        return stonesSize == 1;
    }
    
    if (stones[1] != 1) {
        return false;
    }
    
    memset(dp, false, sizeof(dp));
    dp[1][1] = true;  // First jump must be 1
    
    for (int i = 1; i < stonesSize; i++) {
        for (int jumpSize = 1; jumpSize < MAX_JUMP; jumpSize++) {
            if (!dp[i][jumpSize]) continue;
            
            for (int delta = -1; delta <= 1; delta++) {
                int nextJump = jumpSize + delta;
                if (nextJump <= 0) continue;
                
                int nextPos = stones[i] + nextJump;
                // Find next stone
                for (int j = i + 1; j < stonesSize; j++) {
                    if (stones[j] == nextPos) {
                        if (nextJump < MAX_JUMP) {
                            dp[j][nextJump] = true;
                        }
                        break;
                    } else if (stones[j] > nextPos) {
                        break;
                    }
                }
            }
        }
    }
    
    for (int jumpSize = 1; jumpSize < MAX_JUMP; jumpSize++) {
        if (dp[stonesSize - 1][jumpSize]) {
            return true;
        }
    }
    
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int stones[MAX_STONES];
    int stonesSize = 0;
    
    char* ptr = strchr(line, '[') + 1;
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        stones[stonesSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    bool result = solution(stones, stonesSize);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops: n stones × up to n possible jump sizes

✓ Linear Growth

Space Complexity

O(n²)

2D DP table with n stones × n jump sizes

⚡ Linearithmic Space

67.0K Views

High 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

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler