【Leetcode】2809. 使数组和小于等于 x 的最少时间

题目

2809. 使数组和小于等于 x 的最少时间
给你两个长度相等下标从 0 开始的整数数组 nums1 和 nums2 。每一秒，对于所有下标 0 <= i < nums1.length ，nums1[i] 的值都增加 nums2[i] 。操作 完成后 ，你可以进行如下操作：

• 选择任一满足 0 <= i < nums1.length 的下标 i ，并使 nums1[i] = 0

同时给你一个整数 x 。
请你返回使 nums1 中所有元素之和 小于等于 x 所需要的 最少 时间，如果无法实现，那么返回 -1 。

示例1：
输入：nums1 = [1,2,3], nums2 = [1,2,3], x = 4
输出：3
解释：
第 1 秒，我们对 i = 0 进行操作，得到 nums1 = [0,2+2,3+3] = [0,4,6] 。
第 2 秒，我们对 i = 1 进行操作，得到 nums1 = [0+1,0,6+3] = [1,0,9] 。
第 3 秒，我们对 i = 2 进行操作，得到 nums1 = [1+1,0+2,0] = [2,2,0] 。
现在 nums1 的和为 4 。不存在更少次数的操作，所以我们返回 3 。

示例2：
输入：nums1 = [1,2,3], nums2 = [3,3,3], x = 4
输出：-1
解释：不管如何操作，nums1 的和总是会超过 x 。

提示：

• 1 <= nums1.length <= 10³
• 1 <= nums1[i] <= 10³
• 0 <= nums2[i] <= 10³
• nums1.length == nums2.length
• 0 <= x <= 10⁶

思路

这道题目咋一看好像挺复杂，但是我们慢慢来进行分析，对于数组$nums1$里面的每一个数进行的操作次数是多少次？如果要对数组里面的其中一个数进行两次或者以上的操作的话我们可以发现除了最后一次操作是有用的前面都是没用的，反正都是一次性清零对吧，这就有了第一个结论：

1. 对于每个索引 $i$，我们最多只需要将 $nums1[i]$ 设置为 $0$ 或 $1$ 次

接下来假设我们已经选定好了数组nums1中的哪些数字是要进行操作清零的，那也一定会有一个顺序吧，那么什么样的顺序才是最合适的呢，不难想到肯定是nums2数组中对应的数字小的尽量靠前，对应的数值增长的也就更慢，于是就有了第二结论：

2. 选择了若干个索引 $i1、i2、...、ik$，并将 $nums1[i1]、nums1[i2]、...、nums1[ik]$ 设置为 $0$，那么总是最优的将它们按照 $nums2[i1]<=nums2[i2]<=...<=nums2[ik]$ 的顺序设置（增加越大，越晚设置为 0）

根据以上结论我们就可以开始操作了，我们按照 $nums2$ 的值（非递减顺序）对所有值进行排序。令 $dp[i][j]$ 表示在前 $i$ 个元素上执行 $j$ 次操作时，可以减少的最大总值。然后我们有 $dp[i][0]=0$（对于所有 $i=0,1,...,n$）和 $dp[i][j]=max(dp[i-1][j],dp[i-1][j-1]+nums2[i-1]\ast j+nums1[i-1])$（对于 $1<=i<=n$ 和 $1<=j<=i$）
最后答案是 t 的最小值，使得 $0<=t<=n$ 且 $sum(nums1)+sum(nums2)\ast t-dp[n][t]<=x$，如果不存在这样的 $t$，则返回 $-1$。

代码

class Solution {
public:
    int minimumTime(vector<int>& nums1, vector<int>& nums2, int x) {
        int N = nums1.size();
        vector<vector<int>> help(N, vector<int>(2, 0));
        int s1 = 0, s2 = 0;
        for (int i = 0; i < N; i++) {
            help[i][0] = nums1[i];
            help[i][1] = nums2[i];
            s1 += help[i][0];
            s2 += help[i][1];
        }
        if (s1 <= x) {
            return 0;
        }
        sort(help.begin(), help.end(), [](const auto& i, const auto& j) {
            return i[1] < j[1];
        });
        vector<vector<int>> dp(N, vector<int>(N + 1, 0));
        for (int t = 1; t <= N; t++) {
            for (int i = t - 1; i < N; i++) {
                if (i == 1) {
                    dp[i][t] = dp[i - 1][t - 1];
                } else if (i > 1) {
                    dp[i][t] = max(dp[i - 1][t - 1], dp[i - 1][t] - help[i - 1][0] - t * help[i - 1][1]);
                }
                dp[i][t] += help[i][0] + t * help[i][1];
                if (s1 + t * s2 - dp[i][t] <= x) {
                    return t;
                }
            }
        }
        return -1;
    }
};