通过反转两个数组之一的子数组来最小化两个数组的相同索引元素的乘积之和

题目描述

给定两个长度相同的数组 nums1 和 nums2 ，请你通过对 nums1 中某个子数组进行翻转，使两个数组的相同下标元素的乘积之和最小化。输出最小乘积之和。

示例

示例1：

输入: nums1 = [2,3,1,5,4], nums2 = [5,4,3,2,1]
输出: 58
解释: 通过翻转 nums1 中下标从 0 到 3 的子数组，两个数组最小乘积之和为：
nums1 = [5,3,1,2,4]，nums2 = [5,4,3,2,1]，乘积之和为 5*5 + 3*4 + 1*3 + 2*2 + 4*1 = 58。

示例2：

输入：nums1 = [1,2,3,4,5], nums2 = [1,2,3,4,5]
输出：40
解释：最小乘积之和为 1*5 + 2*4 + 3*3 + 4*2 + 5*1 = 40。

示例3：

输入：nums1 = [1,1,1,2,2], nums2 = [2,2,2,1,1]
输出：16
解释：最小乘积之和为 1*2 + 1*2 + 1*2 + 2*1 + 2*1 = 16。

解题思路

这道题目可以通过贪心算法来解决。

首先，我们计算出不翻转两个数组的乘积之和 sum_no_reverse。

然后，我们考虑翻转 nums1 中的某个子数组（下标从 left 到 right），并计算两个数组的乘积之和 sum_reverse。

如果 sum_reverse < sum_no_reverse，则说明翻转子数组可以使乘积之和更小，我们更新 sum_no_reverse 的值为 sum_reverse。

需要注意的是，为了使乘积之和最小化，我们应该优先翻转那些相对较小的差值，因为这样才能在尽量不影响相同下标元素的情况下，最大程度减少乘积之和。因此，我们需要对差值（即 nums1[i] - nums2[i]）按从小到大进行排序。

具体实现详见下方代码。

复杂度分析

时间复杂度：$O(n \log n)$，其中 $n$ 是数组的长度。需要对差值进行排序，排序的时间复杂度是 $O(n \log n)$，对每个子数组进行计算需要 $O(n)$ 的时间，因此总时间复杂度为 $O(n + n\log n) = O(n \log n)$。

空间复杂度：$O(n)$，需要用一个数组记录下差值，空间复杂度为 $O(n)$。

代码实现

class Solution:
    def minProductSum(self, nums1: List[int], nums2: List[int]) -> int:
        n = len(nums1)
        diff = [nums1[i] - nums2[i] for i in range(n)]
        diff.sort()

        left, right = 0, n - 1
        sum_no_reverse = sum(nums1[i] * nums2[i] for i in range(n))
        while left < right and diff[left] < 0 and diff[right] > 0:
            sum_reverse = sum_no_reverse - diff[left] * nums2[left] - diff[right] * nums2[right] \
                          + diff[left] * nums1[right] + diff[right] * nums1[left]
            if sum_reverse < sum_no_reverse:
                sum_no_reverse = sum_reverse
                left += 1
                right -= 1
            else:
                break

        return sum_no_reverse

注：为了方便阅读和提交，以上代码中的注释、变量名、类名等有所修改。