第230场周赛 2021-02-28

第一题

LC 1773. 统计匹配检索规则的物品数量

难度：简单
算法：字符串，模拟

题目描述：

给你一个数组 items ，其中 items[i] = [typei, colori, namei] ，描述第 i 件物品的类型、颜色以及名称。

另给你一条由两个字符串 ruleKey 和 ruleValue 表示的检索规则。

如果第 i 件物品能满足下述条件之一，则认为该物品与给定的检索规则 匹配 ：

ruleKey == “type” 且 ruleValue == typei 。
ruleKey == “color” 且 ruleValue == colori 。
ruleKey == “name” 且 ruleValue == namei 。
统计并返回 匹配检索规则的物品数量 。

提示：
1 <= items.length <= 10⁴
1 <= typei.length, colori.length, namei.length, ruleValue.length <= 10
ruleKey 等于 “type”、“color” 或 “name”
所有字符串仅由小写字母组成

题解：

简单字符串模拟扫描。

class Solution {
public:
    int countMatches(vector<vector<string>>& items, string ruleKey, string ruleValue) {
        int ans = 0;
        for(auto& it : items)
        {
            string type = it[0];
            string color = it[1];
            string name = it[2];
            if(ruleKey == "type" && ruleValue == type || ruleKey == "color" && ruleValue == color || ruleKey == "name" && ruleValue == name)
                ans++;
        }
        return ans;
    }
};

第二题

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

难度：中等
算法：枚举，位运算，DFS

题目描述：

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

必须选择 一种 冰激凌基料。
可以添加 一种或多种 配料，也可以不添加任何配料。
每种类型的配料 最多两份 。
给你以下三个输入：

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

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

提示：

n == baseCosts.length
m == toppingCosts.length
1 <= n, m <= 10
1 <= baseCosts[i], toppingCosts[i] <= 10⁴
1 <= target <= 10⁴

题解：

数据范围很小，可以通过先枚冰淇淋，再枚举所有配料的选取方式即可。
时间复杂度：O(n * 2^2m)

解法一：DFS

class Solution {
public:
    int n, m, target;
    int ans = 1e9, diff = 1e9;
    vector<int> topp;
    void dfs(int u, int sum)
    {
        if(u == m || sum > target)  
        {
            int t = abs(sum - target);
            if(t < diff || t == diff && sum < ans)    
            {
                diff = t;
                ans = sum;
            }
            return;
        }
        dfs(u + 1, sum);
        dfs(u + 1, sum + topp[u]);
        dfs(u + 1, sum + 2 * topp[u]);
    }
    int closestCost(vector<int>& baseCosts, vector<int>& toppingCosts, int _target) {
        n = baseCosts.size(), m = toppingCosts.size();
        target = _target;
        topp = toppingCosts;
        for(int i = 0; i < n; i++)
        {
            int base = baseCosts[i];
            dfs(0, base);
        }
        return ans;
    }
};

解法二：枚举，位运算

class Solution {
public:
    int closestCost(vector<int>& baseCosts, vector<int>& toppingCosts, int target) {
        int n = baseCosts.size(), m = toppingCosts.size();
        int ans = 1e9;
        for(int i = 0; i < n; i++)
        {
            int base = baseCosts[i];
            if(base > target)  
            {
                int t = abs(base - target);
                if(t < abs(ans - target) || t == abs(ans - target) && base < ans)    ans = base;
                continue;
            }
            for(int j = 0; j < 1 << 2 * m; j++)
            {
                bool flag = true;
                int sum = base;
                for(int k = 0; k < m; k++)
                {
                    int tmp = j >> 2 * k & 3;
                    if(tmp == 3) 	//当前枚举的j不合法
                    {
                        flag = false;
                        break;
                    }
                    sum += toppingCosts[k] * tmp;
                }
                if(!flag)   continue;
                int tt = abs(sum - target);
                if(tt < abs(ans - target) || tt == abs(ans - target) && sum < ans)   ans = sum;
            }
        }
        return ans;
    }
};

第三题

LC 1775. 通过最少操作次数使数组的和相等

难度：中等
算法：贪心

题目描述：
给你两个长度可能不等的整数数组 nums1 和 nums2 。两个数组中的所有值都在 1 到 6 之间（包含 1 和 6）。

每次操作中，你可以选择 任意 数组中的任意一个整数，将它变成 1 到 6 之间 任意 的值（包含 1 和 6）。

请你返回使 nums1 中所有数的和与 nums2 中所有数的和相等的最少操作次数。如果无法使两个数组的和相等，请返回 -1 。

提示：

1 <= nums1.length, nums2.length <= 10⁵
1 <= nums1[i], nums2[i] <= 6

题解：

假设sum1 > sum2，那么为了使得sum1 == sum2，有两种途径

1. 使sum1变小
2. 使sum2变大

预处理出两个数组中每个元素的变化范围，提取出新的变量即变化范围，那么在此变量下可以合并两数组。在每一次操作中优先选择变化范围最大的元素进行操作，因为这样可以使得次数最少，是最优方案。

class Solution {
public:
    int minOperations(vector<int>& nums1, vector<int>& nums2) {
        int sum1 = accumulate(nums1.begin(), nums1.end(), 0);
        int sum2 = accumulate(nums2.begin(), nums2.end(), 0);
        if(sum1 == sum2)    return 0;
        if(sum1 > sum2)     return minOperations(nums2, nums1);
        vector<int> sub(6);
        for(auto& x : nums1)    sub[6 - x]++;
        for(auto& x : nums2)    sub[x - 1]++;
        int ans = 0;
        for(int i = 5; i >= 0; i--)
        {
            while(sum2 > sum1 && sub[i]--)
            {
                sum2 -= i;
                ans++;
            }
            if(sum2 <= sum1)    return ans;
        }
        return sum2 <= sum1 ? ans : -1;
    }
};

---

排名：259 / 3727(前6.95%)

---