Leetcode 第 131 场双周赛题解

Leetcode 第 131 场双周赛题解

题目1：3158. 求出出现两次数字的 XOR 值

思路

遍历数组 nums，用一个集合统计遍历到的元素。

如果当前元素在集合中存在，说明是第二次出现，与答案 ans 异或。

最后返回 ans 即可。

代码

/*
 * @lc app=leetcode.cn id=3158 lang=cpp
 *
 * [3158] 求出出现两次数字的 XOR 值
 */

// @lc code=start
class Solution
{
public:
    int duplicateNumbersXOR(vector<int> &nums)
    {
        set<int> s;
        int ans = 0;
        for (int &num : nums)
        {
            if (s.contains(num))
                ans ^= num;
            else
                s.insert(num);
        }
        return ans;
    }
};
// @lc code=end

复杂度分析

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

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

题目2：3159. 查询数组中元素的出现位置

思路

先用一个 index 数组统计数组 nums 中所有值为 x 的下标。

针对每个查询 queries[i]，如果 queries[i] > index.size()，说明数组中 x 的出现次数少于 queries[i]，答案为 -1；否则答案为 index[queries[i] - 1]。

代码

/*
 * @lc app=leetcode.cn id=3159 lang=cpp
 *
 * [3159] 查询数组中元素的出现位置
 */

// @lc code=start
class Solution
{
public:
    vector<int> occurrencesOfElement(vector<int> &nums, vector<int> &queries, int x)
    {
        vector<int> index;
        for (int i = 0; i < nums.size(); i++)
            if (nums[i] == x)
                index.push_back(i);
        vector<int> ans(queries.size());
        for (int i = 0; i < queries.size(); i++)
            ans[i] = queries[i] > index.size() ? -1 : index[queries[i] - 1];
        return ans;
    }
};
// @lc code=end

复杂度分析

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

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

题目3：3160. 所有球里面不同颜色的数目

思路

用哈希表 color 维护第 x 个球的颜色 y，哈希表 cnt 维护每种颜色的出现次数。

当把球 x 的颜色改成 y 时：

1. 如果 x 在 color 中，设 c=color[x]，先把 cnt[c] 减少一，如果 cnt[c] 变成 0，则从 cnt 中删除 c。
2. 更新 color[x]=y。
3. 把 cnt[y] 增加一。
4. 把 cnt 的大小加入答案。

代码

/*
 * @lc app=leetcode.cn id=3160 lang=cpp
 *
 * [3160] 所有球里面不同颜色的数目
 */

// @lc code=start
class Solution
{
public:
    vector<int> queryResults(int limit, vector<vector<int>> &queries)
    {
        vector<int> ans;
        unordered_map<int, int> color; // 存储各球的颜色
        unordered_map<int, int> cnt;   // 统计各个颜色的出现次数
        for (vector<int> &query : queries)
        {
            int x = query[0], y = query[1];
            if (color.contains(x))
            {
                if (--cnt[color[x]] == 0)
                    cnt.erase(color[x]);
            }
            // add
            color[x] = y;
            cnt[y]++;
            // 加入答案
            ans.push_back(cnt.size());
        }
        return ans;
    }
};
// @lc code=end

复杂度分析

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

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

题目4：3161. 物块放置查询

思路

线段树。

题解：三种方法：线段树/树状数组/并查集（Python/Java/C++/Go）

代码

/*
 * @lc app=leetcode.cn id=3161 lang=cpp
 *
 * [3161] 物块放置查询
 */

// @lc code=start
class Solution
{
    vector<int> t;

    // 把 i 处的值改成 val
    void update(int o, int l, int r, int i, int val)
    {
        if (l == r)
        {
            t[o] = val;
            return;
        }
        int m = (l + r) / 2;
        if (i <= m)
            update(o * 2, l, m, i, val);
        else
            update(o * 2 + 1, m + 1, r, i, val);
        t[o] = max(t[o * 2], t[o * 2 + 1]);
    }

    // 查询 [0, R] 中的最大值
    int query(int o, int l, int r, int R)
    {
        if (r <= R)
            return t[o];
        int m = (l + r) / 2;
        if (R <= m)
            return query(o * 2, l, m, R);
        return max(t[o * 2], query(o * 2 + 1, m + 1, r, R));
    }

public:
    vector<bool> getResults(vector<vector<int>> &queries)
    {
        int m = 0;
        for (vector<int> &query : queries)
            m = max(m, query[1]);
        m++;

        set<int> st{0, m}; // 哨兵
        t.resize(2 << (32 - __builtin_clz(m)));

        vector<bool> ans;
        for (vector<int> &q : queries)
        {
            int x = q[1];
            auto it = st.lower_bound(x);
            int pre = *prev(it); // x 左侧最近障碍物的位置
            if (q[0] == 1) // 在距离原点 x 处建一个障碍物
            {
                int next = *it; // x 右侧最近障碍物的位置
                st.insert(x);
                update(1, 0, m, x, x - pre);   // 更新 d[x] = x - pre
                update(1, 0, m, next, next - x); // 更新 d[next] = next - x
            }
            else
            {
                // 最大长度要么是 [0, pre] 中的最大 d，要么是 [pre, x] 这一段的长度
                int max_gap = max(query(1, 0, m, pre), x - pre);
                ans.push_back(max_gap >= q[2]);
            }
        }
        return ans;
    }
};
// @lc code=end

复杂度分析