2022-12-4 leetcode与蓝桥刷题情况

一、leetcode题目

1.划分技能点相等的团队

（1）题目描述

给你一个正整数数组 skill ，数组长度为 偶数 n ，其中 skill[i] 表示第 i 个玩家的技能点。将所有玩家分成 n / 2 个 2 人团队，使每一个团队的技能点之和 相等 。

团队的 化学反应 等于团队中玩家的技能点 乘积 。

返回所有团队的 化学反应 之和，如果无法使每个团队的技能点之和相等，则返回 -1 。

（2）测试用例

输入：

skill = [3,2,5,1,3,4]

输出：

22

解释：

将玩家分成 3 个团队 (1, 5), (2, 4), (3, 3) ，每个团队的技能点之和都是 6 。
所有团队的化学反应之和是 1 * 5 + 2 * 4 + 3 * 3 = 5 + 8 + 9 = 22 。

提示：

• 2 <= skill.length <= $10^5$
• skill.length 是偶数
• 1 <= skill[i] <= 1000

（3）思路

先判断每个小组的技能点能否相同，即sum % (skill.length / 2) == 0,不为0，既是不能够把技能点平均分配给每个小组。后续的小组成员匹配可使用Hashmap查找成为和优化。

（4）算法实现

public long dividePlayers(int[] skill) {
        int n = skill.length;
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        int sum = 0;
        for(int skil : skill){
            sum += skil;
        }
        if(sum % (n / 2) != 0) return -1;
        int num = sum / (n / 2);
        long ans = 0;
        for(int skil : skill){
            if(map.containsKey(num-skil) && map.get(num-skil) > 0){
                map.put(num-skil, map.get(num-skil) - 1);
                ans += skil * (num-skil);
            }else{
                map.put(skil, map.getOrDefault(skil, 0) + 1);
            }
        }
        for(int key : map.keySet()){
            if(map.get(key) != 0) return -1;
        }
        return ans;
    } 

2.最接近目标价格的甜点成本

（1）题目描述

你打算做甜点，现在需要购买配料。目前共有 n 种冰激凌基料和 m 种配料可供选购。而制作甜点需要遵循以下几条规则：

• 必须选择一种冰激凌基料。
• 可以添加 一种或多种 配料，也可以不添加任何配料。
• 每种类型的配料 最多两份 。

给你以下三个输入：

baseCosts ，一个长度为 n 的整数数组，其中每个 baseCosts[i] 表示第 i 种冰激凌基料的价格。
toppingCosts，一个长度为 m 的整数数组，其中每个 toppingCosts[i] 表示 一份 第 i 种冰激凌配料的价格。
target ，一个整数，表示你制作甜点的目标价格。
你希望自己做的甜点总成本尽可能接近目标价格 target 。

返回最接近 target 的甜点成本。如果有多种方案，返回成本相对较低的一种。

（2）测试用例

输入：

baseCosts = [1,7], toppingCosts = [3,4], target = 10

输出：

10

解释：

考虑下面的方案组合（所有下标均从 0 开始）：
选择 1 号基料：成本 7
选择 1 份 0 号配料：成本 1 x 3 = 3
选择 0 份 1 号配料：成本 0 x 4 = 0
总成本：7 + 3 + 0 = 10 。

提示：

• n == baseCosts.length
• m == toppingCosts.length
• 1 <= n, m <= 10
• 1 <= baseCosts[i], toppingCosts[i] <= $10^4$
• 1 <= target <= $10^4$

（3）思路

数据量非常小，可直接暴力dfs遍历

（4）算法实现

class Solution {
    int res;
    public int closestCost(int[] baseCosts, int[] toppingCosts, int target) {
        res = Arrays.stream(baseCosts).min().getAsInt();
        for(int b : baseCosts){
            dfs(toppingCosts, 0, b, target);
        }
        return res;
    }

    private void dfs(int[] toppingCosts, int p, int curCost, int target){
        if(Math.abs(res - target) < curCost - target) return ;
        else if(Math.abs(res - target) >= Math.abs(curCost - target)){
            if(Math.abs(res - target) > Math.abs(curCost - target)){
                res = curCost;
            }else{
                res = Math.min(res, curCost);
            }
        }
        if(p == toppingCosts.length) return ;
        // 添加两种同一类型配料
        dfs(toppingCosts, p+1, curCost + toppingCosts[p] * 2, target);
        dfs(toppingCosts, p+1, curCost + toppingCosts[p], target);
        dfs(toppingCosts, p+1, curCost, target);
    }
}

今天还刷了一个简单题，不算太难，简单模拟就能过，就不放上来了

二、（今天无蓝桥题目）