题目描述

给定一个整数数组 nums 和一个正整数 k，你需要将这个数组划分成两个长度为 k 的子集，使得两个子集中所有整数的和的差的绝对值最小化。请计算这个最小差值。

例如，给定 nums = [1, 2, 3, 4, 5] 和 k = 2，可能的两个子集为 [1, 2] 和 [3, 4]，它们的和之差的绝对值为 2。

算法思路

这是一道非常经典的动态规划问题。

首先，我们需要把数组 nums 拆分成两个长度为 k 的子数组，可以使用双指针的方法，时间复杂度为 O(n)。

接下来，根据动态规划的思想，我们用一个二维数组 dp[i][j] 表示前 i 个数中选择 j 个数的所有方案中，两个子数组和的差的最小值。

当 i < 2j 时，这个方案不存在，dp[i][j] = MAX（因为两个子数组至少都包含一个数）。

当 j = 1 时，dp[i][j] 可以直接求解，即 dp[i][j] = abs(sum(nums[0:i]) - sum(nums[i-k:i]))。

当 j > 1 时，我们需要在前一个状态 dp[i-1][j-1] 的基础上，再添加第 j 个数到其中一个子数组中，或者添加到另一个子数组中，取最小值。

最后，遍历 dp[nums_len][k] 的所有值，取最小值即可得到两个长度为 k 的子集之间的最小差值。

算法实现

以下是 Python 代码实现：

def minimum_difference(nums, k):
    nums_len = len(nums)
    # 特判
    if nums_len < 2 * k:
        return -1

    # 双指针拆分 nums 为两个长度为 k 的子数组
    left, right = 0, k
    sub1 = nums[left:right]
    sub2 = nums[right:right + k]
    left_max = nums[left] if k > 1 else 0
    right_max = nums[right] if k > 1 else 0
    while right < nums_len and nums_len - right >= k:
        left_max = max(left_max, nums[left + 1])
        if nums[right] > left_max:
            # 把右指针移到左指针的右边一位
            right = left + 2
            sub1 = nums[left + 1:right]
            sub2 = nums[right:right + k]
            left_max = nums[left + 1]
            right_max = nums[right]
        else:
            right_max = max(right_max, nums[right + 1])
            if nums[left] >= right_max:
                # 把左指针移到右指针的左边一位
                left = right - 1
                sub2 = nums[left:left + k]
                sub1 = nums[left + k:right + 1]
                left_max = nums[left]
                right_max = nums[right + 1]
        right += 1

    # 初始化 dp 数组
    dp = [[float('inf')] * (k + 1) for _ in range(nums_len + 1)]

    for i in range(2 * k, nums_len + 1):
        for j in range(1, k + 1):
            if i < 2 * j:
                dp[i][j] = float('inf')
            elif j == 1:
                dp[i][j] = abs(sum(nums[0:i]) - sum(nums[i - k:i]))
            else:
                dp[i][j] = min(dp[i - 1][j - 1] + abs(sum(nums[i - k:i]) - sum(nums[i - 2 * k:i - k])),
                               dp[i - 1][j] + abs(sum(nums[i - k:i]) - sum(nums[i - k - j:i - k + j])))
    ans = float('inf')
    for j in range(1, k + 1):
        ans = min(ans, dp[nums_len][j])
    return ans

时间复杂度

双指针拆分 nums 为两个长度为 k 的子数组的时间复杂度为 O(n)。

动态规划的时间复杂度为 O(nums_lenkk)。

因此，总时间复杂度为 O(nums_lenkk)。

空间复杂度

动态规划的空间复杂度为 O(nums_len*k)。

因此，总空间复杂度为 O(nums_len*k)。

参考链接

LeetCode 题目链接：https://leetcode.com/problems/minimum-difference-between-highest-and-lowest-of-k-scores/

我的 LeetCode 题解链接：https://leetcode-cn.com/problems/minimum-difference-between-highest-and-lowest-of-k-scores/solution/zui-xiao-hua-liang-ge-k-chang-du-zi-ji-zhe-ym2m/

作者

LeetCode 题解作者：NakiriAlice

个人网站：http://www.nurserytong.com