2551. Put Marbles in Bags

Posted on Edited on In

2551. Put Marbles in Bags

Description

You have k bags. You are given a 0-indexed integer array weights where weights[i] is the weight of the i^th 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 i^th marble and j^th marble are in a bag, then all marbles with an index between the i^th and j^th 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:

1
2
3
4
5
6
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:

1
2
3
4
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 <= 10^5
  • 1 <= weights[i] <= 10^9

Hints/Notes

Solution

Language: C++

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Solution {
public:
    long long putMarbles(vector<int>& weights, int k) {
        if (k == 1) {
            return 0;
        }
        int n = weights.size();
        long long mi = weights[0] + weights[n - 1], mx = weights[0] + weights[n - 1];
        // it's pick k - 1 intervals from all the intervals
        vector<int> intervals;
        for (int i = 0; i < n - 1; i ++) {
            intervals.push_back(weights[i] + weights[i + 1]);
        }
        sort(intervals.begin(), intervals.end());
        for (int i = 0; i < k - 1; i++) {
            mi += intervals[i];
        }
        sort(intervals.begin(), intervals.end(), greater<int>());
        for (int i = 0; i < k - 1; i++) {
            mx += intervals[i];
        }
        return mx - mi;
    }
};