LeetCode 1648. 销售价值减少的颜色球

1648. 销售价值减少的颜色球

【贪心】按照inventory的值来排序，优先用较大的来补充orders，但是我们发现数据范围是10^9啊，所以这个不能像6118. 最小差值平方和这道题一样用数组来存inventory的值，只能用哈希表来存值和出现次数，但是数据范围还是太大了，不能每次直接-1，所以只能每次减到下一个出现的inventory，但是问题又来了，减到这个的时候会不会已经超过orders范围了呢，所以这里还是需要做一个判断。

看🌰：假设有3个5，2个3，orders = 17，为了方便判断边界我们加入一个0，根据题目条件不会出现0并且保证orders一定被填满。

5 5 5

3 3

0

（1）首先我们从5开始搜索，他的下一个为3，当我们把所有的5都降到3个时能为orders提供 3 * (5 - 3) = 6个，同时此时的代价为 3 * (5 + 4) = 3 * ((5 + 3 + 1)  * (5 - 3) / 2)，前面3是5出现个数，后面是为了方便计算的等差数列求和公式。然后orders减去6。

为了方便还是用变量来表示吧，假设当前取出的为key，下一个边界为next，key出现次数为n，key到next还差t，那么首先要判断t * n 是否小于等于orders，然后把这些降到next花费的代价为：n * ( (key + next + 1) * (key - next) / 2)

（2）如果t * n 大于orders，说明还没降到next，此时我们先算降了多少即：t = orders / n；然后看看最后一层遗留多少：rem = orders % n；同理计算代价为：n * ( (key + key - t + 1) * t / 2 ) ) + rem * (key - t)

class Solution {

    // 贪心 + TreeMap 3:17 4:20

    public int maxProfit(int[] inventory, int orders) {
        long ans = 0;
        int mod = (int)1e9 + 7;
        TreeMap<Integer, Integer> map = new TreeMap<Integer, Integer>((a, b) -> b - a);
        for (var x: inventory) map.put(x, map.getOrDefault(x, 0) + 1);
        map.put(0, 0);
        while (orders > 0) {
            int key = map.firstKey();
            int n = map.get(key);
            map.remove(key);
            // 3 3 3    相差2，共三个，可以提供6次order
            // 1      
            int next = map.firstKey();
            int t = key - next;
            if ((long)t * n <= orders) {
                ans = (ans + (n * (((long)t * (key + next + 1) / 2)) % mod)) % mod;
                orders -= t * n;
                map.put(next, map.get(next) + n);
            } else {
                // 3 3 3  8
                //        2
                // 1
                t = orders / n;
                int rem = orders % n;
                ans = (ans + (n * (((long)t * (key + key - t + 1) / 2)) % mod)) % mod;
                ans = (ans + ((long)rem * (key - t))) % mod;
                orders = 0;
            }
        }
        return (int)ans;
    }
}

【贪心 + 二分】二分完成orders订单后的最大inventory值，这里用一个t来统计当最后结果为mid时，完成的订单数量，要求t<=orders，然后根据剩下的个数来增加mid个。

class Solution {

    // 贪心 + 二分 8:49 10:13

    public int maxProfit(int[] inventory, int orders) {
        int mod = (int)1e9 + 7;
        int left = 1, right = (int)1e9;
        long t = 0;
        while (left <= right) {
            int mid = (left + right) >>> 1;
            t = 0;
            for (var i = 0; i < inventory.length; i++) t += Math.max(0, inventory[i] - mid);
            // 如果t大了，说明mid取小了，应该往右区间找
            if (t > orders) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        System.out.println(left);
        t = 0;
        long ans = 0;
        for (var x: inventory) {
            if (x > left) {
                ans = (ans + ((long)(left + 1 + x) * (x - left) / 2 % mod)) % mod;
                t += x - left;
            }
        }
        int rem = orders - (int)t;
        for (var j = 0; j < rem; j++) {
            ans = (ans + left) % mod;
        }
        return (int)ans;
    }
}