LeetCode第331场周赛

2023.2.5LeetCode第331场周赛

2558. 从数量最多的堆取走礼物

思路

使用优先队列模拟，每次操作取出最大数量的一堆，再加入它的平方根

代码

class Solution {
public:
    long long pickGifts(vector<int>& gifts, int k) {
        priority_queue<long long> q;
        for (int x : gifts)
            q.push(x);
        while (k -- ) {
            auto t = q.top();
            q.pop();
            q.push(sqrt(t));
        }
        long long ans = 0;
        while (q.size()) {
            auto t = q.top();
            q.pop();
            ans += t;
        }
        return ans;
    }
};

2559. 统计范围内的元音字符串数

思路

前缀和计算满足条件的数量，每次查询返回区间内的总数

代码

class Solution {
public:
    bool isY(char c) {
        if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u')
            return true;
        return false;
    }
    
    vector<int> vowelStrings(vector<string>& w, vector<vector<int>>& q) {
        int n = w.size();
        vector<int> a(n);
        for (int i = 0; i < n; i ++ ) {
            string s = w[i];
            if (isY(s[0]) && isY(s.back()))
                a[i] = 1;
        }
        vector<int> s(n + 1);
        for (int i = 1; i <= n; i ++ )
            s[i] = s[i - 1] + a[i - 1];
        vector<int> ans(q.size());
        for (int i = 0; i < q.size(); i ++ ) {
            ans[i] = s[q[i][1] + 1] - s[q[i][0]];
        }
        
        return ans;
    }
};

2560. 打家劫舍 IV

思路

二分+动态规划
最大最小或者最小最大问题，具有单调二分性，可以使用二分算法
小偷的窃取能力是能窃取的所有房屋中最大金额，求小偷的窃取能力最小是多少
二分的范围是0到最大金额
每次二分要检验的是：当前金额能否作为小偷偷取至少k个房屋的窃取能力，可以转化为偷取不超过当前金额的房屋，需要多少个房屋的问题，房屋数量大于等于k说明能满足
使用dp解决，如果偷取当前房屋i，从i - 2转移而来，且当前金额能偷取；如果不偷取当前房屋i，从i - 1转移而来

代码

class Solution {
public:
    int minCapability(vector<int>& nums, int k) {
        int m = 0;
        for (int x : nums)
            m = max(x, m);
        int n = nums.size();
        int l = 0, r = m;
        while (l < r) {
            int mid = l + r >> 1;
            vector<int> f(n + 1); //f[i]表示前i个房屋，不超过mid的最多房屋数
            for (int i = 1; i <= n; i ++ ) {
                int x = nums[i - 1];
                if (x > mid) f[i] = f[i - 1]; //不能偷当前房屋
                else {
                    if (i > 1)
                        f[i] = max(f[i], f[i - 2] + 1); //不偷和偷两种情况
                    else
                        f[i] = 1; //偷
                }
            }
            if (f[n] >= k) r = mid; //能够满足条件，mid越大越能满足
            else l = mid + 1;
        }
        return l;
    }
};

2561. 重排水果

思路

首先找出无法使两个果篮相等的情况
统计所有种类水果的数量，若某个种类的水果数量为奇数，说明无法相等分配，返回-1
要使两个待交换的水果a、b交换有两种方法（假设a<b）：

1. 直接交换，成本为较小的水果a
2. 间接交换，使用另一个水果x，x与a交换，x再与b交换，成本为min(x, a) * 2

代码

class Solution {
public:
    typedef long long ll;

    long long minCost(vector<int>& basket1, vector<int>& basket2) {
        map<int, int> a, b, mp;
        for (auto x : basket1)
            a[x] ++ , mp[x] ++ ;
        for (auto x : basket2)
            b[x] ++ , mp[x] ++ ;
        for (auto [k, v] : mp)
            if (v % 2) return -1;
        vector<int> c;
        for (auto [k, v] : a) {
            if (v > mp[k] / 2)
                for (int i = 0; i < v - mp[k] / 2; i ++ )
                    c.push_back(k);
        }
        for (auto [k, v] : b) {
            if (v > mp[k] / 2)
                for (int i = 0; i < v - mp[k] / 2; i ++ )
                    c.push_back(k);
        }
        sort(c.begin(), c.end());
        int m = mp.begin()->first;
        ll ans = 0;
        for (int i = 0; i < c.size() / 2; i ++ ) {
            ans += min(c[i], m * 2);
        }
        return ans;
    }
};