All Downloads are FREE. Search and download functionalities are using the official Maven repository.

g2501_2600.s2551_put_marbles_in_bags.Solution Maven / Gradle / Ivy

There is a newer version: 1.38
Show newest version
package g2501_2600.s2551_put_marbles_in_bags;

// #Hard #Array #Sorting #Greedy #Heap_Priority_Queue
// #2023_08_15_Time_33_ms_(99.82%)_Space_55.1_MB_(97.58%)

import java.util.Arrays;

/**
 * 2551 - Put Marbles in Bags\.
 *
 * Hard
 *
 * 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
**/
public class Solution {
    public long putMarbles(int[] weights, int k) {
        long minAns = weights[0] + (long) weights[weights.length - 1];
        long maxAns = weights[0] + (long) weights[weights.length - 1];
        long[] arr = new long[weights.length - 1];
        for (int i = 1; i < weights.length; i++) {
            arr[i - 1] = weights[i] + (long) weights[i - 1];
        }
        Arrays.sort(arr);
        for (int i = 0; i < k - 1; i++) {
            minAns = minAns + arr[i];
        }
        for (int i = arr.length - 1; i > arr.length - k; i--) {
            maxAns = maxAns + arr[i];
        }
        return maxAns - minAns;
    }
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy