49.哀家要长脑子了！

1.860. 柠檬水找零 - 力扣（LeetCode）

贪心贪在哪里。。贪在当需要给20元找零时，优先使用10元的钞票，因为5元的钞票有更多用武之地。其实也就是一个模拟的过程。注意细节的处理。

C++版本

class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        int five = 0, ten = 0;
        for(int b : bills) {
            if(b == 5)
                five++;
            else if(b == 10){
               if(five == 0) return false;
               ten++, five--;
            }
            else{
                if(five>0 && ten>0)
                    five--, ten--;
                else if(five >= 3)
                    five -= 3;
                else 
                    return false;
            }
        
        }
       return true;
    }
};

Java版本

class Solution {
    public boolean lemonadeChange(int[] bills) {
        int five = 0, ten = 0;
        for(int b : bills) {
            if(b == 5) five++;
            else if(b == 10) {
                if(five == 0) return false;
                else{
                    five--;
                    ten++;
                }
            }
            else {
                if(five > 0 && ten > 0) {
                    five--;
                    ten--;
                }
                else if(five >= 3) 
                    five -= 3;
                else 
                    return false;
            }
        }
        return true;
    }
}

2.1342. 将数字变成 0 的操作次数 - 力扣（LeetCode）

用的最蠢的办法，直接模拟。。

class Solution {
public:
    int numberOfSteps(int num) {
        int res = 0;
        while(num != 0) {
            if(num % 2 == 0) {
                num /= 2;
                res++;
            }
            else{
                num--;
                res++;
            }
        }
        return res;
    }
};

3.621. 任务调度器 - 力扣（LeetCode） 

class Solution {
public:
    int leastInterval(vector<char>& tasks, int n) {
        // len 表示任务总数，如果任务的总数已经足够大，那么不需要额外的时间来安排任务
        // 即使有冷却时间，任务总数本身就足以覆盖所有的时间
        int len = tasks.size();
        vector<int> vec(26);

        // 统计每个任务的频率
        for(char c : tasks) ++vec[c - 'A'];

        // 将频率从大到小排序
        sort(vec.begin(), vec.end(), greater<>());
        
        // 计算最高频率的任务数 每个最高频率的任务之间至少需要vec[0]-1 个间隔，每个间隔需要n+1 个时间
        int cnt = 1;
        while(cnt < vec.size() && vec[cnt] == vec[0]) cnt++;
        
        // 加上cnt 是多个最高频率的任务在最后一个间隔之后的时间 也就是说最后一个任务的时间也要算上
        // 后者计算的是最高频率的任务之间有足够的间隔时间
        return max(len, cnt + (n+1) * (vec[0]-1));
    }
};

说实话，我不理解这个题目的意思，题解也看不明白，感觉题目要求的是最短间隔时间，答案求得是完成任务的时间，这个任务怎么安排怎么插的我也不理解。。。只能跟着通义千问老哥走了。。

4.CCF-CSP 202312-1 仓库规划

其实吧，我看了答案，慢慢看懂之后，感觉这个题目也不难，但是我又没想出，还是对代码的掌握能力太弱了，这句话五个月之前就说过，五个月后还说，，无地自容。。。恐怖如斯。。。。还是我太依赖答案了吗？。。

#include<iostream>
#include<vector>
using namespace std;

int main(){
    
    int n = 0, m = 0;
    cin >> n >> m;

    vector<vector<int>> warehouse(n+1, vector<int>(m));
    for(int i = 1; i <= n; i++){
        for(int j = 0; j < m; j++){
            cin >> warehouse[i][j];
        }
    }
    
    for(int i = 1; i <= n; i++){ 
        int res = 0;
        for(int j = 1; j <= n; j++){
            if(i != j){    
                bool flag = true;
                for(int k = 0; k < m; k++){
                    if(warehouse[i][k] >= warehouse[j][k]) {
                        flag = false;
                        break;
                    } 
                }
                if(flag){
                    res = j;        
                    break;
                }
            }
        } 
        cout << res << endl;
    } 
    return 0;
}

这个提交的时候记得要选C++ 11标准，数组开大一点，怕溢出。

第一层for循环用来找答案，有四个答案要找，定位每个仓库，给每个仓库找一个上级仓库出来。

第二层for循环用来每次遍历四个仓库，每一次都把每个仓库作为可能的上级仓库去比较是否符合条件。

第三层for循环用来比较每个仓库的编码，第一列第二列... ，在可能的上级仓库j 中，只要当下的仓库i 有一列不符合要求（大于上级仓库编码），那都是不行的，直接不用比较这个上级仓库j 的其他列，跳出这个循环，进入下一个j循环，比较下一个可能的上级仓库。