通过将数组拆分为两个子集，最大和的最小子集

给定一个非负整数数组 nums，你需要将它拆分成两个非空子集，使得它们的和相等。

请你判断是否存在这样的两个子集，并输出它们各自的最小值之和。

示例 1：

输入：nums = [1,5,11,5]
输出：true
解释：数组可以拆分成 [1, 5, 5] 和 [11]。
最小值之和为 6 + 11 = 17 。

示例 2：

输入：nums = [1,2,3,5]
输出：false
解释：数组不能拆分成两个元素和相等的子集。

本题可以使用动态规划（背包问题）来解决。先计算数组总和 total，并将数组升序排序，接着从 1 到 total//2 的区间尝试能不能找到一个和为 i 的子集，再从 total//2 到 1 的区间尝试能不能找到一个和为 i 的子集，如果能够找到则存在对应的拆分方案。

其中，动态规划的核心思想是定义状态和状态转移方程。状态定义为 dp[i][j]：考虑前 i 个数，能否凑出和为 j，状态转移方程为：

if j >= nums[i-1]:
    dp[i][j] = dp[i-1][j] or dp[i-1][j-nums[i-1]]
else:
    dp[i][j] = dp[i-1][j]

初始状态 dp[0][0] = True（没有数字的时候和为 0）。

下面是对应的 Python3 代码实现和详细注释：

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        n = len(nums)
        total = sum(nums)
        if total % 2 == 1:
            return False

        target = total // 2
        nums.sort()

        # 初始化状态
        dp = [[False] * (target+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, target+1):
                if j >= nums[i-1]:
                    dp[i][j] = dp[i-1][j] or dp[i-1][j-nums[i-1]]
                else:
                    dp[i][j] = dp[i-1][j]

        return dp[n][target]

上述代码的时间复杂度为 O(ntarget)，其中 n 是数组长度，target 是数组总和的一半，空间复杂度为 O(ntarget)。通过此算法，我们可以判断数组是否可以拆分成和相等的两个子集，如果可以则输出各自的最小值之和。