leetcode1526. 形成目标数组的子数组最少增加次数（Python3、c++）

leetcode1526. 形成目标数组的子数组最少增加次数

给你一个整数数组 target 和一个数组 initial ，initial 数组与 target 数组有同样的维度，且一开始全部为 0 。

请你返回从 initial 得到 target 的最少操作次数，每次操作需遵循以下规则：

• 在 initial 中选择 任意 子数组，并将子数组中每个元素增加 1 。

答案保证在 32 位有符号整数以内。

示例 1：

输入：target = [1,2,3,2,1]
输出：3
解释：我们需要至少 3 次操作从 intial 数组得到 target 数组。
[0,0,0,0,0] 将下标为 0 到 4 的元素（包含二者）加 1 。
[1,1,1,1,1] 将下标为 1 到 3 的元素（包含二者）加 1 。
[1,2,2,2,1] 将下表为 2 的元素增加 1 。
[1,2,3,2,1] 得到了目标数组。

示例 2：

输入：target = [3,1,1,2]
输出：4
解释：(initial)[0,0,0,0] -> [1,1,1,1] -> [1,1,1,2] -> [2,1,1,2] -> [3,1,1,2] (target) 。

示例 3：

输入：target = [3,1,5,4,2]
输出：7
解释：(initial)[0,0,0,0,0] -> [1,1,1,1,1] -> [2,1,1,1,1] -> [3,1,1,1,1] 
                                  -> [3,1,2,2,2] -> [3,1,3,3,2] -> [3,1,4,4,2] -> [3,1,5,4,2] (target)。

示例 4：

输入：target = [1,1,1,1]
输出：1

提示：

• 1 <= target.length <= 10^5
• 1 <= target[i] <= 10^5

---

方法：数组差分

思路：

我们首先给出答案，然后解释这个答案的正确性，将initial数组转换为target，等价于将target转换为initial，即将所有值变为0，每次可以选择子数组，子数组中所有数减1。最后的答案即为target数组中，相邻两个值的正差分项之和**（如果后一个值大于前一个，则加上两数之差，如果小于，则忽略）。**

下面我们来解释为什么只需要考虑相邻两个数之间的递增关系。

对于[2,1,1,1]，对一个值2，至少需要两次才能递减到0，那么就是需要两次的子数组都包含该值2，而剩余的数值是递减的（非严格递减），所以不需要继续选择子数组（因为第一次选择2的时候，可以选择整个数组作为子数组，这样后边的1就都变成0了）。

对于例子[3,1,5,4,2]，对第一个3，需要3次变成0；下一个数字1，小于3，在3变成0的过程中它也变成0了；下一个数字5，比1大，可以在1变成0的时候，跟随着变成4，此时1已经变成0了，最前面的3变成了2，但是最前面的数字2继续变得时候，由于中间这个0的存在，无法构成子数组来将此时的4继续改变，因此此时4只能自己改变，因此需要改变4次；后面的数字都是递减的，因此都可以在数字5递减的时候递减到0，所以最后的答案为3+4=7。

代码：

Python3：

class Solution:
    def minNumberOperations(self, target: List[int]) -> int:
        n = len(target)
        res = target[0]
        # 直接求所有的target[i]-target[i-1]大于0的和，差分项之和
        for i in range(1,n):
            res += max(target[i]-target[i-1],0)
        return res

cpp：

class Solution {
public:
    int minNumberOperations(vector<int>& target) {
        int n = target.size();
        int res = target[0];
        // 直接求所有的target[i]-target[i-1]大于0的和，差分项之和
        for (int i = 1; i < n; ++i){
            res += max(target[i]-target[i-1],0);
        }
        return res;

    }
};

结果：