代码随想录额外题目| 数组01 ●1365小于当前数字个数 ●941有效的山脉数组 ●1207独一无二的出现次数

#1365小于当前数字个数 easy

方法一：brute force两层，时间很差，空间好

方法二：sort，用map存，时间好，空间很差

比如有五个，四个distinct的，map里只存了四个是对的。然后最后结果恢复原来的顺序的关键是：

 // use the number in nums as the key to get the corresponding value in mymap
 res[i] = mymap[nums[i]];

vector<int> smallerNumbersThanCurrent(vector<int>& nums) {
    vector<int> nums1 = nums;
    sort(nums1.begin(), nums1.end());

    map<int, int> mymap; // ordered
    for (int &ele : nums) { 
        mymap[ele] = 0;
    }

    for (int i = 0; i < nums1.size(); i++) {
        if (i - 1 >= 0 && nums1[i] == nums1[i - 1]) {
            mymap[nums1[i]] = mymap[nums1[i - 1]];
        }
        else {
            mymap[nums1[i]] = i;
        }
    }

    vector<int> res(nums.size()); 
    for (int i = 0; i < nums.size(); i++) {
        // use the number in nums as the key to get the corresponding value in mymap
        res[i] = mymap[nums[i]]; 
    }

    return res;
}

方法三：随想录方法，相当于我的方法二优化： sort，用hash ary

几个改进:1.直接用个ary当hash 2.中间逻辑不用那么复杂，直接从后往前，小的idx就覆盖了大的

3.注意题目写的constraint，就可以把hash有固定大小。

vector<int> smallerNumbersThanCurrent(vector<int>& nums) {
        vector<int> vec = nums;
        sort(vec.begin(), vec.end()); 
        int hash[101]; //因为0 <= nums[i] <= 100
        //排序后从后往前，大的先赋值，然后是小的，所以小的覆盖了大的
        //我们需要的就是一堆相等元素，最小的index
        for (int i = vec.size() - 1; i >= 0; i--) { 
            hash[vec[i]] = i;
        }
        for (int i = 0; i < nums.size(); i++) {
            vec[i] = hash[nums[i]];
        }
        return vec;
    }

---

#941有效的山脉数组 easy

my code:从头开始走

bool validMountainArray(vector<int>& arr) {
        if(arr.size()<3) return false;

        int i=1;
        while(arr[i]>arr[i-1]) i++;
        if(i<=1 || i-1>arr.size()-2) return false;
        if(i+1<arr.size() && arr[i+1]==arr[i]) return false;

        while(i<arr.size() && arr[i]<arr[i-1]) i++;
        if(i==arr.size()) return true;
        return false;
        
    }

 随想录code：从两头开始双指针，也很好

bool validMountainArray(vector<int>& A) {
        if (A.size() < 3) return false;
        int left = 0;
        int right = A.size() - 1;

        // 注意防止越界
        while (left < A.size() - 1 && A[left] < A[left + 1]) left++;

        // 注意防止越界
        while (right > 0 && A[right] < A[right - 1]) right--;

        // 如果left或者right都在起始位置，说明不是山峰
        if (left == right && left != 0 && right != A.size() - 1) return true;
        return false;
    }

---

#1207独一无二的出现次数 easy

my code:

bool uniqueOccurrences(vector<int>& arr) {
        sort(arr.begin(),arr.end());
        int cnt=1;
        set<int> cntset;
        for(int i=1;i<arr.size();i++){
            if(arr[i-1]==arr[i]) cnt++;
            else{
                if(cntset.find(cnt)==cntset.end()) cntset.insert(cnt);
                else return false;
                cnt=1;
            }
        }
        if(cntset.find(cnt)==cntset.end()) cntset.insert(cnt);
        else return false;
        return true;
    }

随想录：数组在哈希的经典运用

注意Constraints都这么写了，很小，就明显可以做数组哈希

Constraints:

• 1 <= arr.length <= 1000
• -1000 <= arr[i] <= 1000

注意本题有负数：

本题强调了-1000 <= arr[i] <= 1000，那么就可以用数组来做哈希，arr[i]作为哈希表（数组）的下标，那么arr[i]可以是负数，怎么办？负数不能做数组下标。

此时可以定义一个2000大小的数组，例如int count[2002];，统计的时候，将arr[i]统一加1000，这样就可以统计arr[i]的出现频率了。

 bool uniqueOccurrences(vector<int>& arr) {
        int count[2002] = {0}; // 统计数字出现的频率
        for (int i = 0; i < arr.size(); i++) {
            count[arr[i] + 1000]++;
        }
        bool fre[1002] = {false}; // 看相同频率是否重复出现
        for (int i = 0; i <= 2000; i++) {
            if (count[i]) {
                if (fre[count[i]] == false) fre[count[i]] = true;
                else return false;
            }
        }
        return true;
    }