290 周赛补题

T1

​​​​传送门
 

 

数据范围比较小，可以直接模拟 

class Solution {
public:
    vector<int> intersection(vector<vector<int>>& nums) {
        vector<int> aa;
        
        unordered_map<int, int> bb;
        
        for(int i = 0; i < nums.size(); i ++){
            for(int j = 0; j < nums[i].size(); j ++){
                bb[nums[i][j]] ++;
            }
        }
        
        for(auto [x, y] : bb){
            if(y == nums.size()){
                aa.push_back(x);
            }
        }
        
        sort(aa.begin(), aa.end());
        
        return aa;
    }
};

T2

 

​​​​传送门

数据范围也是很小，直接枚举每一个点，判断是否在圆（所有圆）内，有即返回1

这样就不需要去重

class Solution {
public:
    bool check(vector<vector<int>>& circles, int x, int y){
        for(auto &c : circles){ //这里用了引用，否则就超时了
            int p = c[0] - x;
            int q = c[1] - y;
            int z = c[2];

            if(p * p + q * q <= z * z){
                return true;
            }
        }

        return false; 
    }

    int countLatticePoints(vector<vector<int>>& circles) {
        int count = 0;

        for(int i = 0; i < 201; i ++){
            for(int j = 0; j < 201; j ++){
                if(check(circles, i, j) == 1){
                    count ++;
                }
            }
        }

        return count;
    }
};

T3

​​​​传送门 

一定要注意数据范围，横坐标与纵坐标的范围差距很大

由于纵坐标的范围只有 [1,100]，我们可以暴力地在每次插入完横坐标后对 x 排序，排序的次数不会超过 100 次。

对每个point，对[1,100]范围内所有高度进行遍历，在每个高度所对应的宽度列表中，进行二分搜索，找到所有比point更宽的矩阵个数，加入答案。

class Solution {
public:
    vector<int> countRectangles(vector<vector<int>>& rectangles, vector<vector<int>>& points) {
        vector<vector<int>> aa(101);

        for(auto &c : rectangles){
            int x = c[0];
            int y = c[1];

            aa[y].push_back(x);
        }

        for(auto &c : aa){
            sort(c.begin(), c.end());
        }

        vector<int> xx;
        for(auto &c : points){
            int x = c[0];
            int y = c[1];

            int count = 0;
           
            for(int i = y; i < 101; i ++){
                count += aa[i].end() - lower_bound(aa[i].begin(), aa[i].end(), x);
            }

            xx.push_back(count);
        }

        return xx;
    }
};

T4

​​​​传送门 

 

正在开的花的个数 为所有在此时间节点及之前开放的花的个数减去在时间节点之前凋谢的花的个数

直接就表明了一种新思路，大佬的一句话说明白

class Solution {
public:
    vector<int> fullBloomFlowers(vector<vector<int>>& flowers, vector<int>& persons) {
        int kai[50004], diao[50004];
        int n = flowers.size();

        for(int i = 0; i < n; i ++){
            kai[i] = flowers[i][0];
            diao[i] = flowers[i][1];
        }

        sort(kai, kai + n);
        sort(diao, diao + n);

        vector<int> aa(persons);

        for(auto &c : aa){
            int start = upper_bound(kai, kai + n, c) - kai;
            int end = lower_bound(diao, diao + n, c) - diao;

            c = start - end;
        }

        return aa;
    }
};

还有就是关于 lower_bound 与 upper_bound 的用法，以前都还没有用过（见识短） 

使用前提：一个非降序列 

它的三个参数是：

1.一个数组元素的地址（或者数组名来表示这个数组的首地址，用来表示这个数组的开头比较的元素的地址，不一定要是首地址，只是用于比较的“首”地址），

2.一个数组元素的地址（对应的这个数组里边任意一个元素的地址，表示这个二分里边的比较的"结尾'地址），

3.就是一个你要二分查找的数

还有就是在 STL 这函数的使用，具体的可以去搜一下

最后就是以后做题之前一定要看数据范围，这真的真的很重要，它决定你这题应该从哪种方向考虑