Jun 22, 2022 · May 23, 2022 · Jun 21, 2022 · Jun 22, 2022 · Jun 21, 2022
diff --git a/problems/0416.分割等和子集.md b/problems/0416.分割等和子集.md
Original file line number	Diff line number	Diff line change
Expand Up		@@ -416,6 +416,7 @@ var canPartition = function(nums) {
		};
		```


		TypeScript:

		```ts
Expand All		@@ -436,5 +437,163 @@ function canPartition(nums: number[]): boolean {
		```


	C:
	二维dp:
	```c
	/**
	1. dp数组含义:dp[i][j]为背包重量为j时,从[0-i]元素和最大值
	2. 递推公式:dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i])
	3. 初始化:dp[i][0]初始化为0。因为背包重量为0时,不可能放入元素。dp[0][j] = nums[0],当j >= nums[0] && j < target时
	4. 遍历顺序:先遍历物品,再遍历背包
	*/
	#define MAX(a, b) (((a) > (b)) ? (a) : (b))

	int getSum(int* nums, int numsSize) {
	int sum = 0;

	int i;
	for(i = 0; i < numsSize; ++i) {
	sum += nums[i];
	}
	return sum;
	}

	bool canPartition(int* nums, int numsSize){
	// 求出元素总和
	int sum = getSum(nums, numsSize);
	// 若元素总和为奇数,则不可能得到两个和相等的子数组
	if(sum % 2)
	return false;

	// 若子数组的和等于target,则nums可以被分割
	int target = sum / 2;
	// 初始化dp数组
	int dp[numsSize][target + 1];
	// dp[j][0]都应被设置为0。因为当背包重量为0时,不可放入元素
	memset(dp, 0, sizeof(int) * numsSize * (target + 1));

	int i, j;
	// 当背包重量j大于nums[0]时,可以在dp[0][j]中放入元素nums[0]
	for(j = nums[0]; j <= target; ++j) {
	dp[0][j] = nums[0];
	}

	for(i = 1; i < numsSize; ++i) {
	for(j = 1; j <= target; ++j) {
	// 若当前背包重量j小于nums[i],则其值等于只考虑0到i-1物品时的值
	if(j < nums[i])
	dp[i][j] = dp[i - 1][j];
	// 否则,背包重量等于在背包中放入num[i]/不放入nums[i]的较大值
	else
	dp[i][j] = MAX(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i]);
	}
	}
	// 判断背包重量为target,且考虑到所有物品时,放入的元素和是否等于target
	return dp[numsSize - 1][target] == target;
	}
	```
	滚动数组:
	```c
	/**
	1. dp数组含义:dp[j]为背包重量为j时,其中可放入元素的最大值
	2. 递推公式:dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
	3. 初始化:均初始化为0即可
	4. 遍历顺序:先遍历物品,再后序遍历背包
	*/
	#define MAX(a, b) (((a) > (b)) ? (a) : (b))

	int getSum(int* nums, int numsSize) {
	int sum = 0;

	int i;
	for(i = 0; i < numsSize; ++i) {
	sum += nums[i];
	}
	return sum;
	}

	bool canPartition(int* nums, int numsSize){
	// 求出元素总和
	int sum = getSum(nums, numsSize);
	// 若元素总和为奇数,则不可能得到两个和相等的子数组
	if(sum % 2)
	return false;
	// 背包容量
	int target = sum / 2;

	// 初始化dp数组,元素均为0
	int dp[target + 1];
	memset(dp, 0, sizeof(int) * (target + 1));

	int i, j;
	// 先遍历物品,后遍历背包
	for(i = 0; i < numsSize; ++i) {
	for(j = target; j >= nums[i]; --j) {
	dp[j] = MAX(dp[j], dp[j - nums[i]] + nums[i]);
	}
	}

	// 查看背包容量为target时,元素总和是否等于target
	return dp[target] == target;
	}
	```

	TypeScript:

	> 一维数组,简洁

	```typescript
	function canPartition(nums: number[]): boolean {
	const sum: number = nums.reduce((pre, cur) => pre + cur);
	if (sum % 2 === 1) return false;
	const bagSize: number = sum / 2;
	const goodsNum: number = nums.length;
	const dp: number[] = new Array(bagSize + 1).fill(0);
	for (let i = 0; i < goodsNum; i++) {
	for (let j = bagSize; j >= nums[i]; j--) {
	dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
	}
	}
	return dp[bagSize] === bagSize;
	};
	```

	> 二维数组,易懂

	```typescript
	function canPartition(nums: number[]): boolean {
	/**
	weightArr = nums;
	valueArr = nums;
	bagSize = sum / 2; (sum为nums各元素总和);
	按照0-1背包处理
	*/
	const sum: number = nums.reduce((pre, cur) => pre + cur);
	if (sum % 2 === 1) return false;
	const bagSize: number = sum / 2;
	const weightArr: number[] = nums;
	const valueArr: number[] = nums;
	const goodsNum: number = weightArr.length;
	const dp: number[][] = new Array(goodsNum)
	.fill(0)
	.map(_ => new Array(bagSize + 1).fill(0));
	for (let i = weightArr[0]; i <= bagSize; i++) {
	dp[0][i] = valueArr[0];
	}
	for (let i = 1; i < goodsNum; i++) {
	for (let j = 0; j <= bagSize; j++) {
	if (j < weightArr[i]) {
	dp[i][j] = dp[i - 1][j];
	} else {
	dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weightArr[i]] + valueArr[i]);
	}
	}
	}
	return dp[goodsNum - 1][bagSize] === bagSize;
	};
	```



		-----------------------
		<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>