3158.求出出现两次数字的XOR值

给你一个数组 nums ，数组中的数字 要么 出现一次，要么 出现两次。

请你返回数组中所有出现两次数字的按位 XOR 值，如果没有数字出现过两次，返回 0 。

示例 1：

输入：nums = [1,2,1,3]

输出：1

解释：

nums 中唯一出现过两次的数字是 1 。

示例 2：

输入：nums = [1,2,3]

输出：0

解释：

nums 中没有数字出现两次。

示例 3：

输入：nums = [1,2,2,1]

输出：3

解释：

数字 1 和 2 出现过两次。1 XOR 2 == 3 。

提示：

• 1 <= nums.length <= 50
• 1 <= nums[i] <= 50
• nums 中每个数字要么出现过一次，要么出现过两次。

这个题里面的数字在1-50之间，所以可以直接计数排序，如果count[i]==2，那么ans^i

class Solution {
public:
    int duplicateNumbersXOR(vector<int>& nums) {
        int n=nums.size();
        int count[51]={0};
        int ans=0;
        for(int i=0;i<n;i++){
            count[nums[i]]++;
            if(count[nums[i]]==2) ans=ans^nums[i];
        }
        return ans;
    }
};

3159.查询数组中元素的出现位置

给你一个整数数组 nums ，一个整数数组 queries 和一个整数 x 。

对于每个查询 queries[i] ，你需要找到 nums 中第 queries[i] 个 x 的位置，并返回它的下标。如果数组中 x 的出现次数少于 queries[i] ，该查询的答案为 -1 。

请你返回一个整数数组 answer ，包含所有查询的答案。

示例 1：

输入：nums = [1,3,1,7], queries = [1,3,2,4], x = 1

输出：[0,-1,2,-1]

解释：

• 第 1 个查询，第一个 1 出现在下标 0 处。
• 第 2 个查询，nums 中只有两个 1 ，所以答案为 -1 。
• 第 3 个查询，第二个 1 出现在下标 2 处。
• 第 4 个查询，nums 中只有两个 1 ，所以答案为 -1 。

示例 2：

输入：nums = [1,2,3], queries = [10], x = 5

输出：[-1]

解释：

• 第 1 个查询，nums 中没有 5 ，所以答案为 -1 。

提示：

• 1 <= nums.length, queries.length <= 105
• 1 <= queries[i] <= 105
• 1 <= nums[i], x <= 104

这个题只要O(n)遍历数组，将同样的nums元素对应的nums数组的位置放入

unordered_map< int,vector<int> >positions

之后遍历queries数组，找到数字x在nums数组里第queries[i]个的位置。

如果没有，就返回-1

class Solution {
public:
    vector<int> occurrencesOfElement(vector<int>& nums, vector<int>& queries, int x) {
        unordered_map<int, vector<int>> positions; // 用于存储数字 x 在 nums 中的位置
        for (int i = 0; i < nums.size(); i++) {
            positions[nums[i]].push_back(i);
        }

        vector<int> answer;
        for (int query : queries) {
            if (positions.find(x) == positions.end() || positions[x].size() < query) {
                answer.push_back(-1);
            } else {
                answer.push_back(positions[x][query - 1]);
            }
        }

        return answer;
    }
};

不过其实可以不必记录所有的元素的，只需要记录x在nums数组的位置就行

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

给你一个整数 limit 和一个大小为 n x 2 的二维数组 queries 。

总共有 limit + 1 个球，每个球的编号为 [0, limit] 中一个 互不相同 的数字。一开始，所有球都没有颜色。queries 中每次操作的格式为 [x, y] ，你需要将球 x 染上颜色 y 。每次操作之后，你需要求出所有球中 不同 颜色的数目。

请你返回一个长度为 n 的数组 result ，其中 result[i] 是第 i 次操作以后不同颜色的数目。

注意 ，没有染色的球不算作一种颜色。

示例 1：

输入：limit = 4, queries = [[1,4],[2,5],[1,3],[3,4]]

输出：[1,2,2,3]

解释：

• 操作 0 后，球 1 颜色为 4 。
• 操作 1 后，球 1 颜色为 4 ，球 2 颜色为 5 。
• 操作 2 后，球 1 颜色为 3 ，球 2 颜色为 5 。
• 操作 3 后，球 1 颜色为 3 ，球 2 颜色为 5 ，球 3 颜色为 4 。

示例 2：

输入：limit = 4, queries = [[0,1],[1,2],[2,2],[3,4],[4,5]]

输出：[1,2,2,3,4]

解释：

• 操作 0 后，球 0 颜色为 1 。
• 操作 1 后，球 0 颜色为 1 ，球 1 颜色为 2 。
• 操作 2 后，球 0 颜色为 1 ，球 1 和 2 颜色为 2 。
• 操作 3 后，球 0 颜色为 1 ，球 1 和 2 颜色为 2 ，球 3 颜色为 4 。
• 操作 4 后，球 0 颜色为 1 ，球 1 和 2 颜色为 2 ，球 3 颜色为 4 ，球 4 颜色为 5 。

提示：

• 1 <= limit <= 109
• 1 <= n == queries.length <= 105
• queries[i].length == 2
• 0 <= queries[i][0] <= limit
• 1 <= queries[i][1] <= 109

class Solution {
public:
    vector<int> queryResults(int limit, vector<vector<int>>& queries) {
        unordered_map<int, int> color; // 用来记录球对应的颜色
        unordered_map<int, int> colorsCount; // 用来记录每种颜色的数量
        vector<int> result;

        int num = 0;
        for (int i = 0; i < queries.size(); i++) {
            int ball = queries[i][0];
            int newColor = queries[i][1];

            if (color.find(ball) == color.end()) {
                // 新的球，颜色+1
                colorsCount[newColor]++;
                 if(colorsCount[newColor]==1) num++;
                
            } else {
                int oldColor = color[ball];
                if (colorsCount[oldColor] == 1) {
                    // 如果原来的颜色只有一个球，颜色种类-1
                    num--;
                     colorsCount[oldColor]--;
                } else {
                    colorsCount[oldColor]--;
                }
                colorsCount[newColor]++;
                if (colorsCount[newColor] == 1) { // 如果新颜色原本不存在
                    num++;
                }
            }
            color[ball] = newColor;
            result.push_back(num);
        }

        return result;
    }
};

这个题有点麻烦，但是写起来感觉还好

unordered_map<int, int> color; // 用来记录球对应的颜色

unordered_map<int, int> colorsCount; // 用来记录每种颜色的数量

就好了

3161.物块放置查询

有一条无限长的数轴，原点在 0 处，沿着 x 轴 正 方向无限延伸。

给你一个二维数组 queries ，它包含两种操作：

1. 操作类型 1 ：queries[i] = [1, x] 。在距离原点 x 处建一个障碍物。数据保证当操作执行的时候，位置 x 处 没有 任何障碍物。
2. 操作类型 2 ：queries[i] = [2, x, sz] 。判断在数轴范围 [0, x] 内是否可以放置一个长度为 sz 的物块，这个物块需要 完全 放置在范围 [0, x] 内。如果物块与任何障碍物有重合，那么这个物块 不能 被放置，但物块可以与障碍物刚好接触。注意，你只是进行查询，并 不是 真的放置这个物块。每个查询都是相互独立的。

请你返回一个 boolean 数组results ，如果第 i 个操作类型 2 的操作你可以放置物块，那么 results[i] 为 true ，否则为 false 。

示例 1：

输入：queries = [[1,2],[2,3,3],[2,3,1],[2,2,2]]

输出：[false,true,true]

解释：

查询 0 ，在 x = 2 处放置一个障碍物。在 x = 3 之前任何大小不超过 2 的物块都可以被放置。

示例 2：

输入：queries = [[1,7],[2,7,6],[1,2],[2,7,5],[2,7,6]]

输出：[true,true,false]

解释：

• 查询 0 在 x = 7 处放置一个障碍物。在 x = 7 之前任何大小不超过 7 的物块都可以被放置。
• 查询 2 在 x = 2 处放置一个障碍物。现在，在 x = 7 之前任何大小不超过 5 的物块可以被放置，x = 2 之前任何大小不超过 2 的物块可以被放置。

提示：

• 1 <= queries.length <= 15 * 104
• 2 <= queries[i].length <= 3
• 1 <= queries[i][0] <= 2
• 1 <= x, sz <= min(5 * 104, 3 * queries.length)
• 输入保证操作 1 中，x 处不会有障碍物。
• 输入保证至少有一个操作类型 2 。

这个题当时比赛时间不够了，就没写

我看灵茶直播，说好像要线段树。。。没学过。

先去浅学一下。