2809. 使数组和小于等于 x 的最少时间，编辑距离问题

一、题目

1、题目描述

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

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

同时给你一个整数?x?。

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

2、接口描述

?

class Solution {
public:
    int minimumTime(vector<int>& nums1, vector<int>& nums2, int x) {
        
    }
};

3、原题链接

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

---

二、解题报告

1、思路分析

今天和昨天的题目都是动态规划问题中涉及元素操作的编辑距离问题

这类问题的常规解法是设计状态dp[i][j]，为前i个元素操作j次的最小代价

对于本题而言，我们不难想出每个元素最多进行一次操作，如果可以进行两次，那么完全可以只保留最后一次，第一次是冗余的

所以我们最终也最多进行n次操作

其次，我们贪心的考虑，显然nums2[i]越大的nums1[i]要越晚操作，不然操作太早后面涨的多

我们把nums1按照nums2升序排序

定义状态dp[i][j]为前i个元素操作j次所能减少的最大值

最终我们要求的最少操作次数就是满足sum(nums1) + sum(num2) - dp[n][j] <= x的最小j

dp[i][j] = max(dp[i - 1][j] , dp[i - 1][j - 1] + vpii[i - 1].second + vpii[i - 1].first * j);

vpii为存储nums2[i],nums1[i]的键值对数组，已经按照nums2[i]升序排序

由于我们发现每次状态转移只跟上一行的前一列和当前列有关，所以我们可以倒序转移滚动数组优化

2、复杂度

时间复杂度： O(N^2) 空间复杂度：二维dp:O(N^2) 滚动优化:O(N)

3、代码详解

?二维dp代码

class Solution {
public:
typedef pair<int,int> pii;
    int minimumTime(vector<int>& nums1, vector<int>& nums2, int x) {
        vector<pii> vpii;
        int n = nums1.size() , s1 = accumulate(nums1.begin() , nums1.end() , 0) , s2 = accumulate(nums2.begin() , nums2.end() , 0);
        for(int i = 0 ; i < n ; i++)
            vpii.emplace_back(nums2[i] , nums1[i]);
        sort(vpii.begin() , vpii.end());
        vector<vector<int>> dp(n + 1 , vector<int>(n + 1));
        for(int i = 1 ; i <= n ; i++)
            for(int j = 1 ; j <= i ; j++)
                dp[i][j] = max(dp[i - 1][j] , dp[i - 1][j - 1] + vpii[i - 1].second + vpii[i - 1].first * j);
        for(int i = 0 ; i <= n ; i++)
            if(s2 * i + s1 - dp[n][i] <= x)
                return i;
        return -1;
    }
};

滚动数组优化代码

class Solution {
public:
typedef pair<int,int> pii;
    int minimumTime(vector<int>& nums1, vector<int>& nums2, int x) {
        vector<pii> vpii;
        int n = nums1.size() , s1 = accumulate(nums1.begin() , nums1.end() , 0) , s2 = accumulate(nums2.begin() , nums2.end() , 0);
        for(int i = 0 ; i < n ; i++)
            vpii.emplace_back(nums2[i] , nums1[i]);
        sort(vpii.begin() , vpii.end());
        vector<int> dp(n + 1);
        for(int i = 1 ; i <= n ; i++)
            for(int j = i ; j >= 1 ; j--)
                dp[j] = max(dp[j] , dp[j - 1] + + vpii[i - 1].second + vpii[i - 1].first * j);
        for(int i = 0 ; i <= n ; i++)
            if(s2 * i + s1 - dp[i] <= x)
                return i;
        return -1;
    }
};