LeetCode刷题--- 分割等和子集

前言：这个专栏主要讲述动态规划算法，所以下面题目主要也是这些算法做的  

我讲述题目会把讲解部分分为3个部分：
1、题目解析

2、算法原理思路讲解

3、代码实现

---

分割等和子集

题目链接：分割等和子集

题目

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

示例 1：

输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

示例 2：

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

提示：

• 1 <= nums.length <= 200
• 1 <= nums[i] <= 100

---

解法

算法原理与解析

我们这题使用动态规划，我们做这类题目可以分为以下五个步骤

1. 状态显示
2. 状态转移方程
3. 初始化（防止填表时不越界）
4. 填表顺序
5. 返回值

先将问题转化成我们「熟悉」的题型。

如果数组能够被分成两个相同元素之和相同的子集，那么原数组必须有下面⼏个性质：

1. 所有元素之和应该是⼀个偶数；
2. 数组中最⼤的元素应该⼩于所有元素总和的⼀半；
3. 挑选⼀些数，这些数的总和应该等于数组总和的⼀半。

根据前两个性质，我们可以提前判断数组能够被划分。根据最后⼀个性质，我们发现问题就转化成 了「01 背包」的模型：

1. 数组中的元素只能选择⼀次；
2. 每个元素⾯临被选择或者不被选择的处境；
3. 选出来的元素总和要等于所有元素总和的⼀半。

其中，数组内的元素就是物品，总和就是背包。 那么我们就可以⽤背包模型的分析⽅式，来处理这道题。

• 状态显示

dp[i][j] 表示 在前 i 个元素中选择，所有的选法中，能否凑成总和为 j 这个数。

• 状态转移方程

老规矩，根据「最后⼀个位置」的元素，结合题⽬的要求，分情况讨论：

• 不选择 nums[i] ：那么我们是否能够凑成总和为 j ，就要看在前 i - 1 个元素中选，能否凑成总和为 j 。根据状态表⽰，此时 dp[i][j] = dp[i - 1][j] ；
• 选择 nums[i] ：这种情况下是有前提条件的，此时的 nums[i] 应该是⼩于等于 j 。 因为如果这个元素都⽐要凑成的总和⼤，选择它就没有意义呀。那么我们是否能够凑成总和 为 j ，就要看在前 i - 1 个元素中选，能否凑成总和为 j - nums[i] 。根据状态表示，此时 dp[i][j] = dp[i - 1][j - nums[i]] 。

综上所述，两种情况下只要有⼀种能够凑成总和为 j ，那么这个状态就是 true 。因此，状态转移⽅程为：

dp[ i ][ j ] = dp[i - 1][ j ]

if(nums[i - 1] <= j) dp[ i ][ j ] = dp[ i ][ j ] || dp[i - 1][j - nums[i]]

• 初始化（防止填表时不越界）

由于需要⽤到上一行的数据，因此我们可以先把第⼀行初始化。

第⼀行表示不选择任何元素，要凑成目标和 j 。只有当目标和为 0 的时候才能做到，因此第⼀行仅需初始化第⼀个元素 dp[ 0][ 0 ] = true

• 填表顺序

根据「状态转移⽅程」，我们需要「从上往下」填写每⼀行，每⼀行的顺序是「无所谓的」。

• 返回值

根据「状态表示」，返回 dp[n][aim] 的值。

其中 n 表示 数组的⼤小， aim 表示 要凑的目标和。

---

代码实现 

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

#include <climits>
using namespace std;

bool canPartition(vector<int>& nums) 
{
	int n = nums.size();
	int sum = 0;

	for (int i = 0; i < n; i++) { sum += nums[i]; }		// 求出nums数组的总和
	if (sum % 2 != 0) { return false; }					// 若sum不能被整除，直接返回false
	int aim = sum / 2;
	vector<vector<bool> > dp(n+1, vector<bool>(aim + 1));	// 表示前i个元素中选择，所有的选法，能否凑成 j 这个数
	
	dp[0][0] = true;
	// for (int i = 0; i <= n; i++) { dp[i][0] = true; }	// 初始化
	// 填表，从上到下
	
	for (int i = 1; i <= n; i++) // 填表
	{
		for (int j = 1; j <= aim; j++)
		{
			dp[i][j] = dp[i - 1][j];
			if (nums[i - 1] <= j )
			{
				dp[i][j] = dp[i][j] || dp[i - 1][j - nums[i - 1]];
			}
		}
	}
		
	// 返回结果
	return dp[n][aim];
}
int main()
{
	vector<int> v = { 1,5,11,5 };

	if (canPartition(v)) { cout << "YES" << endl; }
	else { cout << "NO" << endl; }

	return 0;
}