12.哀家要长脑子了！

1.189. 轮转数组 - 力扣（LeetCode）

方法一：

要注意这个k是可以大于0的，所以旋转数组的时候要一直保证是在1-n的范围内：%实现

把k个元素旋转放到前面，前面n-k个元素是向后移动的。

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> t(n);
        for(int i = 0; i < n; i++){
            t[(i+k)%n] = nums[i]
        }
        nums.assign(t.begin(), t.end());
    }
};

方法二：

先把这个数组旋转倒置过来，再以第k个元素为界，分别旋d

class Solution {
    void reverse(int start, int end, vector<int> &nums){
        while(start < end){
            swap(nums[start], nums[end]);
            start++, end--;
        }
    }

public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        int k %= n;
        reverse(0, n-1, nums);
        reverse(0, k-1, nums);
        reverse(k, n-1, nums);
    }
};

2. 396. 旋转函数 - 力扣（LeetCode）

嗯。。。我只能说：数学是硬伤。。。。

F(k) = F(k-1) + sum - n*nums[n-k];

class Solution {

public:
    int maxRotateFunction(vector<int>& nums) {
        int n =nums.size();
        int sum = accumulate(nums.begin(), nums.end(), 0);
        int f = 0;
        for(int i = 0; i < n; i++){
            f += i * nums[i];
        }
        int res = f;
        for(int i = n - 1; i > 0; i--){
            f += sum - n * nums[i];
            res = max(res, f); 
        }
        return res;
    }
};

3. 645. 错误的集合 - 力扣（LeetCode）

我真的伤了。。。被自己蠢笑了明明以前做过雷同的题目，为什么为什么还是做不出来啊，我朝立马

class Solution {
public:
    vector<int> findErrorNums(vector<int>& nums) {
        vector<int> res(2);
        sort(nums.begin(), nums.end());
        int pre = 0;
        for(int i = 0; i < nums.size(); i++){
            int now = nums[i];
            if(pre == now){
                res[0] = now;
            }
            else if(now - pre > 1){
                res[1] = pre + 1;
            }
            pre = now;
        }
        if(nums.size() != nums[nums.size() - 1]){
            res[1] = nums.size();
        }
        return res;
    }
};

是因为这个元素值是从1开始，数组下标从0开始，还要判断是不是最后一个元素重复的，我老是搞不清，我是真的不清白啊。。。。。

4. 697. 数组的度 - 力扣（LeetCode）

我知道思路了，但是为什么不会实现呢，我天呢小姐姐

用三个无序map，分别是left，right，counter；遍历数组。left用来访元素第一次出现的位置，right放元素第二次出现的位置，counter放元素的度

数组的度是指元素在数组中出现最多的次数。那么这个元素本身可能是在数组里的，题目要求求与原数组度相同的最短的子数组，那么就让第一次出现的位置与最后一次出现的位置得到距离最小就好。

class Solution {
public:
    int findShortestSubArray(vector<int>& nums) {
        unordered_map<int, int> left, right, counter;
        int degree = 0;
        for(int i = 0; i < nums.size(); i++){
            if(!left.count(nums[i]))
                left[nums[i]] = i;
            right[nums[i]] = i;
            counter[nums[i]]++;
            degree = max(degree, counter[nums[i]]);    
        }
        int res = nums.size();
        for(auto& kv : counter){
            if(kv.second == degree){
                res = min(res, right[kv.first] - left[kv.first] + 1);
            }
        }
        return res;
    }
};

5.448. 找到所有数组中消失的数字 - 力扣（LeetCode）

哎哟，感觉这些题目好奇妙啊。我真服了，为什么我想不到

class Solution {
public:
    vector<int> findDisappearedNumbers(vector<int>& nums) {
        vector<int> res;
        sort(nums.begin(), nums.end());
        for(auto num: nums){
            int x = (num - 1) % nums.size();
            nums[x] += nums.size();
        }
        for(int i = 0; i < nums.size(); i++){
            if(nums[i] <= nums.size()){
                res.push_back(i + 1);
            }
        }
        return res;
    }
};