将非负整数数组划分为两个子集，使得两个子集的平均值相等

这个问题可以转换成在一个非负整数数组中选择一些数，使得这些数的和等于数组总和的一半。

动态规划

可以使用动态规划来解决该问题。具体地，可以定义状态 $dp[i][j]$ 表示是否可以选取前 $i$ 个数中的一些数，使得它们的和等于 $j$。状态转移方程为：

$$ dp[i][j] = dp[i-1][j] , \text{or}, dp[i-1][j-nums[i]] $$

其中，$nums[i]$ 表示数组的第 $i$ 个数。状态转移的含义是：如果不选第 $i$ 个数，则 $dp[i][j]$ 取决于前 $i-1$ 个数是否可以选取一些数，使得它们的和等于 $j$；如果选第 $i$ 个数，则 $dp[i][j]$ 取决于前 $i-1$ 个数是否可以选取一些数，使得它们的和等于 $j - nums[i]$。最终的答案即为 $dp[n][\frac{sum}{2}]$，其中 $n$ 表示数组的长度，$sum$ 表示数组的总和。

代码实现

def can_partition(nums):
    n = len(nums)
    if n == 0:
        return False
    
    # 计算数组总和
    sum = 0
    for num in nums:
        sum += num
    
    # 如果数组总和为奇数，则不能将其分为两个子集使得它们的平均值相等
    if sum % 2 != 0:
        return False
    
    # 初始化状态转移表
    dp = [[False] * (sum // 2 + 1) for _ in range(n)]
    dp[0][0] = True
    if nums[0] <= sum // 2:
        dp[0][nums[0]] = True
    
    # 状态转移
    for i in range(1, n):
        for j in range(sum // 2 + 1):
            dp[i][j] = dp[i-1][j]
            if nums[i] <= j:
                dp[i][j] = dp[i][j] or dp[i-1][j-nums[i]]
    
    return dp[n-1][sum // 2]

回溯算法

使用回溯算法也可以解决该问题。具体地，从第一个数开始，每个数有两个选择：选或不选。当选与不选两种选择都尝试完毕，回溯到上一个状态，继续选择。

代码实现

def can_partition(nums):
    n = len(nums)
    if n == 0:
        return False
    
    # 计算数组总和
    sum = 0
    for num in nums:
        sum += num
    
    # 如果数组总和为奇数，则不能将其分为两个子集使得它们的平均值相等
    if sum % 2 != 0:
        return False
    
    # 回溯求解
    def backtrack(i, target):
        if target == 0:
            return True
        if i == n or target < 0:
            return False
        
        if backtrack(i+1, target-nums[i]):
            return True
        
        if backtrack(i+1, target):
            return True
        
        return False
    
    return backtrack(0, sum // 2)

双指针

还可以使用双指针解决该问题。具体地，将数组按降序排序，然后从两端开始，分别选出一个数加入到两个子集中。如果加入一个数后某一个子集的和大于了另一个子集的和，则选取下一个数加入到另一个子集中。

代码实现

def can_partition(nums):
    n = len(nums)
    if n == 0:
        return False
    
    # 计算数组总和
    sum = 0
    for num in nums:
        sum += num
    
    # 如果数组总和为奇数，则不能将其分为两个子集使得它们的平均值相等
    if sum % 2 != 0:
        return False
    
    # 双指针求解
    nums.sort(reverse=True)
    l, r = 0, n-1
    sum1, sum2 = 0, 0
    while l <= r:
        if sum1 < sum2:
            sum1 += nums[l]
            l += 1
        else:
            sum2 += nums[r]
            r -= 1
    
    return sum1 == sum2

以上三种方法都可以解决该问题，它们的时间复杂度分别为 $O(n\times sum)$、$O(2^n)$ 和 $O(n\log n)$。其中，$sum$ 表示数组的总和。在空间复杂度上，动态规划和双指针方法的空间复杂度均为 $O(n\times sum)$，回溯算法的空间复杂度为 $O(n)$。