33.哀家要长脑子了！

憋说了，感觉好不容易长出来的脑子又缩回去了。。。

1.539. 最小时间差 - 力扣（LeetCode）

把所有时间排好序，然后计算两两之间的分钟差就好，但是要注意加上最后一个和第一个的判断，因为这个时间是按字典序来排序的。所以像23：59 和 00：00 会被放在最后一个和第一个，漏判它俩，但其实他俩就差一分钟，很有可能就是正确答案。

添加一个判断更快

鸽巢原理（抽屉原理）

是一个基本的组合数学原理，简单的表述为：如果要把 n+1 个物体放入 n 个盒子中，那么至少有一个盒子里面会包含两个或两个以上的物体

在本题中的应用：一天最多24小时，1440分钟，即一共有1440种不同的时间，如果timesPoint的长度超过1440，那么必然会有两个相同的时间，此时可以直接返回0

还有就是小时转分钟

// 12:34 

// (1*10 + 2) *60 + (3*10 + 4) = 754

return (int(t[0] - '0')*10 + int(t[1] - '0'))*60 + int(t[3] - '0')*10 +int(t[4] - '0'); 

class Solution {
public:
    int getMin(string t){
  return (int(t[0] - '0')*10 + int(t[1] - '0'))*60 + int(t[3] - '0')*10 +int(t[4] - '0'); 
    }

    int findMinDifference(vector<string>& timePoints) {
        if(timePoints.size() > 1440){
            return 0;
        }
        sort(timePoints.begin(), timePoints.end());
        // 初始化所需变量
        int t0Min = getMin(timePoints[0]);
        int preMin = t0Min;
        int res = INT_MAX;

        for(int i = 1; i < timePoints.size(); i++){
            int nowMin = getMin(timePoints[i]);
            res = min(res, nowMin - preMin);
            preMin = nowMin;
        }

        res = min(res, t0Min + 1440 - preMin);
        return res;
    }
};

 

2.553. 最优除法 - 力扣（LeetCode）

 不明白为什么这个当时也想不懂。。。

对于除法要使其运算结果最大，那么就是，被除数最大，除数最小（直接在除数上面下功夫）。对于三个数及以上的除法运算，要使得其除数最小，就要使它的被除数最小，除数最大（在被除数上做手脚）就直接按顺序运算，一路运算过去就好。

class Solution {
public:
    string optimalDivision(vector<int>& nums) {
        string res;
        int n = nums.size();
        for(int i = 0; i < n; i++){
            
            res += to_string(nums[i]);
            if(i < n-1){
                res += "/";
            }
            if(i == 0 && n > 2){
                res += "(";
            }
        }
        if(n > 2){
            res += ")";
        }
        return res;
    }
};

3.537. 复数乘法 - 力扣（LeetCode）

复数的运算公式

(a+bi) * (c+di) = (ac - bd) + (bc + ad)i

主要是对代码掌握的熟练程度

class Solution {
public:
    pair<int, int> parse(string num){
        // 找到+号
        auto pos = find(num.begin(), num.end(), '+');
        // pos - num.begin() 是+号的位置
        string re = num.substr(0, pos - num.begin());
        string im = num.substr(pos - num.begin() + 1, num.begin() - pos - 2);
        // 分离出实数部分与虚数部分并返回
        return {stoi(re), stoi(im)};
    }
    string complexNumberMultiply(string num1, string num2) {
        // 结构化绑定
        auto[a,b] = parse(num1);
        auto[c,d] = parse(num2);
        int re = a*c - b*d;
        int im = a*d + b*c;
        return to_string(re) + '+' + to_string(im) + 'i';
    } 
};

注意：find()返回的是一个迭代器，想要找到位置，还需要减去最初开始位置的迭代器。

substr() 剪切的是一个左闭右开区间

    string s = "abcdefg";
    cout << s.substr(0,5);         // abcde

计算位置：

-1是减去+号的位置 还有一个-1减去的是偏移量，因为nums.end()指向的不是数组的最后一个元素而是最后一个元素还要后面的一个元素，别忘了。

 string im = num.substr(pos - num.begin() + 1, num.begin() - pos - 2);

 结构化绑定：

auto[a,b] = parse(num1);

基本语法：

auto [variable1, variable2, ..., variablen] =expression;

这里，expression是一个能够提供多个值（例如通过元组，pair或其他聚合类型）的表达式，而variable1, variable2, ..., variablen是声明的变量名，它们会依次绑定道expression提供的值上。

例如题中的parse(num1)返回的是：num1{2, 3}

那么a = 1, b = 3

4.Acwing-快速排序

模板

quick_sort(int q[], int l, int r){
    if(l >= r) return;
    
    int i = l - 1, j = r + 1, x = q[l+r>>1];
    while(i < j) {
        do i++; while(q[i] < x);
        do j--; while(q[i] > x);
        if(i < j)    swap(q[i], q[j]);
    }
    quick_sort(q, l, j);
    quick_sort(q, j+1, r);
}

quick_sort(q, 0, r-1);