Frog Jump - Practice Coding Problems

Frog Jump - Problem

A determined frog embarks on an epic river crossing adventure! 🐸

The river is divided into discrete units, and at various positions there are stones that our brave frog can land on. The frog starts on the first stone and must reach the last stone to complete the journey.

Here's the catch - the frog has momentum-based jumping rules:

The first jump must be exactly 1 unit
If the last jump was k units, the next jump can only be k-1, k, or k+1 units
The frog can only jump forward and must land on stones (never in water!)

Goal: Given a sorted array of stone positions, determine if the frog can successfully cross the river by reaching the last stone.

Input: An array stones where stones[i] represents the position of the i-th stone
Output: true if the frog can cross, false otherwise

Input & Output

example_1.py — Basic Success Case

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

› Output: true

💡 Note: The frog can successfully cross: 0→1 (jump 1) → 3 (jump 2) → 5 (jump 2) → 6 (jump 1) → 8 (jump 2) → 12 (jump 4) → 17 (jump 5). Each jump follows the k-1, k, k+1 rule.

example_2.py — Impossible Case

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

› Output: false

💡 Note: The frog cannot reach the end. From stone 4, the frog needs jump sizes 4, 5, or 6 to continue, but no stones exist at positions 8, 9, or 10 that would allow reaching stone 8.

example_3.py — Edge Case

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

› Output: true

💡 Note: Path: 0→1 (jump 1) → 3 (jump 2) → 6 (jump 3) → 10 (jump 4) → 15 (jump 5) → 16 (jump 1) → 21 (jump 5). The frog can adjust jump size as needed.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Initial Position

Frog starts at stone 0, must make first jump of exactly 1 unit

Momentum Rules

After jump of size k, next jump must be k-1, k, or k+1 units

Path Finding

Use DP to explore all valid combinations of (position, jump_size)

Success Check

Return true if any path reaches the final stone

Key Takeaway

🎯 Key Insight: By memoizing (position, jump_size) states, we avoid exponential recalculation and solve the problem efficiently in O(n²) time.

Asked in

G Google 85 a Amazon 72 f Meta 58 ⊞ Microsoft 45 Apple 31

The optimal approach uses memoized dynamic programming to track valid (position, jump_size) combinations. By caching results and using a hash set for O(1) stone lookups, we achieve O(n²) time complexity instead of the exponential brute force approach. The key insight is that each unique state only needs to be computed once.

Common Approaches

Approach	Time	Space	Notes
✓ Memoized Dynamic Programming	O(n²)	O(n²)	Use memoization to avoid recalculating the same (position, jump_size) pairs

Memoized Dynamic Programming — Algorithm Steps

Create a memoization cache for (stone_index, jump_size) pairs
For each state, check if result is already cached
If not cached, try all three possible jumps (k-1, k, k+1)
Cache and return the result for this state
Use binary search or hash set for efficient stone lookup

Visualization

Tap to expand

Step-by-Step Walkthrough

Cache States

Store results for each (position, jump_size) combination

Check Cache

Before exploring, check if this state was already computed

Compute Once

Each unique state is only computed once

Reuse Results

Return cached results for previously seen states

Code -

solution.c — C

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

#define MAX_STONES 2000
#define HASH_SIZE 10007

typedef struct HashNode {
    char key[32];
    bool value;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];
bool stoneSet[MAX_STONES + 1];

unsigned int hash(const char* key) {
    unsigned int hash = 0;
    while (*key) {
        hash = hash * 31 + *key++;
    }
    return hash % HASH_SIZE;
}

bool getMemo(int pos, int jumpSize) {
    char key[32];
    sprintf(key, "%d,%d", pos, jumpSize);
    
    unsigned int h = hash(key);
    HashNode* node = hashTable[h];
    
    while (node) {
        if (strcmp(node->key, key) == 0) {
            return node->value;
        }
        node = node->next;
    }
    return false; // Not found
}

void setMemo(int pos, int jumpSize, bool value) {
    char key[32];
    sprintf(key, "%d,%d", pos, jumpSize);
    
    unsigned int h = hash(key);
    HashNode* node = (HashNode*)malloc(sizeof(HashNode));
    strcpy(node->key, key);
    node->value = value;
    node->next = hashTable[h];
    hashTable[h] = node;
}

bool hasMemo(int pos, int jumpSize) {
    char key[32];
    sprintf(key, "%d,%d", pos, jumpSize);
    
    unsigned int h = hash(key);
    HashNode* node = hashTable[h];
    
    while (node) {
        if (strcmp(node->key, key) == 0) {
            return true;
        }
        node = node->next;
    }
    return false;
}

bool dfs(int pos, int jumpSize, int target) {
    if (pos == target) {
        return true;
    }
    
    if (hasMemo(pos, jumpSize)) {
        return getMemo(pos, jumpSize);
    }
    
    bool result = false;
    int jumps[] = {jumpSize - 1, jumpSize, jumpSize + 1};
    
    for (int i = 0; i < 3; i++) {
        int nextJump = jumps[i];
        if (nextJump > 0) {
            int nextPos = pos + nextJump;
            if (nextPos <= MAX_STONES && stoneSet[nextPos] && dfs(nextPos, nextJump, target)) {
                result = true;
                break;
            }
        }
    }
    
    setMemo(pos, jumpSize, result);
    return result;
}

bool canCross(int* stones, int stonesSize) {
    if (stonesSize < 2) return stonesSize == 1;
    if (stones[1] != 1) return false;
    
    // Initialize hash table
    memset(hashTable, 0, sizeof(hashTable));
    memset(stoneSet, false, sizeof(stoneSet));
    
    // Build stone set
    for (int i = 0; i < stonesSize; i++) {
        stoneSet[stones[i]] = true;
    }
    
    return dfs(1, 1, stones[stonesSize - 1]);
}

int main() {
    int n;
    scanf("%d", &n);
    int* stones = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        scanf("%d", &stones[i]);
    }
    
    printf("%s\n", canCross(stones, n) ? "true" : "false");
    
    free(stones);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each of n stones can be reached with at most n different jump sizes, and each lookup is O(1) with hash set

⚠ Quadratic Growth

Space Complexity

O(n²)

Memoization table stores up to n×n states plus recursion stack

⚠ Quadratic Space

89.7K Views

High Frequency

~25 min Avg. Time

2.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

Memoized Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler