Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2551.html

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

Solutions

• Java
• C++
• Python
• Go
• TypeScript

• class Solution {
      public long putMarbles(int[] weights, int k) {
          int n = weights.length;
          int[] arr = new int[n - 1];
          for (int i = 0; i < n - 1; ++i) {
              arr[i] = weights[i] + weights[i + 1];
          }
          Arrays.sort(arr);
          long ans = 0;
          for (int i = 0; i < k - 1; ++i) {
              ans -= arr[i];
              ans += arr[n - 2 - i];
          }
          return ans;
      }
  }
  

• class Solution {
  public:
      long long putMarbles(vector<int>& weights, int k) {
          int n = weights.size();
          vector<int> arr(n - 1);
          for (int i = 0; i < n - 1; ++i) {
              arr[i] = weights[i] + weights[i + 1];
          }
          sort(arr.begin(), arr.end());
          long long ans = 0;
          for (int i = 0; i < k - 1; ++i) {
              ans -= arr[i];
              ans += arr[n - 2 - i];
          }
          return ans;
      }
  };
  

• class Solution:
      def putMarbles(self, weights: List[int], k: int) -> int:
          arr = sorted(a + b for a, b in pairwise(weights))
          return sum(arr[len(arr) - k + 1 :]) - sum(arr[: k - 1])
  
  

• func putMarbles(weights []int, k int) (ans int64) {
  	n := len(weights)
  	arr := make([]int, n-1)
  	for i, w := range weights[:n-1] {
  		arr[i] = w + weights[i+1]
  	}
  	sort.Ints(arr)
  	for i := 0; i < k-1; i++ {
  		ans += int64(arr[n-2-i] - arr[i])
  	}
  	return
  }
  

• function putMarbles(weights: number[], k: number): number {
      const n = weights.length;
      const arr: number[] = [];
      for (let i = 0; i < n - 1; ++i) {
          arr.push(weights[i] + weights[i + 1]);
      }
      arr.sort((a, b) => a - b);
      let ans = 0;
      for (let i = 0; i < k - 1; ++i) {
          ans += arr[n - i - 2] - arr[i];
      }
      return ans;
  }
  
  

All Problems

All Solutions