题目描述

给定一个数组 A，大小为 n，其中每个元素都为正整数，将其划分成两个子数组 B 和 C，使得 B 中的元素之和与 C 中的元素之和的差的绝对值最小。输出这个最小的差值。

例如，一个大小为4的数组，元素为：[1, 6, 11, 5]，可以将其划分为 [1, 5] 和 [6, 11]，此时 B 中元素之和为6，C 中元素之和为17，两者之差的绝对值为11，为最小值。

算法思路

这是一道典型的 子集划分问题，可以通过 动态规划 的思想进行求解。

假设原数组为 A，则可以得到以下的状态描述：

• $f_{i,j}$：表示前 i 个元素，组成的子集和中，最接近和为 j 时，这个子集的和。
• 目标：$min(|f_{n,sum(A)/2} - sum(A)/2|)$，其中 n 为数组 A 的长度。

状态转移方程：

f[i][j] = f[i-1][j-A[i-1]]  # 加上当前元素的值
         f[i-1][j]          # 不加当前元素的值

算法实现

以下为 Python 代码实现：

def minimum_subset_sum_difference(A):
    n = len(A)
    total_sum = sum(A)
    half_sum = total_sum // 2

    # 初始化状态数组
    dp = [[False] * (half_sum + 1) for _ in range(n + 1)]
    for i in range(n + 1):
        dp[i][0] = True

    # 动态转移
    for i in range(1, n + 1):
        for j in range(1, half_sum + 1):
            if j < A[i - 1]:
                dp[i][j] = dp[i - 1][j]
            else:
                dp[i][j] = dp[i - 1][j] or dp[i - 1][j - A[i - 1]]

    # 找到最小的子集差值
    for j in range(half_sum, -1, -1):
        if dp[n][j]:
            return total_sum - j*2

    return -1

示例

输入：

A = [1, 6, 11, 5]

输出：

5

时间复杂度

该算法的时间复杂度为 $O(n * sum(A))$，其中 n 为数组 A 的长度。

空间复杂度

该算法的空间复杂度为 $O(n * sum(A))$，其中 n 为数组 A 的长度。