Leetcode 第 376 场周赛题解

Leetcode 第 376 场周赛题解

题目1：2965. 找出缺失和重复的数字

思路

用哈希表统计数组 grid 中各元素的出现次数，其中出现次数为 2 的记为 a。

统计数组 grid 的元素之和为 sum。

数组 grid 其中的值在 [1, n²] 范围内，和为 n²*(n²+1)/2。

当 sum > n * n * (n * n + 1) / 2 时，b = a - (sum - n * n * (n * n + 1) / 2)；否则，b = a + (n * n * (n * n + 1) / 2 - sum)。

代码

/*
 * @lc app=leetcode.cn id=2965 lang=cpp
 *
 * [2965] 找出缺失和重复的数字
 */

// @lc code=start
class Solution
{
public:
    vector<int> findMissingAndRepeatedValues(vector<vector<int>> &grid)
    {
        if (grid.empty())
            return {};
        int n = grid.size();
        int sum = 0, a = 0, b = 0;
        unordered_map<int, int> hash;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
            {
                int num = grid[i][j];
                hash[num]++;
                sum += num;
                if (hash[num] == 2)
                    a = num;
            }
        if (sum > n * n * (n * n + 1) / 2)
            b = a - (sum - n * n * (n * n + 1) / 2);
        else
            b = a + (n * n * (n * n + 1) / 2 - sum);
        return {a, b};
    }
};
// @lc code=end

复杂度分析

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

空间复杂度：O(n²)，其中 n 是二维数组 grid 的长度。

题目2：2966. 划分数组并满足最大差限制

思路

排序。

将数组 nums 从小到大排序，每三个一组插入答案，如果有 nums[i + 2] - nums[i] > k，则不满足要求，返回空数组。

代码

/*
 * @lc app=leetcode.cn id=2966 lang=cpp
 *
 * [2966] 划分数组并满足最大差限制
 */

// @lc code=start
class Solution
{
public:
    vector<vector<int>> divideArray(vector<int> &nums, int k)
    {
        if (nums.empty())
            return {};
        vector<vector<int>> ans;
        sort(nums.begin(), nums.end());
        for (int i = 0; i < nums.size(); i += 3)
        {
            if (nums[i + 2] - nums[i] > k)
                return {};
            ans.push_back({nums[i], nums[i + 1], nums[i + 2]});
        }
        return ans;
    }
};
// @lc code=end

复杂度分析

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

空间复杂度：O(1)。

题目3：2967. 使数组成为等数数组的最小代价

思路

贪心。

题目中要求将数组变成等数数组（数组中的所有元素都等于一个小于 10⁹ 的回文数）。因此，我们需要找到一个小于 10⁹ 的回文数，使得将数组中所有元素变成这个数的代价最小。

基于贪心的思想，我们可以从中位数开始，向左查找第一个回文数 left，向右查找第一个回文数 right，然后取两者中总代价的较小值作为答案。

代码

/*
 * @lc app=leetcode.cn id=2967 lang=cpp
 *
 * [2967] 使数组成为等数数组的最小代价
 */

// @lc code=start
class Solution
{
public:
    long long minimumCost(vector<int> &nums)
    {
        // 特判
        if (nums.empty())
            return 0LL;
        int n = nums.size();
        sort(nums.begin(), nums.end());
        int left = nums[n / 2];
        while (left > 0 && isPalindrome(left) == false)
            left--;
        int right = nums[n / 2];
        while (right <= 1e9 && isPalindrome(right) == false)
            right++;
        return min(calCost(nums, left), calCost(nums, right));
    }
    // 辅函数 - 判断 x 是不是回文数
    bool isPalindrome(int x)
    {
        string s = to_string(x);
        return s == string(s.rbegin(), s.rend());
    }
    // 辅函数 - 计算将数组 nums 的所有元素全部变成 x 的代价
    long long calCost(vector<int> &nums, int x)
    {
        long long cost = 0;
        for (int &num : nums)
            cost += abs(num - x);
        return cost;
    }
};
// @lc code=end

复杂度分析

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

空间复杂度：O(1)。

题目4：2968. 执行操作使频率分数最大

思路

贪心 + 前缀和 + 滑动窗口。

基于贪心的思想，将数组 nums 的所有元素变为 nums 的中位数是最优的。

把数组排序后，要变成一样的数必然在一个连续子数组中，那么用滑动窗口来做，枚举子数组的右端点 right，然后维护子数组的左端点 left。

根据中位数贪心，最优做法是把子数组内的元素都变成子数组的中位数，操作次数如果超过 k，就必须移动左端点。

求出数组的前缀和，就可以在 O(1) 的时间复杂度下算出操作次数了。

代码

/*
 * @lc app=leetcode.cn id=2968 lang=cpp
 *
 * [2968] 执行操作使频率分数最大
 */

// @lc code=start

// 贪心 + 前缀和 + 滑动窗口

class Solution
{
public:
    int maxFrequencyScore(vector<int> &nums, long long k)
    {
        // 特判
        if (nums.empty())
            return 0;
        int n = nums.size();
        sort(nums.begin(), nums.end());
        vector<long long> preSum(n + 1, 0);
        for (int i = 1; i <= n; i++)
            preSum[i] = preSum[i - 1] + nums[i - 1];
        auto calDistance = [&](int left, int i, int right) -> long long
        {
            long long left_distance = (long long)nums[i] * (i - left) - (preSum[i] - preSum[left]);
            long long right_distance = (preSum[right + 1] - preSum[i + 1]) - (long long)nums[i] * (right - i);
            return left_distance + right_distance;
        };
        int ans = 0;
        int left = 0;
        for (int right = 0; right < n; right++)
        {
            while (calDistance(left, (left + right) / 2, right) > k)
                left++;
            ans = max(ans, right - left + 1);
        }
        return ans;
    }
};
// @lc code=end

复杂度分析

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

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