前言：对待这个问题，我想到就是一定是贪心，但是我不知道怎么排序

对待这种问题，肯定是要先假设只有两个，我们要怎么排序呢

class Solution {
public:
    long long minDamage(int power, vector<int>& damage, vector<int>& health) {
        int n = health.size();
        vector<pair<int, int>> a(n);
        for (int i = 0; i < n; i++) {
            a[i] = {(health[i] - 1) / power + 1, damage[i]};
        }
        ranges::sort(a, [](const auto& p, const auto& q) {
            return p.first * q.second < q.first * p.second;
        });

        long long ans = 0, s = 0;
        for (auto& [k, d] : a) {
            s += k;
            ans += s * d;
        }
        return ans;
    }
};

我们再来看一个类似的题目

这个题目和上面这个题目的共同点就是都存在一个固定值，上面这一题的固定值就是cnt是固定的，这一题是花在能力损耗的值是一定的，我们需要虚耗的少一些

bool cmp(vector<int> a, vector<int> b) {
    int u = a[1] - a[0]; int v = b[1] - b[0];
    if (u > v) return 1;
    else if (u == v) return a[1] > b[1];
    return 0;
}

class Solution {
public:
    int minimumEffort(vector<vector<int>>& tasks) {
        int n = tasks.size();
        sort(tasks.begin(), tasks.end(),cmp);
        int num = 0;
        for (int i = 0; i < n; i++) {
            num += tasks[i][0];
        }
        int ans = num;
        for (int i = 0; i < n; i++) {
            if (num >= tasks[i][1]) {
                num -= tasks[i][0];
            }
            else {
                ans += tasks[i][1] - num;
                num = tasks[i][1] - tasks[i][0];
            }
        }return ans;
    }
};