Frog Jump II - Problem

You are given a 0-indexed integer array stones sorted in strictly increasing order representing the positions of stones in a river.

A frog, initially on the first stone, wants to travel to the last stone and then return to the first stone. However, it can jump to any stone at most once.

The length of a jump is the absolute difference between the position of the stone the frog is currently on and the position of the stone to which the frog jumps.

More formally, if the frog is at stones[i] and is jumping to stones[j], the length of the jump is |stones[i] - stones[j]|.

The cost of a path is the maximum length of a jump among all jumps in the path.

Return the minimum cost of a path for the frog.

Input & Output

Example 1 — Basic Case

$ Input: stones = [0,2,5,6,7]

› Output: 5

💡 Note: The optimal strategy uses alternating pattern. For path 0→2→6→7→5→0, jumps are [2,4,1,2,5] with maximum 5. For path 0→5→7→6→2→0, jumps are [5,2,1,4,2] with maximum 5. The minimum cost is 5.

Example 2 — Minimum Size

$ Input: stones = [0,10]

› Output: 0

💡 Note: Only two stones, frog starts at first and needs to reach second then return. No intermediate jumps needed.

Example 3 — Three Stones

$ Input: stones = [0,3,9]

› Output: 9

💡 Note: Path: 0→3→9→0. Jumps are [3,6,9]. The minimum maximum jump is 9.

Constraints

2 ≤ stones.length ≤ 10⁵
0 ≤ stones[i] ≤ 10⁹
stones[0] = 0
stones is sorted in strictly increasing order

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12

The key insight is that the optimal path uses an alternating strategy between odd and even positioned stones. The greedy approach gives us O(n) time complexity by recognizing that the answer is simply the maximum of stones[i] - stones[i-2] for all valid i.

Common Approaches

✓ Memoization

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

Dp 1d

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

Math

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

Binary Search on Answer

⏱️ Time: O(log(max) × 2^n) Space: O(n)

Use binary search on the possible maximum jump distances. For each candidate answer, check if it's possible to complete the round trip with no jump exceeding that distance.

Brute Force - Try All Paths

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

Try every possible way to visit all stones exactly once in a round trip from first to last and back. Calculate the maximum jump distance for each path and return the minimum.

Greedy - Alternating Strategy

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

The optimal strategy is to alternate between odd and even positioned stones. Go forward using odd positions, return using even positions (or vice versa), which naturally minimizes the maximum jump distance.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* stones, int n) {
    if (n <= 2) {
        return 0;
    }
    
    // Simplified approach - the answer is max of second largest gaps
    int result = 0;
    for (int i = 2; i < n; i++) {
        int gap = stones[i] - stones[i-2];
        if (gap > result) {
            result = gap;
        }
    }
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int stones[1000];
    int n = 0;
    
    // Skip opening bracket
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token != NULL && n < 1000) {
            stones[n++] = (int)strtol(token, NULL, 10);
            token = strtok(NULL, ",]");
        }
    }
    
    printf("%d\n", solution(stones, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.8K Views

Medium Frequency

~25 min Avg. Time

456 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

Frog Jump II - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Algorithm Steps — Algorithm Steps

Code -

Time & Space Complexity

Select Compiler