Leetcode周赛214_你有一些球的库存 inventory-优快云博客

本文链接：https://blog.youkuaiyun.com/wangxianse/article/details/109580419

题目链接https://leetcode-cn.com/problems/get-maximum-in-generated-array/

给你一个整数 n 。按下述规则生成一个长度为 n + 1 的数组 nums ：

nums[0] = 0
nums[1] = 1
当 2 <= 2 * i <= n 时，nums[2 * i] = nums[i]
当 2 <= 2 * i + 1 <= n 时，nums[2 * i + 1] = nums[i] + nums[i + 1]

返回生成数组 nums 中的最大值。

示例 1：

输入：n = 7
输出：3
解释：根据规则：
  nums[0] = 0
  nums[1] = 1
  nums[(1 * 2) = 2] = nums[1] = 1
  nums[(1 * 2) + 1 = 3] = nums[1] + nums[2] = 1 + 1 = 2
  nums[(2 * 2) = 4] = nums[2] = 1
  nums[(2 * 2) + 1 = 5] = nums[2] + nums[3] = 1 + 2 = 3
  nums[(3 * 2) = 6] = nums[3] = 2
  nums[(3 * 2) + 1 = 7] = nums[3] + nums[4] = 2 + 1 = 3
因此，nums = [0,1,1,2,1,3,2,3]，最大值 3

示例 2：

输入：n = 2
输出：1
解释：根据规则，nums[0]、nums[1] 和 nums[2] 之中的最大值是 1

示例 3：

输入：n = 3
输出：2
解释：根据规则，nums[0]、nums[1]、nums[2] 和 nums[3] 之中的最大值是 2

提示：

0 <= n <= 100

难度：简单

思路:按照题目给的规则进行枚举，同时取最大值。

class Solution {
    public int getMaximumGenerated(int n) {
        int[] f=new int[n+5];
        int i,j,k=0,res=0;
        if(n==0||n==1) return n;
        f[0]=0;f[1]=1;
        i=1;
       
        while(2*i<=n){
            k=2*i;
            f[k]=f[i];
            res=Math.max(res,f[k]);
            if(k==n) break;
            f[k+1]=f[i]+f[i+1];
            res=Math.max(res,f[k+1]);
            i++;
        }
        return res;
    }
}

第二题：字符频次唯一的最小删除次数

题目链接：https://leetcode-cn.com/problems/minimum-deletions-to-make-character-frequencies-unique/

如果字符串 s 中不存在两个不同字符频次相同的情况，就称 s 是优质字符串。

给你一个字符串 s，返回使 s 成为优质字符串需要删除的最小字符数。

字符串中字符的频次是该字符在字符串中的出现次数。例如，在字符串 "aab" 中，'a' 的频次是 2，而 'b' 的频次是 1 。

示例 1：

输入：s = "aab"
输出：0
解释：s 已经是优质字符串。
示例 2：

输入：s = "aaabbbcc"
输出：2
解释：可以删除两个 'b' , 得到优质字符串 "aaabcc" 。
另一种方式是删除一个 'b' 和一个 'c' ，得到优质字符串 "aaabbc" 。
示例 3：

输入：s = "ceabaacb"
输出：2
解释：可以删除两个 'c' 得到优质字符串 "eabaab" 。
注意，只需要关注结果字符串中仍然存在的字符。（即，频次为 0 的字符会忽略不计。）

提示：

1 <= s.length <= 105
s 仅含小写英文字母

难度：中等

思路：由于都是小写字母，何为优质字符串：字符串中每个字符出现的次数都不唯一，即为优质字符串。进行删除最少的字符，使字符串优质。

举例：aaabbbccdd

a:频次3，b:频次3，c：频次2，d频次2；

首先 a和b出现的频次都是3次，是不是删除一个a或者b，频次为3的字符就只剩下一个，此时该字符是优质字符。删除a；a:频次2，b:频次3，c：频次2，d频次2；

此时：a,c,d,的频次都是2（注意a初始频次为3 ，删除一个后，加入到频次的2的队伍中）。这时候需要删除a,c,d中任意两个字符后频次为的2就只剩下一个，频次为2的达到优质字符串的要求，假设删a,c；

a:频次1，b:频次3，c：频次1，d频次2；

最后：此时频次为1的有a,c，需要删除一个，假设删除a; a:频次0，b:频次3，c：频次1，d频次2；最后为bbbcdd，需要删除4个字符。

第一步：应该想到的是开一个大小26的数组，来统计每个字母的数量。

第二步：根据例子可以想到是不是可以对频次进行排序啊，然后有频次大开始，依次枚举频次，进行字符删除。需要主要的是当一个频次出现0时，初始频次比他小的都应该删除。

class Solution {
    public int minDeletions(String s) {
        int[] count=new int[30];
        int i,j,k=0;
        for(i=0;i<s.length();i++){
            count[s.charAt(i)-'a']++;
        }
        Arrays.sort(count);
        for(i=28;i>=0;i--){
            if(count[i]==0) break;
            if(count[i]>=count[i+1]&&count[i+1]!=0){
                k=k+count[i]-count[i+1]+1;
                count[i]=count[i+1]-1;
            }else if(count[i+1]==0){
                k+=count[i];
                count[i]=0;
            }
        }
        return k;
    }
}

第三题：销售价值减少的颜色球

题目链接：https://leetcode-cn.com/problems/sell-diminishing-valued-colored-balls/

你有一些球的库存 inventory ，里面包含着不同颜色的球。一个顾客想要任意颜色总数为 orders 的球。

这位顾客有一种特殊的方式衡量球的价值：每个球的价值是目前剩下的同色球的数目。比方说还剩下 6 个黄球，那么顾客买第一个黄球的时候该黄球的价值为 6 。这笔交易以后，只剩下 5 个黄球了，所以下一个黄球的价值为 5 （也就是球的价值随着顾客购买同色球是递减的）

给你整数数组 inventory ，其中 inventory[i] 表示第 i 种颜色球一开始的数目。同时给你整数 orders ，表示顾客总共想买的球数目。你可以按照任意顺序卖球。

请你返回卖了 orders 个球以后最大总价值之和。由于答案可能会很大，请你返回答案对 109 + 7 取余数的结果。

示例 1：

输入：inventory = [2,5], orders = 4
输出：14
解释：卖 1 个第一种颜色的球（价值为 2 )，卖 3 个第二种颜色的球（价值为 5 + 4 + 3）。
最大总和为 2 + 5 + 4 + 3 = 14 。
示例 2：

输入：inventory = [3,5], orders = 6
输出：19
解释：卖 2 个第一种颜色的球（价值为 3 + 2），卖 4 个第二种颜色的球（价值为 5 + 4 + 3 + 2）。
最大总和为 3 + 2 + 5 + 4 + 3 + 2 = 19 。
示例 3：

输入：inventory = [2,8,4,10,6], orders = 20
输出：110
示例 4：

输入：inventory = [1000000000], orders = 1000000000
输出：21
解释：卖 1000000000 次第一种颜色的球，总价值为 500000000500000000 。 500000000500000000 对 109 + 7 取余为 21 。

提示：

1 <= inventory.length <= 105
1 <= inventory[i] <= 109
1 <= orders <= min(sum(inventory[i]), 109)

难度：中等

思路：刚开始想的只用优先队列，每次取最大值，看最大值和次大值的差值，即为此次可以取得球数。但是超时。

其实这道题和第二题思路差不多。对数组排序，取高度h为当前最大值的次大值的差值。宽度为已经遍历过得下表+1。

然后判断当前orders和当前的w*h的大小。

大于orders表示最大值不能取到次大值时orders就减到0；需要计算下，取到哪个位置时orders为0；

小于orders是最大值可以取到次大值。将球的结果分值加入到res中。

class Solution {
    public int maxProfit(int[] inventory, int orders) {
        Arrays.sort(inventory);
        int i,n=inventory.length;
        long j,k,res=0;
        for(i=n-1;i>=0&&orders>0;i--){
            long h;
            if(i!=0){
                h=inventory[i]-inventory[i-1];
            }else{
                h=inventory[i];
            }
            long ans;
            ans=h*(n-i);
            if(ans<=orders){
                orders-=h*(n-i);
                res=(res+(n-i)*h*(inventory[i]-h+1+inventory[i])/2)%1000000007;
            }else{
                h=orders/(n-i);
                k=orders%(n-i);
                res=(res+(n-i)*h*(inventory[i]-h+1+inventory[i])/2)%1000000007;
                res=(res+(inventory[i]-h)*k)%1000000007;
                break;
            }
        }
        return (int)res;
    }
}

第四题：通过指令创建有序数组

题目链接：https://leetcode-cn.com/problems/create-sorted-array-through-instructions/

给你一个整数数组 instructions ，你需要根据 instructions 中的元素创建一个有序数组。一开始你有一个空的数组 nums ，你需要从左到右遍历 instructions 中的元素，将它们依次插入 nums 数组中。每一次插入操作的代价是以下两者的较小值：

nums 中严格小于  instructions[i] 的数字数目。
nums 中严格大于  instructions[i] 的数字数目。
比方说，如果要将 3 插入到 nums = [1,2,3,5] ，那么插入操作的代价为 min(2, 1) (元素 1 和  2 小于 3 ，元素 5 大于 3 ），插入后 nums 变成 [1,2,3,3,5] 。

请你返回将 instructions 中所有元素依次插入 nums 后的总最小代价。由于答案会很大，请将它对 109 + 7 取余后返回。

示例 1：

输入：instructions = [1,5,6,2]
输出：1
解释：一开始 nums = [] 。
插入 1 ，代价为 min(0, 0) = 0 ，现在 nums = [1] 。
插入 5 ，代价为 min(1, 0) = 0 ，现在 nums = [1,5] 。
插入 6 ，代价为 min(2, 0) = 0 ，现在 nums = [1,5,6] 。
插入 2 ，代价为 min(1, 2) = 1 ，现在 nums = [1,2,5,6] 。
总代价为 0 + 0 + 0 + 1 = 1 。
示例 2:

输入：instructions = [1,2,3,6,5,4]
输出：3
解释：一开始 nums = [] 。
插入 1 ，代价为 min(0, 0) = 0 ，现在 nums = [1] 。
插入 2 ，代价为 min(1, 0) = 0 ，现在 nums = [1,2] 。
插入 3 ，代价为 min(2, 0) = 0 ，现在 nums = [1,2,3] 。
插入 6 ，代价为 min(3, 0) = 0 ，现在 nums = [1,2,3,6] 。
插入 5 ，代价为 min(3, 1) = 1 ，现在 nums = [1,2,3,5,6] 。
插入 4 ，代价为 min(3, 2) = 2 ，现在 nums = [1,2,3,4,5,6] 。
总代价为 0 + 0 + 0 + 0 + 1 + 2 = 3 。
示例 3：

输入：instructions = [1,3,3,3,2,4,2,1,2]
输出：4
解释：一开始 nums = [] 。
插入 1 ，代价为 min(0, 0) = 0 ，现在 nums = [1] 。
插入 3 ，代价为 min(1, 0) = 0 ，现在 nums = [1,3] 。
插入 3 ，代价为 min(1, 0) = 0 ，现在 nums = [1,3,3] 。
插入 3 ，代价为 min(1, 0) = 0 ，现在 nums = [1,3,3,3] 。
插入 2 ，代价为 min(1, 3) = 1 ，现在 nums = [1,2,3,3,3] 。
插入 4 ，代价为 min(5, 0) = 0 ，现在 nums = [1,2,3,3,3,4] 。
插入 2 ，代价为 min(1, 4) = 1 ，现在 nums = [1,2,2,3,3,3,4] 。
插入 1 ，代价为 min(0, 6) = 0 ，现在 nums = [1,1,2,2,3,3,3,4] 。
插入 2 ，代价为 min(2, 4) = 2 ，现在 nums = [1,1,2,2,2,3,3,3,4] 。
总代价为 0 + 0 + 0 + 0 + 1 + 0 + 1 + 0 + 2 = 4 。

提示：

1 <= instructions.length <= 100000
1 <= instructions[i] <= 100000

难度：难

思路：裸树状数组

class Solution {
    int[] c;
    int n=0;
    public int lowbit(int x){
        return x&(-x);
    }
    public void update(int x,int d){
        while(x<=n){
            c[x]+=d;
            x+=lowbit(x);
        }
    }
    public long sum(int x){
        long res=0;
        while(x>0){
            res+=c[x];
            x-=lowbit(x);
        }
        return res;
    }
    public int createSortedArray(int[] instructions) {
        long res=0,l,r;
        int i,j,k;
        for(i=0;i<instructions.length;i++){
            n=Math.max(n,instructions[i]);
        }
        c=new int[n+1];
        for(i=0;i<instructions.length;i++){
            l=sum(instructions[i]-1);
            r=i-sum(instructions[i]);
            res=(res+Math.min(l,r))%1000000007;
            update(instructions[i],1);
        }
        return (int) res%1000000007;
    }
}