Leetcode 第 402 场周赛题解

Leetcode 第 402 场周赛题解

题目1：3184. 构成整天的下标对数目 I

思路

统计满足 i < j 且 hours[i] + hours[j] 构成整天的下标对 i, j 的数目。

构成整天的条件：(hours[i] + hours[j]) % 24 == 0。

代码

/*
 * @lc app=leetcode.cn id=3184 lang=cpp
 *
 * [3184] 构成整天的下标对数目 I
 */

// @lc code=start
class Solution
{
public:
    int countCompleteDayPairs(vector<int> &hours)
    {
        int n = hours.size();
        int count = 0;
        for (int i = 0; i < n - 1; i++)
            for (int j = i + 1; j < n; j++)
                if ((hours[i] + hours[j]) % 24 == 0)
                    count++;
        return count;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(n²)，其中 n 是数组 hours 的长度。

空间复杂度：O(1)。

题目2：3185. 构成整天的下标对数目 II

思路

本质思路类同经典的“两数之和”。枚举右，用哈希表维护左。

枚举 j，并维护 cnt[x] 表示所有满足 i < j 的下标 i 中，有几个 hours[i] 模 24 等于 x。设 y = nums[j] % 24，那么答案就是 sum(cnt[(24 - y) % 24])。

注意取余的存在，余 0 的情况要特殊处理。

代码

/*
 * @lc app=leetcode.cn id=3185 lang=cpp
 *
 * [3185] 构成整天的下标对数目 II
 */

// @lc code=start
class Solution
{
public:
    long long countCompleteDayPairs(vector<int> &hours)
    {
        vector<int> cnt(24, 0);
        long long ans = 0LL;
        for (int &hour : hours)
        {
            hour %= 24;
            ans += cnt[(24 - hour) % 24];
            cnt[hour]++;
        }
        return ans;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(n+M)，其中 n 为数组 hours 的长度，M=24。

空间复杂度：O(M)，M=24。

题目3：3186. 施咒的最大总伤害

思路

统计每个元素的出现次数，记到哈希表 cnt 中。将哈希表的 key 整理到数组 a 中，把 a 按照从小到大的顺序排序。

定义 dfs(i) 表示从 a[0] 到 a[i] 中选择，可以得到的伤害值之和的最大值。

考虑 a[i] 选或不选：

• 不选：问题变成从 a[0] 到 a[i−1] 中选择，可以得到的伤害值之和的最大值，即 dfs(i)=dfs(i−1)。
• 选：那么伤害值等于 a[i]−2 和 a[i]−1 的数不能选，问题变成从 a[0] 到 a[j−1] 中选择，可以得到的伤害值之和的最大值，其中 j 是最小的满足 a[j]≥a[i]−2 的数。那么 dfs(i)=dfs(j−1)+a[i]⋅cnt[a[i]]。

两种情况取最大值，得：dfs(i)=max⁡(dfs(i−1),dfs(j−1)+a[i]⋅cnt[a[i]])。

递归边界：dfs(−1)=0。没有数可以选，伤害值之和为 0。

递归入口：dfs(n−1)，即答案。注意这里 n 是 a 的长度，即 power 中的不同元素个数。

代码

#
# @lc app=leetcode.cn id=3186 lang=python3
#
# [3186] 施咒的最大总伤害
#

# @lc code=start
class Solution:
    def maximumTotalDamage(self, power: List[int]) -> int:
        cnt = Counter(power)
        a = sorted(cnt.keys())

        @cache
        def dfs(i: int) -> int:
            if i < 0:
                return 0
            x = a[i]
            j = i
            while j > 0 and a[j - 1] >= x - 2:
                j -= 1
            res1 = dfs(i - 1) # 不选 a[i]
            res2 = dfs(j - 1) + x * cnt[x] # 选 a[i]
            return max(res1, res2)
        
        return dfs(len(a) - 1)
# @lc code=end

复杂度分析

时间复杂度：O(nlogn)，其中 n 是 power 的长度。

空间复杂度：O(n)，其中 n 是 power 的长度。

题目4：3187. 数组中的峰值

思路

为方便描述，把 nums 记作 a。

如果 1≤i≤n−2 且 a[i−1]<a[i]>a[i+1]，那么把 a[i] 视作 1，否则视作 0。

如此转换后，操作 1 相当于计算从 l+1 到 r−1 的子数组的元素和。请注意，题目说的是「子数组」的第一个和最后一个不是峰值元素，注意是子数组，不是整个数组。

由于操作 2 要动态修改数组，我们可以用树状数组维护。

具体来说：

1. 先把区间 [max⁡(i−1,1),min⁡(i+1,n−2)] 中的峰值元素从树状数组中去掉。
2. 然后修改 a[i]=val。
3. 最后再把区间 [max⁡(i−1,1),min⁡(i+1,n−2)] 中的峰值元素加入树状数组。

代码

/*
 * @lc app=leetcode.cn id=3187 lang=cpp
 *
 * [3187] 数组中的峰值
 */

// @lc code=start
class Fenwick
{
    vector<int> f;

public:
    Fenwick(int n) : f(n) {}

    void update(int i, int val)
    {
        for (; i < f.size(); i += i & -i)
        {
            f[i] += val;
        }
    }

    int pre(int i)
    {
        int res = 0;
        for (; i > 0; i &= i - 1)
        {
            res += f[i];
        }
        return res;
    }

    int query(int l, int r)
    {
        if (r < l)
        {
            return 0;
        }
        return pre(r) - pre(l - 1);
    }
};

class Solution
{
public:
    vector<int> countOfPeaks(vector<int> &nums, vector<vector<int>> &queries)
    {
        int n = nums.size();
        Fenwick f(n - 1);
        auto update = [&](int i, int val)
        {
            if (nums[i - 1] < nums[i] && nums[i] > nums[i + 1])
            {
                f.update(i, val);
            }
        };
        for (int i = 1; i < n - 1; i++)
        {
            update(i, 1);
        }

        vector<int> ans;
        for (auto &q : queries)
        {
            if (q[0] == 1)
            {
                ans.push_back(f.query(q[1] + 1, q[2] - 1));
                continue;
            }
            int i = q[1];
            for (int j = max(i - 1, 1); j <= min(i + 1, n - 2); ++j)
            {
                update(j, -1);
            }
            nums[i] = q[2];
            for (int j = max(i - 1, 1); j <= min(i + 1, n - 2); ++j)
            {
                update(j, 1);
            }
        }
        return ans;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O((n+q)log⁡n)，其中 n 是数组 nums 的长度，q 是数组 queries 的长度。

空间复杂度：O(n)，其中 n 是数组 nums 的长度，返回值不计入。