Coin Path - Practice Coding Problems

Coin Path - Problem

Imagine navigating through a platformer game where you start at the first platform and need to reach the final platform with the minimum cost. You have a limited jump range and must pay a toll to land on each platform!

Given a 1-indexed array coins where coins[i] represents the cost to land on platform i (or -1 if blocked), and an integer maxJump representing your maximum jump distance, find the lexicographically smallest path that reaches the final platform with minimum cost.

Rules:

Start at index 1 (guaranteed to be accessible)
From index i, you can jump to any index i + k where 1 ≤ k ≤ maxJump
Cannot land on blocked platforms (where coins[i] = -1)
Pay coins[i] cost when visiting index i
If multiple paths have the same minimum cost, return the lexicographically smallest one

Example: coins = [1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, 0], maxJump = 6
You can jump from index 1 → 10 → 16 with total cost 1+0+0 = 1

Input & Output

example_1.py — Basic Path Finding

$ Input: coins = [1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, 0], maxJump = 6

› Output: [1, 10, 16]

💡 Note: Start at index 1 (cost 1), jump to index 10 (cost 0), then jump to index 16 (cost 0). Total cost = 1 + 0 + 0 = 1. This is the minimum cost path.

example_2.py — Lexicographically Smallest Path

$ Input: coins = [1, 2, 4, -1, 2], maxJump = 2

› Output: [1, 3, 5]

💡 Note: Two paths exist: [1,3,5] with cost 1+4+2=7 and [1,2,5] with cost 1+2+2=5. The second path has lower cost, but we need to check if [1,3,5] is also optimal. Actually [1,2,5] is cheaper, so answer is [1,2,5].

example_3.py — Impossible Path

$ Input: coins = [1, 2, -1], maxJump = 1

› Output: []

💡 Note: Cannot reach the end because index 3 (coins[2]) is blocked with value -1, and maxJump=1 means we can only jump 1 position at a time.

Constraints

1 ≤ coins.length ≤ 1000
0 ≤ coins[i] ≤ 10⁹ or coins[i] = -1
1 ≤ maxJump ≤ 1000
coins[0] ≠ -1 (starting position is always accessible)

Visualization

Tap to expand

Understanding the Visualization

Initialize Costs

Set up DP array where dp[i] represents minimum cost to reach platform i

Forward Pass

For each platform, calculate costs to reach all platforms within jumping distance

Backward Reconstruction

Starting from the end, trace back the optimal path by choosing lexicographically smallest jumps

Return Path

Output the complete path from start to end platform

Key Takeaway

🎯 Key Insight: Use DP for cost optimization, then reconstruct the lexicographically smallest path by working backwards and greedily choosing the smallest valid previous position at each step.

Asked in

G Google 15 a Amazon 8 ⊞ Microsoft 5 f Meta 3

The optimal approach uses dynamic programming to compute minimum costs in O(n × maxJump) time, then reconstructs the lexicographically smallest path by working backwards and greedily choosing the smallest valid jump at each step. Key insight: separate the cost optimization from path reconstruction for clean, efficient solution.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming + Path Reconstruction	O(n × maxJump)	O(n)	Use DP to find minimum costs, then reconstruct the lexicographically smallest optimal path

Dynamic Programming + Path Reconstruction — Algorithm Steps

Initialize DP array where dp[i] = minimum cost to reach position i
For each position, try all valid jumps and update minimum costs
After DP computation, work backwards from the destination
At each step, choose the smallest index that leads to optimal solution
Reconstruct the complete path from start to end

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP array

Set dp[0] = coins[0], others to infinity

Fill DP table

For each position, update reachable positions with minimum cost

Reconstruct path

Work backwards from destination, choosing lexicographically smallest optimal jumps

Return path

Reverse the reconstructed path to get start-to-end sequence

Code -

solution.c — C

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

int* cheapestJump(int* coins, int coinsSize, int maxJump, int* returnSize) {
    if (coinsSize == 0 || coins[0] == -1 || coins[coinsSize-1] == -1) {
        *returnSize = 0;
        return NULL;
    }
    
    // DP to find minimum cost to reach each position
    int* dp = (int*)malloc(coinsSize * sizeof(int));
    for (int i = 0; i < coinsSize; i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = coins[0];
    
    for (int i = 0; i < coinsSize; i++) {
        if (dp[i] == INT_MAX || coins[i] == -1) {
            continue;
        }
        
        int maxReach = (i + maxJump + 1 < coinsSize) ? i + maxJump + 1 : coinsSize;
        
        for (int j = i + 1; j < maxReach; j++) {
            if (coins[j] != -1) {
                if (dp[i] + coins[j] < dp[j]) {
                    dp[j] = dp[i] + coins[j];
                }
            }
        }
    }
    
    // If destination is unreachable
    if (dp[coinsSize-1] == INT_MAX) {
        free(dp);
        *returnSize = 0;
        return NULL;
    }
    
    // Reconstruct lexicographically smallest path
    int* path = (int*)malloc(coinsSize * sizeof(int));
    int pathSize = 0;
    int pos = coinsSize - 1;
    
    while (pos >= 0) {
        path[pathSize++] = pos + 1; // Convert to 1-indexed
        if (pos == 0) break;
        
        // Find the smallest index that can reach current position optimally
        int start = (pos - maxJump > 0) ? pos - maxJump : 0;
        
        for (int prev = start; prev < pos; prev++) {
            if (coins[prev] != -1 && dp[prev] != INT_MAX &&
                dp[prev] + coins[pos] == dp[pos]) {
                pos = prev;
                break;
            }
        }
    }
    
    // Reverse the path
    for (int i = 0; i < pathSize / 2; i++) {
        int temp = path[i];
        path[i] = path[pathSize - 1 - i];
        path[pathSize - 1 - i] = temp;
    }
    
    free(dp);
    *returnSize = pathSize;
    return path;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × maxJump)

First pass fills DP array (n × maxJump), second pass reconstructs path (n × maxJump)

✓ Linear Growth

Space Complexity

O(n)

DP array and path storage both require O(n) space

⚡ Linearithmic Space

18.2K Views

Medium Frequency

~25 min Avg. Time

480 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

Dynamic Programming + Path Reconstruction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler