Minimum Cost to Connect Sticks

Minimum Cost to Connect Sticks - Problem

You have some number of sticks with positive integer lengths. These lengths are given as an array sticks, where sticks[i] is the length of the i-th stick.

You can connect any two sticks of lengths x and y into one stick by paying a cost of x + y. You must connect all the sticks until there is only one stick remaining.

Return the minimum cost of connecting all the given sticks into one stick in this way.

Input & Output

Example 1 — Basic Case

$ Input: sticks = [2,4,3]

› Output: 14

💡 Note: Combine 2+3=5 (cost 5), then combine 5+4=9 (cost 9). Total cost = 5+9 = 14

Example 2 — Four Sticks

$ Input: sticks = [1,8,3,5]

› Output: 30

💡 Note: Optimal: 1+3=4 (cost 4), 4+5=9 (cost 9), 8+9=17 (cost 17). Total cost = 4+9+17 = 30

Example 3 — Single Stick

$ Input: sticks = [20]

› Output: 0

💡 Note: Only one stick, no combining needed, so cost is 0

Constraints

1 ≤ sticks.length ≤ 10⁴
1 ≤ sticks[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

a Amazon 42 G Google 35 f Facebook 28 M Microsoft 22

The key insight is that combining shorter sticks first minimizes the total cost since each intermediate result gets added multiple times. The greedy min-heap approach always combines the two shortest sticks, achieving optimal results. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2ⁿ) Space: O(n)

Generate all possible ways to combine sticks by trying every pair at each step. This involves exploring all permutations of combining operations, which leads to exponential time complexity.

Greedy with Min-Heap

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

Use a min-heap to always efficiently find and combine the two shortest sticks. This greedy approach ensures minimum cost because combining shorter sticks first reduces the total accumulated cost.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible combination sequences
Calculate cost for each sequence
Return minimum cost found

Visualization

Tap to expand

Step-by-Step Walkthrough

All Combinations

Try every possible pair at each step

Calculate Costs

Compute total cost for each combination sequence

Find Minimum

Return the sequence with lowest total cost

Code -

solution.c — C

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

int minCostHelper(int* sticks, int n) {
    if (n == 1) {
        return 0;
    }
    
    int minCost = INT_MAX;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int cost = sticks[i] + sticks[j];
            int* newSticks = (int*)malloc((n - 1) * sizeof(int));
            int idx = 0;
            
            for (int k = 0; k < n; k++) {
                if (k != i && k != j) {
                    newSticks[idx++] = sticks[k];
                }
            }
            newSticks[idx] = cost;
            
            int totalCost = cost + minCostHelper(newSticks, n - 1);
            if (totalCost < minCost) {
                minCost = totalCost;
            }
            
            free(newSticks);
        }
    }
    
    return minCost;
}

int solution(int* sticks, int n) {
    return minCostHelper(sticks, n);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int sticks[1000];
    int n = 0;
    
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            sticks[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", solution(sticks, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Exponential combinations of stick merging orders

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and temporary arrays

⚡ Linearithmic Space

38.5K Views

Medium Frequency

~15 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 - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler