1.1705. 吃苹果的最大数目 - 力扣（LeetCode）

 贪心贪在哪里，用一个优先队列（小根堆）存储腐烂日期和该日期苹果腐烂的数量。优先吃掉距离腐烂日期最近的苹果。吃苹果分为两个阶段，第一个是在1-n天内，第二个阶段时n天之后，n天之后可以吃掉的苹果数量由剩余可以吃的日期和苹果数量中的较小值决定。

class Solution {
typedef pair<int, int> PII;
public:
    int eatenApples(vector<int>& apples, vector<int>& days) {
        // 存储苹果日期和该日期腐烂的苹果个数 
        priority_queue<PII, vector<PII>, greater<PII>> pq;

        // 最终可以吃掉的苹果个数和当日日期
        int res = 0, i = 0;
        // 总天数
        int n = apples.size();

        while(i < n){
            // 移除腐烂苹果
            while(!pq.empty() && pq.top().first <= i)
                pq.pop();
            
            // 计算此时这个苹果的腐烂日期
            int exp = i + days[i];
            // 添加新的苹果信息
            if(apples[i] > 0)
                pq.push({exp, apples[i]});
            
            // 当队列非空时，有苹果可以吃
            if(!pq.empty()){
                // 拿出这个日期的所有苹果
                auto arr = pq.top();
                pq.pop();
                // 吃掉一个苹果
                arr.second--;
                // 一天只能吃一个苹果，如果这个日期的苹果没有吃完，剩余苹果放回去
                if(arr.second != 0){
                    pq.emplace(arr.first, arr.second);
                }
                res++;
            }
            // 日子像旋转木马 在脑海里转不停~ 
            i++;
        }

        // n天之后还有苹果可以吃 
        while(!pq.empty()){
            // 移除腐烂苹果
            while(!pq.empty() && pq.top().first <= i){
                pq.pop();
            }
            
            // 空空如也~
            if(pq.empty())
                break;
            
            // 拿出
            auto arr = pq.top();
            pq.pop();
            
            // 苹果的腐烂日期 和 苹果数量 被小的控制 懂自懂
            int rem = min(arr.first-i, arr.second);
            res += rem;
            i += rem;
        }
        return res;
    }
};

2.1630. 等差子数组 - 力扣（LeetCode）

 狐假虎威的中等题、、

class Solution {
public:
    bool isCha(vector<int> &nums){
        sort(nums.begin(), nums.end());
        int dif = nums[1] - nums[0];
        for(int i = 1; i < nums.size(); i++)
            if(dif != nums[i] - nums[i-1]) return false;
        return true;
    }
    vector<bool> checkArithmeticSubarrays(vector<int>& nums, vector<int>& l, vector<int>& r) {
        vector<bool> res;
        int n = l.size();
        for(int i = 0; i < n; i++) {
            vector<int> temp;
            for(int j = l[i]; j <= r[i]; j++){
                temp.push_back(nums[j]);
            }
            bool flag = isCha(temp);
            res.push_back(flag);
        }
        return res;
    }
};

3.870. 优势洗牌 - 力扣（LeetCode）

我感觉准备蓝桥杯的时候，做过类似的，我以为的贪心是把优先匹配差值最小的对应nums1元素，然而并不是。。。

后面看了挺久的感觉。。能想到是田忌赛马但是不知道怎么实现的，哈哈。（额..并不是很好笑好吗，谢谢）

贪心贪在哪里，贪在如果这个nums1元素不能满足大于最小的nums2元素的话，的话那就直接把它放在nums2最大元素的位置，但是这个nums2元素的位置不能改变，用一个数组来记录nums2从小到大的元素及其对应下标。

class Solution {
public:
    vector<int> advantageCount(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size();
        vector<int> res(n);
        sort(nums1.begin(), nums1.end());
        
        vector<int> ids(n);
        iota(ids.begin(), ids.end(), 0);
        sort(ids.begin(), ids.end(), [&](int i, int j){
            return nums2[i] < nums2[j];
        });

        int left = 0, right = n-1;
        for(int x : nums1){
            // 如果这个nums1能满足要求，就把他放在对应最小的nums2的位置，如果不能就放在最大的nums2的位置
            res[x > nums2[ids[left]] ? ids[left++] : ids[right--] ] = x;
        }
        return res;
    }
};

4.507. 完美数 - 力扣（LeetCode） 

不好意思啊，十分抱歉的水了一题（咬牙切齿），谢谢（哎呀，树莓说话太上头了

 

class Solution {
public:
    bool checkPerfectNumber(int num) {
        vector<int> mul;
        int res = 0;
        for(int i = 1; i < num; i++){
            if(num % i == 0)    
                mul.push_back(i);
        }

        int t = accumulate(mul.begin(), mul.end(), 0);
        if(t == num) 
            return true;
        return false;
    }
};

 5.202312-2 因子化简

 我的玛雅。。我真的不知道到时候我要怎么去过这个认证，我的天爷。。。。。

 其实没什么算法，但是这个操作。。。。。。太太太让我不知所措了，自己写的时候还是理不清

#include<iostream>
#include<vector>
#include<math.h>

using namespace std;

int main(){
    int q;
    cin >> q;
    
    vector<vector<long long>> a(q, vector<long long>(2));
    for(int i = 0; i < q; i++){
        cin >> a[i][0];
        cin >> a[i][1];
    }
    
    // 创建质数表
    vector<int> b;
    int n = pow(10, 5);
    int length = 0;
    int j; 
    for(int i = 2; i < n; i++){
        int m = sqrt(i);
        for(j = 2; j <= m; j++){
            if(i % j ==0) break;
        }
        if(j >= m){
            b.push_back(i);
            length++;
        }
    }

    
    for(int i = 0; i < q; i++){

        int count = -1;
        vector<vector<int>> c;

        for(int j = 0; j < length; j++){

            bool flag = true;
            while(a[i][0]%b[j] == 0 && a[i][0] != 0){
                // 添加新的质数
                if(flag){
                    count++;
                    c.push_back({b[j],0});
                    flag = false;
                }   
                // 增加对应质数的指数
                c[count][1]++;
                a[i][0] /= b[j];
            }   
            if(a[i][0] == 1)
                break;    
        } //Jfor

        // 计算
        long long sum = 1;
        for(int k = 0; k < c.size(); k++){
            if(c[k][1] >= a[i][1]){
                sum *= pow(c[k][0], c[k][1]);
            }
        }
        cout << sum << endl;
    }  //Ifor

   return 0;
}