Put Marbles in Bags - Practice Coding Problems

Put Marbles in Bags - Problem

Marble Distribution Challenge

You're managing a marble collection with k specialized storage bags. Each marble has a specific weight, and you must distribute all marbles according to strict rules.

Distribution Rules:
• Every bag must contain at least one marble
• Marbles must be placed in contiguous segments - if marbles at positions i and j are in the same bag, all marbles between them must also be in that bag
• Each bag's cost is calculated as: weight[first_marble] + weight[last_marble]

Your Mission: Find the difference between the maximum possible total cost and minimum possible total cost across all valid distributions.

Example: With marbles [1,3,5,1] and k=2 bags:
• Split [1] | [3,5,1]: cost = (1+1) + (3+1) = 6
• Split [1,3] | [5,1]: cost = (1+3) + (5+1) = 10
• Split [1,3,5] | [1]: cost = (1+5) + (1+1) = 8
Maximum cost (10) - Minimum cost (6) = 4

Input & Output

example_1.py — Basic Case

$ Input: weights = [1,3,5,1], k = 2

› Output: 4

💡 Note: The optimal distributions are: Min cost: [1] | [3,5,1] with cost (1+1) + (3+1) = 6. Max cost: [1,3] | [5,1] with cost (1+3) + (5+1) = 10. Difference: 10 - 6 = 4.

example_2.py — Three Bags

$ Input: weights = [1,3,5,1], k = 3

› Output: 4

💡 Note: With 3 bags, possible distributions: [1] | [3] | [5,1] = (1+1) + (3+3) + (5+1) = 14, [1] | [3,5] | [1] = (1+1) + (3+5) + (1+1) = 18, [1,3] | [5] | [1] = (1+3) + (5+5) + (1+1) = 20. Max: 20, Min: 14, Difference: 6.

example_3.py — Edge Case

$ Input: weights = [1,1,1,1], k = 2

› Output: 0

💡 Note: All marbles have the same weight, so all possible distributions yield the same cost. Any split like [1] | [1,1,1] gives cost (1+1) + (1+1) = 4. The difference between max and min is 0.

Constraints

1 ≤ k ≤ weights.length ≤ 10⁵
1 ≤ weights[i] ≤ 10⁹
No bag can be empty
Marbles must be placed in contiguous segments

Visualization

Tap to expand

Understanding the Visualization

Identify Boundaries

Each possible cut position between adjacent marbles has a cost equal to the sum of the two marbles it separates

Sort Options

Sort all possible boundary costs to identify the cheapest and most expensive cuts

Choose Optimally

For minimum cost, choose the k-1 cheapest cuts. For maximum cost, choose the k-1 most expensive cuts

Calculate Difference

The answer is the difference between the maximum and minimum possible total costs

Key Takeaway

🎯 Key Insight: The problem reduces to selecting k-1 optimal boundary cuts. By sorting all possible cut costs and choosing the cheapest for minimum and most expensive for maximum, we achieve optimal O(n log n) performance.

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a greedy boundary selection approach. The key insight is that every partition contributes the same first and last elements to the total cost. The difference comes from the k-1 internal boundaries we choose. By calculating and sorting all possible boundary costs (weights[i] + weights[i+1]), we can greedily select the k-1 smallest for minimum cost and k-1 largest for maximum cost, achieving O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Partitions	O(C(n-1, k-1) * k)	O(k)	Generate all possible ways to divide marbles into k contiguous groups
Greedy Boundary Selection	O(n log n)	O(n)	Focus on boundary costs - select k-1 boundaries optimally using sorting

Generate All Partitions — Algorithm Steps

Use recursive function to generate all ways to place k-1 dividers
For each partition, calculate cost as sum of (first + last) for each segment
Track the minimum and maximum costs encountered
Return the difference between max and min costs

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Recursion

Begin with empty partition, need to place k bags

Try All Positions

For current bag, try all valid ending positions

Calculate Cost

When partition complete, calculate total cost

Track Min/Max

Update minimum and maximum costs seen so far

Code -

solution.c — C

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

int minCost = INT_MAX;
int maxCost = 0;

void backtrack(int* weights, int n, int start, int bagsLeft, int currentCost) {
    if (bagsLeft == 1) {
        int bagCost = weights[start] + weights[n-1];
        int totalCost = currentCost + bagCost;
        if (totalCost < minCost) minCost = totalCost;
        if (totalCost > maxCost) maxCost = totalCost;
        return;
    }
    
    for (int end = start; end <= n - bagsLeft; end++) {
        int bagCost = weights[start] + weights[end];
        backtrack(weights, n, end + 1, bagsLeft - 1, currentCost + bagCost);
    }
}

int putMarblesInBags(int* weights, int n, int k) {
    if (k == 1) return 0;
    minCost = INT_MAX;
    maxCost = 0;
    backtrack(weights, n, 0, k, 0);
    return maxCost - minCost;
}

int main() {
    int weights[] = {1,3,5,1};
    int n = 4, k = 2;
    printf("%d\n", putMarblesInBags(weights, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n-1, k-1) * k)

We choose k-1 positions from n-1 possible divider positions, and for each partition we calculate cost in O(k) time

✓ Linear Growth

Space Complexity

O(k)

Recursion depth and space to store current partition

✓ Linear Space

28.4K Views

Medium-High Frequency

~18 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

Generate All Partitions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler