LeetCode刷题记录（3）

跟着英雄哥6月集训——6.3

文章目录

• 题目链接：
• • 一、1464. 数组中两元素的最大乘积
  • • • • 1.排序：
  • 二、1636. 按照频率将数组升序排序
  • • • • 1.自定义排序：
  • 三、1287. 有序数组中出现次数超过25%的元素
  • • • • 1.直接找最大：
  • 四、436. 寻找右区间
  • • • • 1.二分+排序：
• 总结

---

题目链接：

六月3日数组题目
1464. 数组中两元素的最大乘积
1636. 按照频率将数组升序排序
1287. 有序数组中出现次数超过25%的元素
436. 寻找右区间

一、1464. 数组中两元素的最大乘积 1.排序：

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        return (nums[nums.size() - 1] - 1) * (nums[nums.size() - 2] - 1);
    }
};

二、1636. 按照频率将数组升序排序 1.自定义排序：

class Solution {
public:
    vector<int> frequencySort(vector<int>& nums) {
        unordered_map<int,int> num;
        for(int i = 0; i < nums.size(); i++){
            num[nums[i]]++;
        }
        sort(nums.begin(),nums.end(), [&](const int& a, const int& b){
            if(num[a] != num[b] ){
                return num[a] < num[b];
            }
            return a > b;
        });
        return nums;
    }
};

三、1287. 有序数组中出现次数超过25%的元素 1.直接找最大：

class Solution {
public:
    int findSpecialInteger(vector<int>& arr) {
        int len = arr.size();
        int x[100000 + 5] = {0};
        for(int i = 0; i < len; i++) {
            x[arr[i]]++;
        }
        int Max = x[0];
        int m = 0;
        for(int i = 0; i < 100000 + 5; i++) {
            if(Max < x[i]) {
                Max = x[i];
                m = i;
            }
        }
        return m;
    }
};

四、436. 寻找右区间 1.二分+排序：

抄一下二分的用途(来自力扣负雪明烛)
二分查找有不同的应用：
1.找到 target 的位置（常见）
2.找到大于等于 target的第一个位置
3.找到大于 target 的第一个位置
4.找到小于等于 target 的第一个位置
5.找到小于 target 的第一个位置
今天使用的就是第 2 种应用：「找到大于等于 target 的第一个位置」。
二分查找的本质是每次排除掉不可能存在结果的区间。
二分查找的前提是数组是有序的

说一下本题思路：题目给了一个数组 intervals，其中的每个元素都是一个区间。
当区间B的起点 大于等于 区间 A 的终点，我们就说区间 B 在区间 A 的右侧。
B不一定真的在A的右侧，B可以在数组的任何位置
让我们求每个区间的右侧第一个区间（右侧的区间中，起点最小的那个）。
我们先将所有区间B的起点都存在一个数组C中，进行排序，
然后通过二分查找的方法遍历：数组C和每一个区间A的终点

class Solution {
public:
    vector<int> findRightInterval(vector<vector<int>>& intervals) {
        unordered_map<int,int> start_map;
        vector<int> starts;
        for(int i = 0; i < intervals.size(); i++){
            starts.push_back(intervals[i][0]);
            start_map[intervals[i][0]] = i;
        }
        sort(starts.begin(),starts.end());
        vector<int>ans;
        for(auto &it : intervals) {
            int index = BSfind(starts,it[1]);//注意返回的下标
            ans.push_back(index == -1 ? -1 : start_map[starts[index]] );//通过下标index找到starts中所代表的区间，在找区间所在的下标
        }
        return ans;
    }
    int BSfind(vector<int>& vec, int target){//返回vec的下标
        if(target > vec[vec.size() - 1]) {
            return -1;
        }
        int left = 0;
        int right = vec.size() - 1;
        while(left < right){
            int mid = (left + right) / 2;
            if(vec[mid] >= target) {
                right = mid;
            }
            else{
                left = mid + 1;
            }
        }
        return left;
    }
};

总结

坚持就是胜利！！！