Leetcode 第 387 场周赛题解

Leetcode 第 387 场周赛题解

题目1：3069. 将元素分配到两个数组中 I

思路

简单地按题意模拟。

代码

/*
 * @lc app=leetcode.cn id=3069 lang=cpp
 *
 * [3069] 将元素分配到两个数组中 I
 */

// @lc code=start
class Solution
{
public:
    vector<int> resultArray(vector<int> &nums)
    {
        vector<int> arr1, arr2;
        arr1.push_back(nums[0]);
        arr2.push_back(nums[1]);
        for (int i = 2; i < nums.size(); i++)
        {
            if (arr1.back() > arr2.back())
                arr1.push_back(nums[i]);
            else
                arr2.push_back(nums[i]);
        }

        vector<int> result(arr1.begin(), arr1.end());
        for (int &x : arr2)
            result.push_back(x);
        return result;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(n)，其中 n 是数组 nums 的元素个数。

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

题目2：3070. 元素和小于等于 k 的子矩阵的数目

思路

二维前缀和的模板题。

代码

/*
 * @lc app=leetcode.cn id=3070 lang=cpp
 *
 * [3070] 元素和小于等于 k 的子矩阵的数目
 */

// @lc code=start

// 二维前缀和

class Solution
{
public:
    int countSubmatrices(vector<vector<int>> &grid, int k)
    {
        if (grid.empty())
            return 0;
        if (grid[0][0] > k)
            return 0;

        int m = grid.size(), n = m ? grid[0].size() : 0;
        // sum[i + 1][j + 1] 表示以 grid[0][0] 为左上角，
        // 以 grid[i][j] 为右下角的子矩阵的元素和 
        vector<vector<int>> sum(m + 1, vector<int>(n + 1, 0));

        int count = 0;
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
            {
                sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + grid[i][j];
                if (sum[i + 1][j + 1] <= k)
                    count++;
            }
        return count;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(mn)，其中 m 和 n 分别为二维数组 grid 的行数和列数。

空间复杂度：O(mn)，其中 m 和 n 分别为二维数组 grid 的行数和列数。

题目3：3071. 在矩阵上写出字母 Y 所需的最少操作次数

思路

统计 Y 中的元素出现次数，记到一个长为 3 的数组 cnt1 中。统计不在 Y 中的元素出现次数，记到一个长为 3 的数组 cnt2 中。

计算最多可以保留多少个元素不变，设这个值为 maxNotChange。

在 0,1,2 中枚举 i 和 j，其中 i≠j。让 Y 中的元素都变成 i，不在 Y 中的元素都变成 j，那么 maxNotChange 就是 cnt1[i]+cnt2[j] 的最大值。

最后返回 n²−maxNotChange，即最少要修改的元素个数。

代码

/*
 * @lc app=leetcode.cn id=3071 lang=cpp
 *
 * [3071] 在矩阵上写出字母 Y 所需的最少操作次数
 */

// @lc code=start
class Solution
{
public:
    int minimumOperationsToWriteY(vector<vector<int>> &grid)
    {
        int n = grid.size();    // n 为奇数
        vector<int> cnt1(3, 0); // 字母 Y 单元格各数字的出现次数
        vector<int> cnt2(3, 0); // 非字母 Y 单元格各数字的出现次数

        auto isY = [&](int i, int j) -> bool
        {
            if (i < 0 || i > n || j < 0 || j > n)
                return false;
            if (i == j && i <= n / 2)
                return true;
            if (i + j == n - 1 && i <= n / 2)
                return true;
            if (i >= n / 2 && j == n / 2)
                return true;
            return false;
        };

        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
            {
                int x = grid[i][j];
                if (isY(i, j))
                    cnt1[x]++;
                else
                    cnt2[x]++;
            }

        int max_not_change = 0;
        for (int i = 0; i < 3; i++)
            for (int j = 0; j < 3; j++)
                if (i != j)
                    max_not_change = max(max_not_change, cnt1[i] + cnt2[j]);

        return n * n - max_not_change;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(n²+k²)，其中 n 为 grid 的长度，k=3。

空间复杂度：O(k)，其中 k=3。

题目4：3072. 将元素分配到两个数组中 II

思路

题解：离散化 + 树状数组（附练习题）Python/Java/C++/Go

代码

/*
 * @lc app=leetcode.cn id=3072 lang=cpp
 *
 * [3072] 将元素分配到两个数组中 II
 */

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

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

    // 把下标为 i 的元素增加 1
    void add(int i)
    {
        while (i < tree.size())
        {
            tree[i]++;
            i += i & -i;
        }
    }

    // 返回下标在 [1,i] 的元素之和
    int pre(int i)
    {
        int res = 0;
        while (i > 0)
        {
            res += tree[i];
            i &= i - 1;
        }
        return res;
    }
};

class Solution
{
public:
    vector<int> resultArray(vector<int> &nums)
    {
        auto sorted = nums;
        ranges::sort(sorted);
        sorted.erase(unique(sorted.begin(), sorted.end()), sorted.end());
        int m = sorted.size();

        vector<int> a{nums[0]}, b{nums[1]};
        Fenwick t1(m + 1), t2(m + 1);
        t1.add(ranges::lower_bound(sorted, nums[0]) - sorted.begin() + 1);
        t2.add(ranges::lower_bound(sorted, nums[1]) - sorted.begin() + 1);
        for (int i = 2; i < nums.size(); i++)
        {
            int x = nums[i];
            int v = ranges::lower_bound(sorted, x) - sorted.begin() + 1;
            int gc1 = a.size() - t1.pre(v); // greaterCount(a, v)
            int gc2 = b.size() - t2.pre(v); // greaterCount(b, v)
            if (gc1 > gc2 || gc1 == gc2 && a.size() <= b.size())
            {
                a.push_back(x);
                t1.add(v);
            }
            else
            {
                b.push_back(x);
                t2.add(v);
            }
        }
        a.insert(a.end(), b.begin(), b.end());
        return a;
    }
};
// @lc code=end

复杂度分析

时间复杂度：O(nlog⁡n)，其中 n 为数组 nums 的长度。

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