Minimum Cost to Reach Every Position - Practice Coding Problems

Minimum Cost to Reach Every Position - Problem

Array Easy

Imagine you're standing at the end of a line of n + 1 people (positions 0 to n), and you want to move forward to different positions. You start at position n (the very end) and want to calculate the minimum cost to reach every position from 0 to n-1.

Here's how the swapping works:

To move forward (swap with someone in front of you), you must pay them their specified cost
People behind you can swap with you for free (they want to move forward too!)

Given an array cost where cost[i] represents how much person i charges to swap places, return an array where answer[i] is the minimum total cost to reach position i.

The key insight is that once you pay to move forward, people behind you will help you move even further forward for free!

Input & Output

example_1.py — Small Array

$ Input: cost = [1, 3, 2]

› Output: [6, 5, 2]

💡 Note: To reach position 0: pay 1+3+2=6. To reach position 1: pay 3+2=5. To reach position 2: pay 2.

example_2.py — Single Element

$ Input: cost = [5]

› Output: [5]

💡 Note: Only one position to reach (position 0), and it costs 5 to swap with that person.

example_3.py — Increasing Costs

$ Input: cost = [1, 2, 3, 4]

› Output: [10, 9, 7, 4]

💡 Note: Position 0 costs 1+2+3+4=10. Position 1 costs 2+3+4=9. Position 2 costs 3+4=7. Position 3 costs 4.

Constraints

1 ≤ cost.length ≤ 10⁵
1 ≤ cost[i] ≤ 10⁶
You start at position n (end of line)
Positions are numbered from 0 to n

Visualization

Tap to expand

Understanding the Visualization

Start at Back

You begin at position n (end of line)

Pay to Advance

Pay each person their cost to swap places

Calculate Costs

Sum all costs from target position to end

Key Takeaway

🎯 Key Insight: Each position's minimum cost is simply the sum of all swap costs from that position to the end - this is exactly a suffix sum!

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 5

The optimal solution uses suffix sum technique. Since reaching position i requires paying everyone from position i to n-1, we can calculate this efficiently with a single right-to-left pass. Each position's answer is the sum of all costs from that position to the end. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Independent Calculation)	O(n²)	O(1)	Calculate minimum cost for each target position independently
Suffix Sum (Optimal)	O(n)	O(1)	Use suffix sum to calculate costs in single pass

Brute Force (Independent Calculation) — Algorithm Steps

For each target position i from 0 to n-1
Calculate minimum cost to reach position i from position n
Consider all people between position i and n
Find minimum cost path by trying different swap sequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Target Position 0

Calculate cost to reach position 0 from end

Target Position 1

Calculate cost to reach position 1 from end

Continue

Repeat for all positions independently

Code -

solution.c — C

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

int* minCostToReachPosition(int* cost, int n, int* returnSize) {
    *returnSize = n;
    int* result = (int*)malloc(n * sizeof(int));
    
    for (int target = 0; target < n; target++) {
        int minCost = 0;
        for (int i = target; i < n; i++) {
            minCost += cost[i];
        }
        result[target] = minCost;
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    int* cost = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &cost[i]);
    }
    
    int returnSize;
    int* result = minCostToReachPosition(cost, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(cost);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we potentially examine all n elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

23.4K Views

Medium Frequency

~12 min Avg. Time

892 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

Brute Force (Independent Calculation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler