2551. Put Marbles in Bags

You have k bags. You are given a 0-indexed integer array weights where weights[i] is the weight of the ith marble. You are also given the integer k.

Divide the marbles into the k bags according to the following rules:

• No bag is empty.
• If the ith marble and jth marble are in a bag, then all marbles with an index between the ith and jth indices should also be in that same bag.
• If a bag consists of all the marbles with an index from i to j inclusively, then the cost of the bag is weights[i] + weights[j].

The score after distributing the marbles is the sum of the costs of all the k bags.

Return the difference between the maximum and minimum scores among marble distributions.

Example 1:

Input: weights = [1,3,5,1], k = 2
Output: 4
Explanation:
The distribution [1],[3,5,1] results in the minimal score of (1+1) + (3+1) = 6.
The distribution [1,3],[5,1], results in the maximal score of (1+3) + (5+1) = 10.
Thus, we return their difference 10 - 6 = 4.

Example 2:

Input: weights = [1, 3], k = 2
Output: 0
Explanation: The only distribution possible is [1],[3].
Since both the maximal and minimal score are the same, we return 0.

Constraints:

• 1 <= k <= weights.length <= 105
• 1 <= weights[i] <= 109

Approach 01:

class Solution {
public:
    long long putMarbles(vector<int>& weights, int k) {
        vector<int> splitCosts;
        long minScore = 0;
        long maxScore = 0;

        for (int i = 0; i + 1 < weights.size(); ++i)
            splitCosts.push_back(weights[i] + weights[i + 1]);

        ranges::sort(splitCosts);

        for (int i = 0; i < k - 1; ++i) {
            minScore += splitCosts[i];
            maxScore += splitCosts[splitCosts.size() - 1 - i];
        }

        return maxScore - minScore;
    }
};

class Solution:
    def putMarbles(self, weights: List[int], k: int) -> int:
        splitCosts = []
        minScore = 0
        maxScore = 0

        for i in range(len(weights) - 1):
            splitCosts.append(weights[i] + weights[i + 1])

        splitCosts.sort()

        for i in range(k - 1):
            minScore += splitCosts[i]
            maxScore += splitCosts[-1 - i]

        return maxScore - minScore

Time Complexity:

• Computing Split Costs:

  Iterating through the array to compute adjacent pair sums takes \( O(n) \), where \( n \) is the length of weights.

• Sorting the Split Costs:

  Sorting the list splitCosts takes \( O(n \log n) \).

• Calculating Scores:

  Summing up the first and last \( k-1 \) elements in splitCosts takes \( O(k) \).

• Total Time Complexity:

  The dominant term is \( O(n \log n) \), making the overall time complexity \( O(n \log n) \).

Space Complexity:

• Split Costs Storage:

  The list splitCosts stores \( n-1 \) elements, taking \( O(n) \) space.

• Auxiliary Variables:

  Variables like minScore, maxScore, and loop counters take \( O(1) \) space.

• Total Space Complexity:

  The overall space complexity is \( O(n) \).